diff options
| author | phaller <hallerp@gmail.com> | 2012-05-01 11:59:08 +0200 |
|---|---|---|
| committer | phaller <hallerp@gmail.com> | 2012-05-01 11:59:08 +0200 |
| commit | de4b03d25c0e6571ca628d58ad84ca90b78f625e (patch) | |
| tree | 21e1fb66b6bfab2d68eabf0570c66296444bbb90 /src | |
| parent | bec8ade7e1beb03bcc07f702dceda8852038e517 (diff) | |
| parent | cfd037271ebf96b977d4ef06dbcd7814cfcc20a0 (diff) | |
| download | scala-de4b03d25c0e6571ca628d58ad84ca90b78f625e.tar.gz scala-de4b03d25c0e6571ca628d58ad84ca90b78f625e.tar.bz2 scala-de4b03d25c0e6571ca628d58ad84ca90b78f625e.zip | |
Merge branch 'master' into wip-sip14-fixes
Diffstat (limited to 'src')
360 files changed, 6702 insertions, 7852 deletions
diff --git a/src/build/genprod.scala b/src/build/genprod.scala index 6016f6fb92..8c91128de0 100644 --- a/src/build/genprod.scala +++ b/src/build/genprod.scala @@ -130,7 +130,7 @@ object FunctionOne extends Function(1) { * @param g a function A => T1 * @return a new function `f` such that `f(x) == apply(g(x))` */ - def compose[A](g: A => T1): A => R = { x => apply(g(x)) } + @annotation.unspecialized def compose[A](g: A => T1): A => R = { x => apply(g(x)) } /** Composes two instances of Function1 in a new Function1, with this function applied first. * @@ -138,7 +138,7 @@ object FunctionOne extends Function(1) { * @param g a function R => A * @return a new function `f` such that `f(x) == g(apply(x))` */ - def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) } + @annotation.unspecialized def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) } """ } @@ -169,19 +169,20 @@ object Function { class Function(val i: Int) extends Group("Function") with Arity { def descriptiveComment = "" - def functionNTemplate = """ + def functionNTemplate = +""" * In the following example, the definition of %s is a * shorthand for the anonymous class definition %s: * * {{{ - * object Main extends App { %s } + * object Main extends App {%s} * }}} * * Note that `Function1` does not define a total function, as might * be suggested by the existence of [[scala.PartialFunction]]. The only * distinction between `Function1` and `PartialFunction` is that the * latter can specify inputs which it will not handle. - """ +""" def toStr() = "\"" + ("<function%d>" format i) + "\"" def apply() = { @@ -195,7 +196,7 @@ class Function(val i: Int) extends Group("Function") with Arity { * @return the result of function application. */ def apply({funArgs}): R - {moreMethods} +{moreMethods} override def toString() = {toStr} }} </file> @@ -218,15 +219,15 @@ class Function(val i: Int) extends Group("Function") with Arity { // f(x1,x2,x3,x4,x5,x6) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6) def curryComment = { -"""/** Creates a curried version of this function. +""" /** Creates a curried version of this function. * * @return a function `f` such that `f%s == apply%s` */""".format(xdefs map ("(" + _ + ")") mkString, commaXs) } def tupleMethod = { - def comment = """ - /** Creates a tupled version of this function: instead of %d arguments, + def comment = +""" /** Creates a tupled version of this function: instead of %d arguments, * it accepts a single [[scala.Tuple%d]] argument. * * @return a function `f` such that `f(%s) == f(Tuple%d%s) == apply%s` @@ -234,14 +235,14 @@ class Function(val i: Int) extends Group("Function") with Arity { """.format(i, i, commaXs, i, commaXs, commaXs) def body = "case Tuple%d%s => apply%s".format(i, commaXs, commaXs) - comment + " def tupled: Tuple%d%s => R = {\n %s\n }".format(i, invariantArgs, body) + comment + "\n @annotation.unspecialized def tupled: Tuple%d%s => R = {\n %s\n }".format(i, invariantArgs, body) } def curryMethod = { val body = if (i < 5) shortCurry else longCurry curryComment + - " def curried: %s => R = {\n %s\n }\n".format( + "\n @annotation.unspecialized def curried: %s => R = {\n %s\n }\n".format( targs mkString " => ", body ) } @@ -255,10 +256,7 @@ class Function(val i: Int) extends Group("Function") with Arity { zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz */ object Tuple { - val zipImports = """ -import scala.collection.{ TraversableLike => TLike, IterableLike => ILike } -import scala.collection.generic.{ CanBuildFrom => CBF } -""" + val zipImports = "" def make(i: Int) = apply(i)() def apply(i: Int) = i match { @@ -284,230 +282,11 @@ object TupleTwo extends Tuple(2) * second element is the first element of this Tuple. */ def swap: Tuple2[T2,T1] = Tuple2(_2, _1) - - @deprecated("Use `zipped` instead.", "2.9.0") - def zip[Repr1, El1, El2, To](implicit w1: T1 => TLike[El1, Repr1], - w2: T2 => Iterable[El2], - cbf1: CBF[Repr1, (El1, El2), To]): To = { - zipped map ((x, y) => ((x, y))) - } - - /** Wraps a tuple in a `Zipped`, which supports 2-ary generalisations of `map`, `flatMap`, `filter`, etc. - * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]] - * or [[scala.collection.IterableLike]]. - * {{{ - * scala> val tuple = (List(1,2,3),List('a','b','c')) - * tuple: (List[Int], List[Char]) = (List(1, 2, 3),List(a, b, c)) - * - * scala> tuple.zipped map { (x,y) => x + ":" + y } - * res6: List[java.lang.String] = List(1:a, 2:b, 3:c) - * }}} - * - * @see Zipped - * Note: will not terminate for infinite-sized collections. - */ - def zipped[Repr1, El1, Repr2, El2](implicit w1: T1 => TLike[El1, Repr1], w2: T2 => ILike[El2, Repr2]): Zipped[Repr1, El1, Repr2, El2] - = new Zipped[Repr1, El1, Repr2, El2](_1, _2) - - class Zipped[+Repr1, +El1, +Repr2, +El2](coll1: TLike[El1, Repr1], coll2: ILike[El2, Repr2]) { // coll2: ILike for filter - def map[B, To](f: (El1, El2) => B)(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - b.sizeHint(coll1) - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) - b += f(el1, elems2.next) - else - return b.result - } - - b.result - } - - def flatMap[B, To](f: (El1, El2) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) - b ++= f(el1, elems2.next) - else - return b.result - } - - b.result - } - - def filter[To1, To2](f: (El1, El2) => Boolean)(implicit cbf1: CBF[Repr1, El1, To1], cbf2: CBF[Repr2, El2, To2]): (To1, To2) = { - val b1 = cbf1(coll1.repr) - val b2 = cbf2(coll2.repr) - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) { - val el2 = elems2.next - if (f(el1, el2)) { - b1 += el1 - b2 += el2 - } - } - else return (b1.result, b2.result) - } - - (b1.result, b2.result) - } - - def exists(f: (El1, El2) => Boolean): Boolean = { - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) { - if (f(el1, elems2.next)) - return true - } - else return false - } - false - } - - def forall(f: (El1, El2) => Boolean): Boolean = - !exists((x, y) => !f(x, y)) - - def foreach[U](f: (El1, El2) => U): Unit = { - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) - f(el1, elems2.next) - else - return - } - } - } """ } object TupleThree extends Tuple(3) { override def imports = Tuple.zipImports - override def moreMethods = """ - - @deprecated("Use `zipped` instead.", "2.9.0") - def zip[Repr1, El1, El2, El3, To](implicit w1: T1 => TLike[El1, Repr1], - w2: T2 => Iterable[El2], - w3: T3 => Iterable[El3], - cbf1: CBF[Repr1, (El1, El2, El3), To]): To = { - zipped map ((x, y, z) => ((x, y, z))) - } - - /** Wraps a tuple in a `Zipped`, which supports 3-ary generalisations of `map`, `flatMap`, `filter`, etc. - * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]] - * or [[scala.collection.IterableLike]]. - * {{{ - * scala> val tuple = (List(1,2,3),List('a','b','c'),List("x","y","z")) - * tuple: (List[Int], List[Char], List[java.lang.String]) = (List(1, 2, 3),List(a, b, c),List(x, y, z)) - * - * scala> tuple.zipped map { (x,y,z) => x + ":" + y + ":" + z} - * res8: List[java.lang.String] = List(1:a:x, 2:b:y, 3:c:z) - * }}} - * - * @see Zipped - * Note: will not terminate for infinite-sized collections. - */ - def zipped[Repr1, El1, Repr2, El2, Repr3, El3](implicit w1: T1 => TLike[El1, Repr1], - w2: T2 => ILike[El2, Repr2], - w3: T3 => ILike[El3, Repr3]): Zipped[Repr1, El1, Repr2, El2, Repr3, El3] - = new Zipped[Repr1, El1, Repr2, El2, Repr3, El3](_1, _2, _3) - - class Zipped[+Repr1, +El1, +Repr2, +El2, +Repr3, +El3](coll1: TLike[El1, Repr1], - coll2: ILike[El2, Repr2], - coll3: ILike[El3, Repr3]) { - def map[B, To](f: (El1, El2, El3) => B)(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) - b += f(el1, elems2.next, elems3.next) - else - return b.result - } - b.result - } - - def flatMap[B, To](f: (El1, El2, El3) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) - b ++= f(el1, elems2.next, elems3.next) - else - return b.result - } - b.result - } - - def filter[To1, To2, To3](f: (El1, El2, El3) => Boolean)( - implicit cbf1: CBF[Repr1, El1, To1], - cbf2: CBF[Repr2, El2, To2], - cbf3: CBF[Repr3, El3, To3]): (To1, To2, To3) = { - val b1 = cbf1(coll1.repr) - val b2 = cbf2(coll2.repr) - val b3 = cbf3(coll3.repr) - val elems2 = coll2.iterator - val elems3 = coll3.iterator - def result = (b1.result, b2.result, b3.result) - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) { - val el2 = elems2.next - val el3 = elems3.next - - if (f(el1, el2, el3)) { - b1 += el1 - b2 += el2 - b3 += el3 - } - } - else return result - } - - result - } - - def exists(f: (El1, El2, El3) => Boolean): Boolean = { - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) { - if (f(el1, elems2.next, elems3.next)) - return true - } - else return false - } - false - } - - def forall(f: (El1, El2, El3) => Boolean): Boolean = - !exists((x, y, z) => !f(x, y, z)) - - def foreach[U](f: (El1, El2, El3) => U): Unit = { - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) - f(el1, elems2.next, elems3.next) - else - return - } - } - } -""" } class Tuple(val i: Int) extends Group("Tuple") with Arity { @@ -578,7 +357,7 @@ class Product(val i: Int) extends Group("Product") with Arity { * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ """ diff --git a/src/build/maven/maven-deploy.xml b/src/build/maven/maven-deploy.xml index 7f8343a84e..ac0f8f745b 100644 --- a/src/build/maven/maven-deploy.xml +++ b/src/build/maven/maven-deploy.xml @@ -112,7 +112,6 @@ <deploy-local name="scala-compiler" version="@{version}" repository="@{repository}" /> <deploy-local-plugin name="continuations" version="@{version}" repository="@{repository}"/> <deploy-local name="scala-actors" version="@{version}" repository="@{repository}" /> - <deploy-local name="scala-dbc" version="@{version}" repository="@{repository}" /> <deploy-local name="scala-swing" version="@{version}" repository="@{repository}"/> <deploy-local name="scalap" version="@{version}" repository="@{repository}"/> <deploy-local name="scala-partest" version="@{version}" repository="@{repository}"/> @@ -171,7 +170,6 @@ </deploy-remote> <deploy-remote name="jline" version="@{version}" repository="@{repository}"/> <deploy-remote name="scala-compiler" version="@{version}" repository="@{repository}" /> - <deploy-remote name="scala-dbc" version="@{version}" repository="@{repository}" /> <deploy-remote name="scala-swing" version="@{version}" repository="@{repository}"/> <deploy-remote name="scala-actors" version="@{version}" repository="@{repository}"/> <deploy-remote name="scalap" version="@{version}" repository="@{repository}"/> @@ -239,7 +237,6 @@ <deploy-remote-signed name="scala-library" version="@{version}" repository="@{repository}"/> <deploy-remote-signed name="jline" version="@{version}" repository="@{repository}"/> <deploy-remote-signed name="scala-compiler" version="@{version}" repository="@{repository}" /> - <deploy-remote-signed name="scala-dbc" version="@{version}" repository="@{repository}" /> <deploy-remote-signed name="scala-swing" version="@{version}" repository="@{repository}"/> <deploy-remote-signed name="scala-actors" version="@{version}" repository="@{repository}"/> <deploy-remote-signed name="scalap" version="@{version}" repository="@{repository}"/> diff --git a/src/build/maven/scala-dbc-pom.xml b/src/build/maven/scala-dbc-pom.xml deleted file mode 100644 index aa3d050c1e..0000000000 --- a/src/build/maven/scala-dbc-pom.xml +++ /dev/null @@ -1,61 +0,0 @@ -<project - xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" - xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> - <modelVersion>4.0.0</modelVersion> - <groupId>org.scala-lang</groupId> - <artifactId>scala-dbc</artifactId> - <packaging>jar</packaging> - <version>@VERSION@</version> - <name>Scala Database Connectivity</name> - <description>Connectivity for your DBs</description> - <url>http://www.scala-lang.org/</url> - <inceptionYear>2002</inceptionYear> - <organization> - <name>LAMP/EPFL</name> - <url>http://lamp.epfl.ch/</url> - </organization> - <licenses> - <license> - <name>BSD-like</name> - <url>http://www.scala-lang.org/downloads/license.html - </url> - <distribution>repo</distribution> - </license> - </licenses> - <scm> - <connection>scm:git:git://github.com/scala/scala.git</connection> - <url>https://github.com/scala/scala.git</url> - </scm> - <issueManagement> - <system>JIRA</system> - <url>https://issues.scala-lang.org/</url> - </issueManagement> - <dependencies> - <dependency> - <groupId>org.scala-lang</groupId> - <artifactId>scala-library</artifactId> - <version>@VERSION@</version> - </dependency> - </dependencies> - <distributionManagement> - <repository> - <id>scala-tools.org</id> - <url>@RELEASE_REPOSITORY@</url> - </repository> - <snapshotRepository> - <id>scala-tools.org</id> - <url>@SNAPSHOT_REPOSITORY@</url> - <uniqueVersion>false</uniqueVersion> - </snapshotRepository> - </distributionManagement> - <developers> - <developer> - <id>lamp</id> - <name>EPFL LAMP</name> - </developer> - <developer> - <id>Typesafe</id> - <name>Typesafe, Inc.</name> - </developer> - </developers> -</project> diff --git a/src/build/maven/scala-library-pom.xml b/src/build/maven/scala-library-pom.xml index c3f8a4531c..e8db512125 100644 --- a/src/build/maven/scala-library-pom.xml +++ b/src/build/maven/scala-library-pom.xml @@ -32,9 +32,9 @@ </issueManagement> <dependencies> <dependency> - <groupId>org.skife.com.typesafe.config</groupId> - <artifactId>typesafe-config</artifactId> - <version>0.3.0</version> + <groupId>com.typesafe</groupId> + <artifactId>config</artifactId> + <version>0.4.0</version> </dependency> </dependencies> <distributionManagement> diff --git a/src/build/pack.xml b/src/build/pack.xml index 3bd4d7a199..f96c6b9799 100644 --- a/src/build/pack.xml +++ b/src/build/pack.xml @@ -137,7 +137,6 @@ MAIN DISTRIBUTION PACKAGING <mvn-copy-lib mvn.artifact.name="jline"/> <mvn-copy-lib mvn.artifact.name="scala-library"/> <mvn-copy-lib mvn.artifact.name="scala-compiler"/> - <mvn-copy-lib mvn.artifact.name="scala-dbc"/> <mvn-copy-lib mvn.artifact.name="scala-swing"/> <mvn-copy-lib mvn.artifact.name="scala-actors"/> <mvn-copy-lib mvn.artifact.name="scala-partest"/> @@ -202,11 +201,9 @@ MAIN DISTRIBUTION PACKAGING basedir="${build-docs.dir}/continuations-plugin"> <include name="**/*"/> </jar> - <!-- TODO - Scala swing, dbc and actors should maybe have thier own jar, but creating it is SLOW. --> + <!-- TODO - Scala swing and actors should maybe have thier own jar, but creating it is SLOW. --> <copy tofile="${dists.dir}/maven/${version.number}/scala-swing/scala-swing-docs.jar" file="${dists.dir}/maven/${version.number}/scala-library/scala-library-docs.jar"/> - <copy tofile="${dists.dir}/maven/${version.number}/scala-dbc/scala-dbc-docs.jar" - file="${dists.dir}/maven/${version.number}/scala-library/scala-library-docs.jar"/> <copy tofile="${dists.dir}/maven/${version.number}/scala-actors/scala-actors-docs.jar" file="${dists.dir}/maven/${version.number}/scala-library/scala-library-docs.jar"/> </target> diff --git a/src/compiler/scala/reflect/internal/AnnotationInfos.scala b/src/compiler/scala/reflect/internal/AnnotationInfos.scala index b86c62661a..fe0175fe72 100644 --- a/src/compiler/scala/reflect/internal/AnnotationInfos.scala +++ b/src/compiler/scala/reflect/internal/AnnotationInfos.scala @@ -260,8 +260,7 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable => } } - lazy val classfileAnnotArgManifest: ClassManifest[ClassfileAnnotArg] = - reflect.ClassManifest[ClassfileAnnotArg](classOf[ClassfileAnnotArg]) + lazy val classfileAnnotArgTag: ArrayTag[ClassfileAnnotArg] = arrayTag[ClassfileAnnotArg] object UnmappableAnnotation extends CompleteAnnotationInfo(NoType, Nil, Nil) } diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala index 72fca5da12..9e28319882 100644 --- a/src/compiler/scala/reflect/internal/Definitions.scala +++ b/src/compiler/scala/reflect/internal/Definitions.scala @@ -15,6 +15,8 @@ import scala.reflect.{ mirror => rm } trait Definitions extends reflect.api.StandardDefinitions { self: SymbolTable => + object definitions extends DefinitionsClass + // [Eugene] find a way to make these non-lazy lazy val ByteTpe = definitions.ByteClass.asType lazy val ShortTpe = definitions.ShortClass.asType @@ -41,34 +43,21 @@ trait Definitions extends reflect.api.StandardDefinitions { */ private type PolyMethodCreator = List[Symbol] => (Option[List[Type]], Type) - private def enterNewClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): Symbol = { + private def enterNewClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): ClassSymbol = { val clazz = owner.newClassSymbol(name, NoPosition, flags) clazz setInfoAndEnter ClassInfoType(parents, newScope, clazz) } - private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): Symbol = { + private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): MethodSymbol = { val msym = owner.newMethod(name.encode, NoPosition, flags) val params = msym.newSyntheticValueParams(formals) msym setInfo MethodType(params, restpe) } - private def enterNewMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): Symbol = + private def enterNewMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): MethodSymbol = owner.info.decls enter newMethod(owner, name, formals, restpe, flags) // the scala value classes trait ValueClassDefinitions { - self: definitions.type => - - private[Definitions] def valueCache(name: Name) = { - val res = ( - if (name.isTypeName) ScalaPackageClass.info member name - else ScalaPackageClass.info member name suchThat (_ hasFlag MODULE) - ) - if (res eq NoSymbol) - abort("Could not find value classes! This is a catastrophic failure. scala " + scala.util.Properties.versionString) - else res - } - private[Definitions] def valueModuleMethod(className: Name, methodName: Name): Symbol = { - valueCache(className.toTermName).moduleClass.tpe member methodName - } + self: DefinitionsClass => import ClassfileConstants._ @@ -94,8 +83,27 @@ trait Definitions extends reflect.api.StandardDefinitions { tpnme.Unit -> VOID_TAG ) + private def catastrophicFailure() = + abort("Could not find value classes! This is a catastrophic failure. scala " + + scala.util.Properties.versionString) + + private def valueClassSymbol(name: TypeName): ClassSymbol = { + getMember(ScalaPackageClass, name) match { + case x: ClassSymbol => x + case _ => catastrophicFailure() + } + } + private def valueClassCompanion(name: TermName): ModuleSymbol = { + getMember(ScalaPackageClass, name) match { + case x: ModuleSymbol => x + case _ => catastrophicFailure() + } + } + private def valueCompanionMember(className: Name, methodName: TermName): MethodSymbol = + getMemberMethod(valueClassCompanion(className.toTermName).moduleClass, methodName) + private def classesMap[T](f: Name => T) = symbolsMap(ScalaValueClassesNoUnit, f) - private def symbolsMap[T](syms: List[Symbol], f: Name => T): Map[Symbol, T] = syms zip (syms map (x => f(x.name))) toMap + private def symbolsMap[T](syms: List[Symbol], f: Name => T): Map[Symbol, T] = mapFrom(syms)(x => f(x.name)) private def symbolsMapFilt[T](syms: List[Symbol], p: Name => Boolean, f: Name => T) = symbolsMap(syms filter (x => p(x.name)), f) private def boxedName(name: Name) = sn.Boxed(name.toTypeName) @@ -106,8 +114,8 @@ trait Definitions extends reflect.api.StandardDefinitions { lazy val boxedClass = classesMap(x => getClass(boxedName(x))) lazy val refClass = classesMap(x => getRequiredClass("scala.runtime." + x + "Ref")) lazy val volatileRefClass = classesMap(x => getRequiredClass("scala.runtime.Volatile" + x + "Ref")) - lazy val boxMethod = classesMap(x => valueModuleMethod(x, nme.box)) - lazy val unboxMethod = classesMap(x => valueModuleMethod(x, nme.unbox)) + lazy val boxMethod = classesMap(x => valueCompanionMember(x, nme.box)) + lazy val unboxMethod = classesMap(x => valueCompanionMember(x, nme.unbox)) def isNumericSubClass(sub: Symbol, sup: Symbol) = ( (numericWeight contains sub) @@ -116,27 +124,28 @@ trait Definitions extends reflect.api.StandardDefinitions { ) /** Is symbol a numeric value class? */ - def isNumericValueClass(sym: Symbol): Boolean = - numericWeight contains sym + def isNumericValueClass(sym: Symbol) = ScalaNumericValueClasses contains sym def isGetClass(sym: Symbol) = - (sym.name == nme.getClass_) && (sym.paramss.isEmpty || sym.paramss.head.isEmpty) - - lazy val UnitClass = valueCache(tpnme.Unit) - lazy val ByteClass = valueCache(tpnme.Byte) - lazy val ShortClass = valueCache(tpnme.Short) - lazy val CharClass = valueCache(tpnme.Char) - lazy val IntClass = valueCache(tpnme.Int) - lazy val LongClass = valueCache(tpnme.Long) - lazy val FloatClass = valueCache(tpnme.Float) - lazy val DoubleClass = valueCache(tpnme.Double) - lazy val BooleanClass = valueCache(tpnme.Boolean) + (sym.name == nme.getClass_) && flattensToEmpty(sym.paramss) + + lazy val UnitClass = valueClassSymbol(tpnme.Unit) + lazy val ByteClass = valueClassSymbol(tpnme.Byte) + lazy val ShortClass = valueClassSymbol(tpnme.Short) + lazy val CharClass = valueClassSymbol(tpnme.Char) + lazy val IntClass = valueClassSymbol(tpnme.Int) + lazy val LongClass = valueClassSymbol(tpnme.Long) + lazy val FloatClass = valueClassSymbol(tpnme.Float) + lazy val DoubleClass = valueClassSymbol(tpnme.Double) + lazy val BooleanClass = valueClassSymbol(tpnme.Boolean) lazy val Boolean_and = getMember(BooleanClass, nme.ZAND) lazy val Boolean_or = getMember(BooleanClass, nme.ZOR) lazy val Boolean_not = getMember(BooleanClass, nme.UNARY_!) + lazy val ScalaNumericValueClasses = ScalaValueClasses filterNot Set[Symbol](UnitClass, BooleanClass) + def ScalaValueClassesNoUnit = ScalaValueClasses filterNot (_ eq UnitClass) - def ScalaValueClasses: List[Symbol] = List( + def ScalaValueClasses: List[ClassSymbol] = List( UnitClass, BooleanClass, ByteClass, @@ -148,10 +157,10 @@ trait Definitions extends reflect.api.StandardDefinitions { DoubleClass ) def ScalaValueClassCompanions: List[Symbol] = ScalaValueClasses map (_.companionSymbol) - def ScalaPrimitiveValueClasses: List[Symbol] = ScalaValueClasses + def ScalaPrimitiveValueClasses: List[ClassSymbol] = ScalaValueClasses } - object definitions extends AbsDefinitions with ValueClassDefinitions { + abstract class DefinitionsClass extends AbsDefinitions with ValueClassDefinitions { private var isInitialized = false def isDefinitionsInitialized = isInitialized @@ -207,15 +216,14 @@ trait Definitions extends reflect.api.StandardDefinitions { } // It becomes tricky to create dedicated objects for other symbols because // of initialization order issues. - lazy val JavaLangPackage = getModule(sn.JavaLang) + lazy val JavaLangPackage = getRequiredPackage(sn.JavaLang) lazy val JavaLangPackageClass = JavaLangPackage.moduleClass - lazy val ScalaPackage = getModule(nme.scala_) + lazy val ScalaPackage = getRequiredPackage(nme.scala_) lazy val ScalaPackageClass = ScalaPackage.moduleClass - - lazy val RuntimePackage = getRequiredModule("scala.runtime") + lazy val RuntimePackage = getRequiredPackage("scala.runtime") lazy val RuntimePackageClass = RuntimePackage.moduleClass - lazy val JavaLangEnumClass = getRequiredClass("java.lang.Enum") + lazy val JavaLangEnumClass = requiredClass[java.lang.Enum[_]] // convenient one-argument parameter lists lazy val anyparam = List(AnyClass.tpe) @@ -268,9 +276,9 @@ trait Definitions extends reflect.api.StandardDefinitions { } // top types - lazy val AnyClass = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT) - lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.tpe) - lazy val ObjectClass = getClass(sn.Object) + lazy val AnyClass = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT) + lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.tpe) + lazy val ObjectClass = getRequiredClass(sn.Object.toString) // Note: this is not the type alias AnyRef, it's a companion-like // object used by the @specialize annotation. @@ -278,12 +286,13 @@ trait Definitions extends reflect.api.StandardDefinitions { @deprecated("Use AnyRefModule", "2.10.0") def Predef_AnyRef = AnyRefModule - lazy val AnyValClass = ScalaPackageClass.info member tpnme.AnyVal orElse { + lazy val AnyValClass: ClassSymbol = (ScalaPackageClass.info member tpnme.AnyVal orElse { val anyval = enterNewClass(ScalaPackageClass, tpnme.AnyVal, List(AnyClass.tpe, NotNullClass.tpe), ABSTRACT) val av_constr = anyval.newClassConstructor(NoPosition) anyval.info.decls enter av_constr anyval - } + }).asInstanceOf[ClassSymbol] + lazy val AnyVal_getClass = enterNewMethod(AnyValClass, nme.getClass_, Nil, getClassReturnType(AnyValClass.tpe)) // bottom types @@ -292,7 +301,7 @@ trait Definitions extends reflect.api.StandardDefinitions { sealed abstract class BottomClassSymbol(name: TypeName, parent: Symbol) extends ClassSymbol(ScalaPackageClass, NoPosition, name) { locally { - this initFlags ABSTRACT | TRAIT | FINAL + this initFlags ABSTRACT | FINAL this setInfoAndEnter ClassInfoType(List(parent.tpe), newScope, this) } final override def isBottomClass = true @@ -308,24 +317,24 @@ trait Definitions extends reflect.api.StandardDefinitions { } // exceptions and other throwables - lazy val ClassCastExceptionClass = getRequiredClass("java.lang.ClassCastException") + lazy val ClassCastExceptionClass = requiredClass[ClassCastException] lazy val IndexOutOfBoundsExceptionClass = getClass(sn.IOOBException) lazy val InvocationTargetExceptionClass = getClass(sn.InvTargetException) - lazy val MatchErrorClass = getRequiredClass("scala.MatchError") - lazy val NonLocalReturnControlClass = getRequiredClass("scala.runtime.NonLocalReturnControl") + lazy val MatchErrorClass = requiredClass[MatchError] + lazy val NonLocalReturnControlClass = requiredClass[scala.runtime.NonLocalReturnControl[_]] lazy val NullPointerExceptionClass = getClass(sn.NPException) lazy val ThrowableClass = getClass(sn.Throwable) - lazy val UninitializedErrorClass = getRequiredClass("scala.UninitializedFieldError") + lazy val UninitializedErrorClass = requiredClass[UninitializedFieldError] // fundamental reference classes - lazy val PartialFunctionClass = getRequiredClass("scala.PartialFunction") + lazy val PartialFunctionClass = requiredClass[PartialFunction[_,_]] lazy val AbstractPartialFunctionClass = getRequiredClass("scala.runtime.AbstractPartialFunction") lazy val SymbolClass = getRequiredClass("scala.Symbol") - lazy val StringClass = getClass(sn.String) + lazy val StringClass = requiredClass[java.lang.String] lazy val StringModule = StringClass.linkedClassOfClass - lazy val ClassClass = getClass(sn.Class) + lazy val ClassClass = getRequiredClass("java.lang.Class") def Class_getMethod = getMember(ClassClass, nme.getMethod_) - lazy val DynamicClass = getRequiredClass("scala.Dynamic") + lazy val DynamicClass = requiredClass[Dynamic] // fundamental modules lazy val SysPackage = getPackageObject("scala.sys") @@ -336,14 +345,14 @@ trait Definitions extends reflect.api.StandardDefinitions { // Those modules and their module classes lazy val UnqualifiedOwners = UnqualifiedModules.toSet ++ UnqualifiedModules.map(_.moduleClass) - lazy val PredefModule: Symbol = getRequiredModule("scala.Predef") + lazy val PredefModule = requiredModule[scala.Predef.type] lazy val PredefModuleClass = PredefModule.moduleClass - def Predef_classOf = getMember(PredefModule, nme.classOf) - def Predef_identity = getMember(PredefModule, nme.identity) - def Predef_conforms = getMember(PredefModule, nme.conforms) + def Predef_classOf = getMember(PredefModule, nme.classOf) + def Predef_identity = getMember(PredefModule, nme.identity) + def Predef_conforms = getMember(PredefModule, nme.conforms) def Predef_wrapRefArray = getMember(PredefModule, nme.wrapRefArray) - def Predef_??? = getMember(PredefModule, nme.???) + def Predef_??? = getMember(PredefModule, nme.???) /** Is `sym` a member of Predef with the given name? * Note: DON't replace this by sym == Predef_conforms/etc, as Predef_conforms is a `def` @@ -356,8 +365,8 @@ trait Definitions extends reflect.api.StandardDefinitions { /** Specialization. */ - lazy val SpecializableModule = getRequiredModule("scala.Specializable") - lazy val GroupOfSpecializable = SpecializableModule.info.member(newTypeName("Group")) + lazy val SpecializableModule = requiredModule[Specializable] + lazy val GroupOfSpecializable = getMember(SpecializableModule, tpnme.Group) lazy val ConsoleModule: Symbol = getRequiredModule("scala.Console") lazy val ScalaRunTimeModule: Symbol = getRequiredModule("scala.runtime.ScalaRunTime") @@ -371,6 +380,8 @@ trait Definitions extends reflect.api.StandardDefinitions { def arrayCloneMethod = getMember(ScalaRunTimeModule, nme.array_clone) def ensureAccessibleMethod = getMember(ScalaRunTimeModule, nme.ensureAccessible) def scalaRuntimeSameElements = getMember(ScalaRunTimeModule, nme.sameElements) + def arrayClassMethod = getMember(ScalaRunTimeModule, nme.arrayClass) + def arrayElementClassMethod = getMember(ScalaRunTimeModule, nme.arrayElementClass) // classes with special meanings lazy val StringAddClass = getRequiredClass("scala.runtime.StringAdd") @@ -379,7 +390,7 @@ trait Definitions extends reflect.api.StandardDefinitions { lazy val NotNullClass = getRequiredClass("scala.NotNull") lazy val ScalaNumberClass = getRequiredClass("scala.math.ScalaNumber") lazy val TraitSetterAnnotationClass = getRequiredClass("scala.runtime.TraitSetter") - lazy val DelayedInitClass = getRequiredClass("scala.DelayedInit") + lazy val DelayedInitClass = requiredClass[scala.DelayedInit] def delayedInitMethod = getMember(DelayedInitClass, nme.delayedInit) // a dummy value that communicates that a delayedInit call is compiler-generated // from phase UnCurry to phase Constructors @@ -401,6 +412,8 @@ trait Definitions extends reflect.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)) + lazy val MarkerCPSTypes = getClassIfDefined("scala.util.continuations.cpsParam") + def isByNameParamType(tp: Type) = tp.typeSymbol == ByNameParamClass def isScalaRepeatedParamType(tp: Type) = tp.typeSymbol == RepeatedParamClass def isJavaRepeatedParamType(tp: Type) = tp.typeSymbol == JavaRepeatedParamClass @@ -456,8 +469,8 @@ trait Definitions extends reflect.api.StandardDefinitions { lazy val Array_clone = getMember(ArrayClass, nme.clone_) // reflection / structural types - lazy val SoftReferenceClass = getRequiredClass("java.lang.ref.SoftReference") - lazy val WeakReferenceClass = getRequiredClass("java.lang.ref.WeakReference") + lazy val SoftReferenceClass = requiredClass[java.lang.ref.SoftReference[_]] + lazy val WeakReferenceClass = requiredClass[java.lang.ref.WeakReference[_]] lazy val MethodClass = getClass(sn.MethodAsObject) def methodClass_setAccessible = getMember(MethodClass, nme.setAccessible) lazy val EmptyMethodCacheClass = getRequiredClass("scala.runtime.EmptyMethodCache") @@ -468,7 +481,16 @@ trait Definitions extends reflect.api.StandardDefinitions { // scala.reflect lazy val ReflectPackageClass = getMember(ScalaPackageClass, nme.reflect) lazy val ReflectPackage = getPackageObject("scala.reflect") - def Reflect_mirror = getMember(ReflectPackage, nme.mirror) + def ReflectMirror = getMember(ReflectPackage, nme.mirror) + // [Eugene] is this a good place for ReflectMirrorPrefix? + def ReflectMirrorPrefix = gen.mkAttributedRef(ReflectMirror) setType singleType(ReflectMirror.owner.thisPrefix, ReflectMirror) + + lazy val PartialManifestClass = getRequiredClass("scala.reflect.ClassManifest") + lazy val PartialManifestModule = getRequiredModule("scala.reflect.ClassManifest") + lazy val FullManifestClass = getRequiredClass("scala.reflect.Manifest") + lazy val FullManifestModule = getRequiredModule("scala.reflect.Manifest") + lazy val OptManifestClass = getRequiredClass("scala.reflect.OptManifest") + lazy val NoManifest = getRequiredModule("scala.reflect.NoManifest") lazy val ExprClass = getMember(getRequiredClass("scala.reflect.api.Exprs"), tpnme.Expr) def ExprTree = getMember(ExprClass, nme.tree) @@ -477,16 +499,21 @@ trait Definitions extends reflect.api.StandardDefinitions { def ExprValue = getMember(ExprClass, nme.value) lazy val ExprModule = getMember(getRequiredClass("scala.reflect.api.Exprs"), nme.Expr) - lazy val ClassTagClass = getRequiredClass("scala.reflect.ClassTag") - def ClassTagErasure = getMember(ClassTagClass, nme.erasure) - def ClassTagTpe = getMember(ClassTagClass, nme.tpe) - lazy val ClassTagModule = getRequiredModule("scala.reflect.ClassTag") - lazy val TypeTagsClass = getRequiredClass("scala.reflect.api.TypeTags") - lazy val TypeTagClass = getMember(TypeTagsClass, tpnme.TypeTag) - def TypeTagTpe = getMember(TypeTagClass, nme.tpe) - lazy val TypeTagModule = getMember(TypeTagsClass, nme.TypeTag) - lazy val ConcreteTypeTagClass = getMember(TypeTagsClass, tpnme.ConcreteTypeTag) - lazy val ConcreteTypeTagModule = getMember(TypeTagsClass, nme.ConcreteTypeTag) + lazy val ArrayTagClass = requiredClass[scala.reflect.ArrayTag[_]] + lazy val ErasureTagClass = requiredClass[scala.reflect.ErasureTag[_]] + lazy val ClassTagModule = requiredModule[scala.reflect.ClassTag[_]] + lazy val ClassTagClass = requiredClass[scala.reflect.ClassTag[_]] + lazy val TypeTagsClass = requiredClass[scala.reflect.api.TypeTags] + lazy val TypeTagClass = getMemberClass(TypeTagsClass, tpnme.TypeTag) + lazy val TypeTagModule = getMemberModule(TypeTagsClass, nme.TypeTag) + lazy val ConcreteTypeTagClass = getMemberClass(TypeTagsClass, tpnme.ConcreteTypeTag) + lazy val ConcreteTypeTagModule = getMemberModule(TypeTagsClass, nme.ConcreteTypeTag) + + def ArrayTagWrap = getMemberMethod(ArrayTagClass, nme.wrap) + def ArrayTagNewArray = getMemberMethod(ArrayTagClass, nme.newArray) + def ErasureTagErasure = getMemberMethod(ErasureTagClass, nme.erasure) + def ClassTagTpe = getMemberMethod(ClassTagClass, nme.tpe) + def TypeTagTpe = getMemberMethod(TypeTagClass, nme.tpe) lazy val MacroContextClass = getRequiredClass("scala.reflect.makro.Context") def MacroContextPrefix = getMember(MacroContextClass, nme.prefix) @@ -495,16 +522,18 @@ trait Definitions extends reflect.api.StandardDefinitions { def MacroContextReify = getMember(MacroContextClass, nme.reify) lazy val MacroImplAnnotation = getRequiredClass("scala.reflect.makro.internal.macroImpl") lazy val MacroInternalPackage = getPackageObject("scala.reflect.makro.internal") - def MacroInternal_materializeClassTag = getMember(MacroInternalPackage, nme.materializeClassTag) - def MacroInternal_materializeTypeTag = getMember(MacroInternalPackage, nme.materializeTypeTag) - def MacroInternal_materializeConcreteTypeTag = getMember(MacroInternalPackage, nme.materializeConcreteTypeTag) + def MacroInternal_materializeArrayTag = getMemberMethod(MacroInternalPackage, nme.materializeArrayTag) + def MacroInternal_materializeErasureTag = getMemberMethod(MacroInternalPackage, nme.materializeErasureTag) + def MacroInternal_materializeClassTag = getMemberMethod(MacroInternalPackage, nme.materializeClassTag) + def MacroInternal_materializeTypeTag = getMemberMethod(MacroInternalPackage, nme.materializeTypeTag) + def MacroInternal_materializeConcreteTypeTag = getMemberMethod(MacroInternalPackage, nme.materializeConcreteTypeTag) lazy val ScalaSignatureAnnotation = getRequiredClass("scala.reflect.ScalaSignature") lazy val ScalaLongSignatureAnnotation = getRequiredClass("scala.reflect.ScalaLongSignature") // Option classes - lazy val OptionClass: Symbol = getRequiredClass("scala.Option") - lazy val SomeClass: Symbol = getRequiredClass("scala.Some") + lazy val OptionClass: Symbol = requiredClass[Option[_]] + lazy val SomeClass: Symbol = requiredClass[Some[_]] lazy val NoneModule: Symbol = getRequiredModule("scala.None") lazy val SomeModule: Symbol = getRequiredModule("scala.Some") @@ -512,9 +541,9 @@ trait Definitions extends reflect.api.StandardDefinitions { // private lazy val importerFromRm = self.mkImporter(rm) private lazy val importerFromRm = self.mkImporter(rm).asInstanceOf[self.Importer { val from: rm.type }] - def manifestToType(m: Manifest[_]): Type = importerFromRm.importType(m.tpe) + def compilerTypeFromTag(t: rm.TypeTag[_]): Type = importerFromRm.importType(t.tpe) - def manifestToSymbol(m: Manifest[_]): Symbol = importerFromRm.importSymbol(m.tpe.typeSymbol) + def compilerSymbolFromTag(t: rm.TypeTag[_]): Symbol = importerFromRm.importSymbol(t.sym) // The given symbol represents either String.+ or StringAdd.+ def isStringAddition(sym: Symbol) = sym == String_+ || sym == StringAdd_+ @@ -616,13 +645,13 @@ trait Definitions extends reflect.api.StandardDefinitions { } def isTupleType(tp: Type) = isTupleTypeDirect(tp.normalize) - lazy val ProductRootClass: Symbol = getRequiredClass("scala.Product") - def Product_productArity = getMember(ProductRootClass, nme.productArity) - def Product_productElement = getMember(ProductRootClass, nme.productElement) - // def Product_productElementName = getMember(ProductRootClass, nme.productElementName) - def Product_iterator = getMember(ProductRootClass, nme.productIterator) - def Product_productPrefix = getMember(ProductRootClass, nme.productPrefix) - def Product_canEqual = getMember(ProductRootClass, nme.canEqual_) + lazy val ProductRootClass: ClassSymbol = requiredClass[scala.Product] + def Product_productArity = getMemberMethod(ProductRootClass, nme.productArity) + def Product_productElement = getMemberMethod(ProductRootClass, nme.productElement) + def Product_iterator = getMemberMethod(ProductRootClass, nme.productIterator) + def Product_productPrefix = getMemberMethod(ProductRootClass, nme.productPrefix) + def Product_canEqual = getMemberMethod(ProductRootClass, nme.canEqual_) + // def Product_productElementName = getMemberMethod(ProductRootClass, nme.productElementName) def productProj(z:Symbol, j: Int): Symbol = getMember(z, nme.productAccessorName(j)) def productProj(n: Int, j: Int): Symbol = productProj(ProductClass(n), j) @@ -655,6 +684,11 @@ trait Definitions extends reflect.api.StandardDefinitions { false } + def isPartialFunctionType(tp: Type): Boolean = { + val sym = tp.typeSymbol + (sym eq PartialFunctionClass) || (sym eq AbstractPartialFunctionClass) + } + def isSeqType(tp: Type) = elementType(SeqClass, tp.normalize) != NoType def elementType(container: Symbol, tp: Type): Type = tp match { @@ -912,6 +946,7 @@ trait Definitions extends reflect.api.StandardDefinitions { lazy val ThrowsClass = getRequiredClass("scala.throws") lazy val TransientAttr = getRequiredClass("scala.transient") lazy val UncheckedClass = getRequiredClass("scala.unchecked") + lazy val UnspecializedClass = getRequiredClass("scala.annotation.unspecialized") lazy val VolatileAttr = getRequiredClass("scala.volatile") // Meta-annotations @@ -942,7 +977,7 @@ trait Definitions extends reflect.api.StandardDefinitions { // Trying to allow for deprecated locations sym.isAliasType && isMetaAnnotation(sym.info.typeSymbol) ) - lazy val metaAnnotations = Set( + lazy val metaAnnotations = Set[Symbol]( FieldTargetClass, ParamTargetClass, GetterTargetClass, SetterTargetClass, BeanGetterTargetClass, BeanSetterTargetClass @@ -961,31 +996,64 @@ trait Definitions extends reflect.api.StandardDefinitions { def getPackageObject(fullname: String): Symbol = getModule(newTermName(fullname)).info member nme.PACKAGE - def getModule(fullname: Name): Symbol = - getModuleOrClass(fullname.toTermName) + def getModule(fullname: Name): ModuleSymbol = + getModuleOrClass(fullname.toTermName) match { + case x: ModuleSymbol => x + case _ => MissingRequirementError.notFound("object " + fullname) + } - def getClass(fullname: Name): Symbol = { - var result = getModuleOrClass(fullname.toTypeName) - while (result.isAliasType) result = result.info.typeSymbol - result + def getPackage(fullname: Name): PackageSymbol = + getModuleOrClass(fullname.toTermName) match { + case x: PackageSymbol => x + case _ => MissingRequirementError.notFound("package " + fullname) + } + @inline private def wrapMissing(body: => Symbol): Symbol = + try body + catch { case _: MissingRequirementError => NoSymbol } + + private def fatalMissingSymbol(owner: Symbol, name: Name, what: String = "member") = { + throw new FatalError(owner + " does not have a " + what + " " + name) } - def getRequiredModule(fullname: String): Symbol = + @deprecated("Use getClassByName", "2.10.0") + def getClass(fullname: Name): Symbol = getClassByName(fullname) + + def getRequiredPackage(fullname: String): PackageSymbol = + getPackage(newTermNameCached(fullname)) + + def getRequiredModule(fullname: String): ModuleSymbol = getModule(newTermNameCached(fullname)) - def getRequiredClass(fullname: String): Symbol = - getClass(newTypeNameCached(fullname)) + + def requiredClass[T: ClassTag] : ClassSymbol = + getRequiredClass(classTag[T].erasure.getName) + + // TODO: What syntax do we think should work here? Say you have an object + // like scala.Predef. You can't say requiredModule[scala.Predef] since there's + // no accompanying Predef class, and if you say requiredModule[scala.Predef.type] + // the name found via the erasure is scala.Predef$. For now I am + // removing the trailing $, but I think that classTag should have + // a method which returns a usable name, one which doesn't expose this + // detail of the backend. + def requiredModule[T: ClassTag] : ModuleSymbol = + getRequiredModule(classTag[T].erasure.getName stripSuffix "$") + + def getRequiredClass(fullname: String): ClassSymbol = + getClassByName(newTypeNameCached(fullname)) match { + case x: ClassSymbol => x + case _ => MissingRequirementError.notFound("class " + fullname) + } def getClassIfDefined(fullname: String): Symbol = getClassIfDefined(newTypeName(fullname)) + def getClassIfDefined(fullname: Name): Symbol = - try getClass(fullname.toTypeName) - catch { case _: MissingRequirementError => NoSymbol } + wrapMissing(getClass(fullname.toTypeName)) def getModuleIfDefined(fullname: String): Symbol = getModuleIfDefined(newTermName(fullname)) + def getModuleIfDefined(fullname: Name): Symbol = - try getModule(fullname.toTermName) - catch { case _: MissingRequirementError => NoSymbol } + wrapMissing(getModule(fullname.toTermName)) def getLanguageFeature(name: String, owner: Symbol = languageFeatureModule) = getMember(owner, newTypeName(name)) @@ -1013,11 +1081,29 @@ trait Definitions extends reflect.api.StandardDefinitions { val pkg = owner.owner val flatname = nme.flattenedName(owner.name, name) getMember(pkg, flatname) - } else { - throw new FatalError(owner + " does not have a member " + name) } + else fatalMissingSymbol(owner, name) + } + } + def getMemberModule(owner: Symbol, name: Name): ModuleSymbol = { + getMember(owner, name.toTermName) match { + case x: ModuleSymbol => x + case _ => fatalMissingSymbol(owner, name, "member object") } } + def getMemberClass(owner: Symbol, name: Name): ClassSymbol = { + getMember(owner, name.toTypeName) match { + case x: ClassSymbol => x + case _ => fatalMissingSymbol(owner, name, "member class") + } + } + def getMemberMethod(owner: Symbol, name: Name): MethodSymbol = { + getMember(owner, name.toTermName) match { + case x: MethodSymbol => x + case _ => fatalMissingSymbol(owner, name, "method") + } + } + def getMemberIfDefined(owner: Symbol, name: Name): Symbol = owner.info.nonPrivateMember(name) @@ -1026,9 +1112,7 @@ trait Definitions extends reflect.api.StandardDefinitions { * know the method in question is uniquely declared in the given owner. */ def getDecl(owner: Symbol, name: Name): Symbol = { - getDeclIfDefined(owner, name) orElse { - throw new FatalError(owner + " does not have a decl " + name) - } + getDeclIfDefined(owner, name) orElse fatalMissingSymbol(owner, name, "decl") } def getDeclIfDefined(owner: Symbol, name: Name): Symbol = owner.info.nonPrivateDecl(name) @@ -1058,10 +1142,16 @@ trait Definitions extends reflect.api.StandardDefinitions { */ private def getModuleOrClass(path: Name): Symbol = getModuleOrClass(path, path.length) - private def newAlias(owner: Symbol, name: TypeName, alias: Type): Symbol = + private def getClassByName(fullname: Name): Symbol = { + var result = getModuleOrClass(fullname.toTypeName) + while (result.isAliasType) result = result.info.typeSymbol + result + } + + private def newAlias(owner: Symbol, name: TypeName, alias: Type): AliasTypeSymbol = owner.newAliasType(name) setInfoAndEnter alias - private def specialPolyClass(name: TypeName, flags: Long)(parentFn: Symbol => Type): Symbol = { + private def specialPolyClass(name: TypeName, flags: Long)(parentFn: Symbol => Type): ClassSymbol = { val clazz = enterNewClass(ScalaPackageClass, name, Nil) val tparam = clazz.newSyntheticTypeParam("T0", flags) val parents = List(AnyRefClass.tpe, parentFn(tparam)) @@ -1069,7 +1159,7 @@ trait Definitions extends reflect.api.StandardDefinitions { clazz setInfo GenPolyType(List(tparam), ClassInfoType(parents, newScope, clazz)) } - def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: PolyMethodCreator): Symbol = { + def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: PolyMethodCreator): MethodSymbol = { val msym = owner.newMethod(name.encode, NoPosition, flags) val tparams = msym.newSyntheticTypeParams(typeParamCount) val mtpe = createFn(tparams) match { @@ -1082,16 +1172,16 @@ trait Definitions extends reflect.api.StandardDefinitions { /** T1 means one type parameter. */ - def newT1NullaryMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): Symbol = { + def newT1NullaryMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): MethodSymbol = { newPolyMethod(1, owner, name, flags)(tparams => (None, createFn(tparams.head))) } - def newT1NoParamsMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): Symbol = { + def newT1NoParamsMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): MethodSymbol = { newPolyMethod(1, owner, name, flags)(tparams => (Some(Nil), createFn(tparams.head))) } - lazy val boxedClassValues = boxedClass.values.toSet - lazy val isUnbox = unboxMethod.values.toSet - lazy val isBox = boxMethod.values.toSet + lazy val boxedClassValues = boxedClass.values.toSet[Symbol] + lazy val isUnbox = unboxMethod.values.toSet[Symbol] + lazy val isBox = boxMethod.values.toSet[Symbol] /** Is symbol a phantom class for which no runtime representation exists? */ lazy val isPhantomClass = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass) @@ -1099,8 +1189,7 @@ trait Definitions extends reflect.api.StandardDefinitions { /** Is the symbol that of a parent which is added during parsing? */ lazy val isPossibleSyntheticParent = ProductClass.toSet[Symbol] + ProductRootClass + SerializableClass - lazy val scalaValueClassesSet = ScalaValueClasses.toSet - private lazy val boxedValueClassesSet = boxedClass.values.toSet + BoxedUnitClass + private lazy val boxedValueClassesSet = boxedClass.values.toSet[Symbol] + BoxedUnitClass /** Is symbol a value class? */ def isPrimitiveValueClass(sym: Symbol) = ScalaValueClasses contains sym diff --git a/src/compiler/scala/reflect/internal/Flags.scala b/src/compiler/scala/reflect/internal/Flags.scala index ce459bdd06..c6901d1cf6 100644 --- a/src/compiler/scala/reflect/internal/Flags.scala +++ b/src/compiler/scala/reflect/internal/Flags.scala @@ -83,40 +83,40 @@ import scala.collection.{ mutable, immutable } /** Flags set on Modifiers instances in the parsing stage. */ class ModifierFlags { - final val IMPLICIT = 0x00000200 - final val FINAL = 0x00000020 // May not be overridden. Note that java final implies much more than scala final. - final val PRIVATE = 0x00000004 - final val PROTECTED = 0x00000001 - - final val SEALED = 0x00000400 - final val OVERRIDE = 0x00000002 - final val CASE = 0x00000800 - final val ABSTRACT = 0x00000008 // abstract class, or used in conjunction with abstract override. + final val IMPLICIT = 1 << 9 + final val FINAL = 1 << 5 // May not be overridden. Note that java final implies much more than scala final. + final val PRIVATE = 1 << 2 + final val PROTECTED = 1 << 0 + + final val SEALED = 1 << 10 + final val OVERRIDE = 1 << 1 + final val CASE = 1 << 11 + final val ABSTRACT = 1 << 3 // abstract class, or used in conjunction with abstract override. // Note difference to DEFERRED! - final val DEFERRED = 0x00000010 // was `abstract' for members | trait is virtual - final val INTERFACE = 0x00000080 // symbol is an interface (i.e. a trait which defines only abstract methods) - final val MUTABLE = 0x00001000 // symbol is a mutable variable. - final val PARAM = 0x00002000 // symbol is a (value or type) parameter to a method - final val MACRO = 0x00008000 // symbol is a macro definition - - final val COVARIANT = 0x00010000 // symbol is a covariant type variable - final val BYNAMEPARAM = 0x00010000 // parameter is by name - final val CONTRAVARIANT = 0x00020000 // symbol is a contravariant type variable - final val ABSOVERRIDE = 0x00040000 // combination of abstract & override - final val LOCAL = 0x00080000 // symbol is local to current class (i.e. private[this] or protected[this] + final val DEFERRED = 1 << 4 // was `abstract' for members | trait is virtual + final val INTERFACE = 1 << 7 // symbol is an interface (i.e. a trait which defines only abstract methods) + final val MUTABLE = 1 << 12 // symbol is a mutable variable. + final val PARAM = 1 << 13 // symbol is a (value or type) parameter to a method + final val MACRO = 1 << 15 // symbol is a macro definition + + final val COVARIANT = 1 << 16 // symbol is a covariant type variable + final val BYNAMEPARAM = 1 << 16 // parameter is by name + final val CONTRAVARIANT = 1 << 17 // symbol is a contravariant type variable + final val ABSOVERRIDE = 1 << 18 // combination of abstract & override + final val LOCAL = 1 << 19 // symbol is local to current class (i.e. private[this] or protected[this] // pre: PRIVATE or PROTECTED are also set - final val JAVA = 0x00100000 // symbol was defined by a Java class - final val STATIC = 0x00800000 // static field, method or class - final val CASEACCESSOR = 0x01000000 // symbol is a case parameter (or its accessor, or a GADT skolem) - final val TRAIT = 0x02000000 // symbol is a trait - final val DEFAULTPARAM = 0x02000000 // the parameter has a default value - final val PARAMACCESSOR = 0x20000000 // for field definitions generated for primary constructor + final val JAVA = 1 << 20 // symbol was defined by a Java class + final val STATIC = 1 << 23 // static field, method or class + final val CASEACCESSOR = 1 << 24 // symbol is a case parameter (or its accessor, or a GADT skolem) + final val TRAIT = 1 << 25 // symbol is a trait + final val DEFAULTPARAM = 1 << 25 // the parameter has a default value + final val PARAMACCESSOR = 1 << 29 // for field definitions generated for primary constructor // parameters (no matter if it's a 'val' parameter or not) // for parameters of a primary constructor ('val' or not) // for the accessor methods generated for 'val' or 'var' parameters - final val LAZY = 0x80000000L // symbol is a lazy val. can't have MUTABLE unless transformed by typer - final val PRESUPER = 0x2000000000L // value is evaluated before super call - final val DEFAULTINIT = 0x20000000000L// symbol is initialized to the default value: used by -Xcheckinit + final val LAZY = 1L << 31 // symbol is a lazy val. can't have MUTABLE unless transformed by typer + final val PRESUPER = 1L << 37 // value is evaluated before super call + final val DEFAULTINIT = 1L << 41 // symbol is initialized to the default value: used by -Xcheckinit // Overridden. def flagToString(flag: Long): String = "" @@ -129,43 +129,43 @@ object ModifierFlags extends ModifierFlags /** All flags and associated operatins */ class Flags extends ModifierFlags { - final val METHOD = 0x00000040 // a method - final val MODULE = 0x00000100 // symbol is module or class implementing a module - final val PACKAGE = 0x00004000 // symbol is a java package - - final val CAPTURED = 0x00010000 // variable is accessed from nested function. Set by LambdaLift. - final val LABEL = 0x00020000 // method symbol is a label. Set by TailCall - final val INCONSTRUCTOR = 0x00020000 // class symbol is defined in this/superclass constructor. - final val SYNTHETIC = 0x00200000 // symbol is compiler-generated - final val STABLE = 0x00400000 // functions that are assumed to be stable + final val METHOD = 1 << 6 // a method + final val MODULE = 1 << 8 // symbol is module or class implementing a module + final val PACKAGE = 1 << 14 // symbol is a java package + + final val CAPTURED = 1 << 16 // variable is accessed from nested function. Set by LambdaLift. + final val LABEL = 1 << 17 // method symbol is a label. Set by TailCall + final val INCONSTRUCTOR = 1 << 17 // class symbol is defined in this/superclass constructor. + final val SYNTHETIC = 1 << 21 // symbol is compiler-generated + final val STABLE = 1 << 22 // functions that are assumed to be stable // (typically, access methods for valdefs) // or classes that do not contain abstract types. - final val BRIDGE = 0x04000000 // function is a bridge method. Set by Erasure - final val ACCESSOR = 0x08000000 // a value or variable accessor (getter or setter) + final val BRIDGE = 1 << 26 // function is a bridge method. Set by Erasure + final val ACCESSOR = 1 << 27 // a value or variable accessor (getter or setter) - final val SUPERACCESSOR = 0x10000000 // a super accessor - final val MODULEVAR = 0x40000000 // for variables: is the variable caching a module value + final val SUPERACCESSOR = 1 << 28 // a super accessor + final val MODULEVAR = 1 << 30 // for variables: is the variable caching a module value - final val IS_ERROR = 0x100000000L // symbol is an error symbol - final val OVERLOADED = 0x200000000L // symbol is overloaded - final val LIFTED = 0x400000000L // class has been lifted out to package level + final val IS_ERROR = 1L << 32 // symbol is an error symbol + final val OVERLOADED = 1L << 33 // symbol is overloaded + final val LIFTED = 1L << 34 // class has been lifted out to package level // local value has been lifted out to class level // todo: make LIFTED = latePRIVATE? - final val MIXEDIN = 0x800000000L // term member has been mixed in - final val EXISTENTIAL = 0x800000000L // type is an existential parameter or skolem - final val EXPANDEDNAME = 0x1000000000L // name has been expanded with class suffix - final val IMPLCLASS = 0x2000000000L // symbol is an implementation class - final val TRANS_FLAG = 0x4000000000L // transient flag guaranteed to be reset after each phase. + final val MIXEDIN = 1L << 35 // term member has been mixed in + final val EXISTENTIAL = 1L << 35 // type is an existential parameter or skolem + final val EXPANDEDNAME = 1L << 36 // name has been expanded with class suffix + final val IMPLCLASS = 1L << 37 // symbol is an implementation class + final val TRANS_FLAG = 1L << 38 // transient flag guaranteed to be reset after each phase. - final val LOCKED = 0x8000000000L // temporary flag to catch cyclic dependencies - final val SPECIALIZED = 0x10000000000L// symbol is a generated specialized member - final val VBRIDGE = 0x40000000000L// symbol is a varargs bridge + final val LOCKED = 1L << 39 // temporary flag to catch cyclic dependencies + final val SPECIALIZED = 1L << 40 // symbol is a generated specialized member + final val VBRIDGE = 1L << 42 // symbol is a varargs bridge - final val VARARGS = 0x80000000000L// symbol is a Java-style varargs method - final val TRIEDCOOKING = 0x100000000000L // ``Cooking'' has been tried on this symbol - // A Java method's type is ``cooked'' by transforming raw types to existentials + final val VARARGS = 1L << 43 // symbol is a Java-style varargs method + final val TRIEDCOOKING = 1L << 44 // ``Cooking'' has been tried on this symbol + // A Java method's type is ``cooked'' by transforming raw types to existentials - final val SYNCHRONIZED = 0x200000000000L // symbol is a method which should be marked ACC_SYNCHRONIZED + final val SYNCHRONIZED = 1L << 45 // symbol is a method which should be marked ACC_SYNCHRONIZED // ------- shift definitions ------------------------------------------------------- final val InitialFlags = 0x0001FFFFFFFFFFFFL // flags that are enabled from phase 1. diff --git a/src/compiler/scala/reflect/internal/FrontEnds.scala b/src/compiler/scala/reflect/internal/FrontEnds.scala new file mode 100644 index 0000000000..74501c7686 --- /dev/null +++ b/src/compiler/scala/reflect/internal/FrontEnds.scala @@ -0,0 +1,75 @@ +package scala.reflect +package internal + +trait FrontEnds { self: SymbolTable => + + import scala.tools.nsc.reporters._ + import scala.tools.nsc.Settings + + def mkConsoleFrontEnd(minSeverity: Int = 1): FrontEnd = { + val settings = new Settings() + if (minSeverity <= 0) settings.verbose.value = true + if (minSeverity > 1) settings.nowarn.value = true + wrapReporter(new ConsoleReporter(settings)) + } + + abstract class FrontEndToReporterProxy(val frontEnd: FrontEnd) extends AbstractReporter { + import frontEnd.{Severity => ApiSeverity} + val API_INFO = frontEnd.INFO + val API_WARNING = frontEnd.WARNING + val API_ERROR = frontEnd.ERROR + + type NscSeverity = Severity + val NSC_INFO = INFO + val NSC_WARNING = WARNING + val NSC_ERROR = ERROR + + def display(pos: Position, msg: String, nscSeverity: NscSeverity): Unit = + frontEnd.log(pos, msg, nscSeverity match { + case NSC_INFO => API_INFO + case NSC_WARNING => API_WARNING + case NSC_ERROR => API_ERROR + }) + + def displayPrompt(): Unit = + frontEnd.interactive() + } + + def wrapFrontEnd(frontEnd: FrontEnd): Reporter = new FrontEndToReporterProxy(frontEnd) { + val settings = new Settings() + settings.verbose.value = true + settings.nowarn.value = false + } + + class ReporterToFrontEndProxy(val reporter: Reporter) extends FrontEnd { + val API_INFO = INFO + val API_WARNING = WARNING + val API_ERROR = ERROR + + override def hasErrors = reporter.hasErrors + override def hasWarnings = reporter.hasWarnings + + def display(info: Info): Unit = info.severity match { + case API_INFO => reporter.info(info.pos, info.msg, false) + case API_WARNING => reporter.warning(info.pos, info.msg) + case API_ERROR => reporter.error(info.pos, info.msg) + } + + def interactive(): Unit = reporter match { + case reporter: AbstractReporter => reporter.displayPrompt() + case _ => // do nothing + } + + override def flush(): Unit = { + super.flush() + reporter.flush() + } + + override def reset(): Unit = { + super.reset() + reporter.reset() + } + } + + def wrapReporter(reporter: Reporter): FrontEnd = new ReporterToFrontEndProxy(reporter) +} diff --git a/src/compiler/scala/reflect/internal/Importers.scala b/src/compiler/scala/reflect/internal/Importers.scala index ab5e19fca9..8404386e10 100644 --- a/src/compiler/scala/reflect/internal/Importers.scala +++ b/src/compiler/scala/reflect/internal/Importers.scala @@ -71,9 +71,9 @@ trait Importers { self: SymbolTable => case x: from.ModuleSymbol => linkReferenced(myowner.newModuleSymbol(myname, mypos, myflags), x, importSymbol) case x: from.FreeTerm => - newFreeTerm(importName(x.name).toTermName, importType(x.info), x.value, x.origin, myflags) + newFreeTermSymbol(importName(x.name).toTermName, importType(x.info), x.value, x.flags, x.origin) case x: from.FreeType => - newFreeType(importName(x.name).toTypeName, importType(x.info), x.value, x.origin, myflags) + newFreeTypeSymbol(importName(x.name).toTypeName, importType(x.info), x.value, x.flags, x.origin) case x: from.TermSymbol => linkReferenced(myowner.newValue(myname, mypos, myflags), x, importSymbol) case x: from.TypeSkolem => @@ -326,7 +326,7 @@ trait Importers { self: SymbolTable => case from.ValDef(mods, name, tpt, rhs) => new ValDef(importModifiers(mods), importName(name).toTermName, importTree(tpt), importTree(rhs)) case from.DefDef(mods, name, tparams, vparamss, tpt, rhs) => - new DefDef(importModifiers(mods), importName(name).toTermName, tparams map importTypeDef, vparamss map (_ map importValDef), importTree(tpt), importTree(rhs)) + new DefDef(importModifiers(mods), importName(name).toTermName, tparams map importTypeDef, mmap(vparamss)(importValDef), importTree(tpt), importTree(rhs)) case from.TypeDef(mods, name, tparams, rhs) => new TypeDef(importModifiers(mods), importName(name).toTypeName, tparams map importTypeDef, importTree(rhs)) case from.LabelDef(name, params, rhs) => diff --git a/src/compiler/scala/reflect/internal/JvmClassInfo.scala b/src/compiler/scala/reflect/internal/JvmClassInfo.scala new file mode 100644 index 0000000000..d47f51e512 --- /dev/null +++ b/src/compiler/scala/reflect/internal/JvmClassInfo.scala @@ -0,0 +1,440 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2011 LAMP/EPFL + * @author Paul Phillips + */ + +package scala.reflect.internal + +import java.io.{ DataInput, InputStream, DataInputStream, ByteArrayInputStream, BufferedInputStream, FileInputStream } +import scala.tools.nsc.io.{ Directory } +import scala.reflect.NameTransformer.decode +import scala.tools.util.StringOps.trimTrailingSpace +import ConstantPool._ + +final case class JvmVersion(minorVersion: Int, majorVersion: Int) + +trait ClassfileModel { + type Result + type Entry + type InterfaceInfo + type MemberInfo + type AttributeInfo + type InnerClassInfo + + protected implicit def EntryArrayTag: ArrayTag[Entry] + protected implicit def InterfaceInfoArrayTag: ArrayTag[InterfaceInfo] + protected implicit def MemberInfoArrayTag: ArrayTag[MemberInfo] + protected implicit def AttributeInfoArrayTag: ArrayTag[AttributeInfo] + protected implicit def InnerClassInfoArrayTag: ArrayTag[InnerClassInfo] + + // These could be implemented to jump forward in the stream if the + // result is not wanted. + def readConstantPoolEntry(): Entry + def readInterface(): InterfaceInfo + def readMember(): MemberInfo + def readAttribute(): AttributeInfo + def readInnerClass(): InnerClassInfo + + def createInfo( + version: JvmVersion, + entries: Array[Entry], + flags: Int, + name: String, + superName: String, + interfaces: Array[InterfaceInfo], + fields: Array[MemberInfo], + methods: Array[MemberInfo], + attributes: Array[AttributeInfo] + ): Result +} + +abstract class StreamingClassfileModel extends ClassfileModel { + protected[this] val in: DataInput + private[this] var name: String = _ + private[this] var entries: Array[PoolEntry] = _ + + type Entry = PoolEntry + + // These translate null into "", it's less troublesome. + protected def nameAt(idx: Int) = entries(idx) match { + case x: Name_Info => stringAt(x.name_index).replace('/', '.') + case _ => "" + } + protected def stringAt(idx: Int) = entries(idx) match { + case x: Utf8_info => x.stringValue + case _ => "" + } + + protected def u4 = in.readInt + protected def u2 = in.readUnsignedShort.toChar + protected def u1 = in.readUnsignedByte + + // The constant_pool table is indexed from 1 to constant_pool_count−1. + protected def readConstantPool(): Array[Entry] = { + val count = u2 + val entries = new Array[Entry](count) + var i = 1 + while (i < count) { + val entry = readConstantPoolEntry() + entries(i) = entry + i += entry.width + } + entries + } + protected def readInterfaces() = { + val count = u2 + val interfaces = new Array[InterfaceInfo](count) + var i = 0 + while (i < count) { + interfaces(i) = readInterface() + i += 1 + } + interfaces + } + protected def readMembers() = { + val count = u2 + val arr = new Array[MemberInfo](count) + var i = 0 + while (i < count) { + arr(i) = readMember() + i += 1 + } + arr + } + protected def readAttributes(): Array[AttributeInfo] = { + val count = u2 + val arr = new Array[AttributeInfo](count) + var i = 0 + while (i < count) { + arr(i) = readAttribute() + i += 1 + } + arr + } + protected def readInnerClasses() = { + val count = u2 + val arr = new Array[InnerClassInfo](count) + var i = 0 + while (i < count) { + arr(i) = readInnerClass() + i += 1 + } + arr + } + protected def thisClass = name + + def parse() = { + assert(u4 == 0xCAFEBABE, "Bad magic number") + val version = JvmVersion(u2, u2) + this.entries = readConstantPool() + val flags = u2.toShort + this.name = nameAt(u2) + val superName = nameAt(u2) + val interfaces = readInterfaces() + val fields = readMembers() + val methods = readMembers() + val attributes = readAttributes() + + try createInfo(version, entries, flags, name, superName, interfaces, fields, methods, attributes) + finally entries = null + } +} + +abstract class ScalacClassfileModel extends StreamingClassfileModel { + type Result = JvmClassInfo + type InterfaceInfo = String + type MemberInfo = JvmMemberInfo + type AttributeInfo = JvmAttributeInfo + type InnerClassInfo = JvmInnerClassInfo + + protected implicit def EntryArrayTag = arrayTag[PoolEntry] + protected implicit def InterfaceInfoArrayTag = arrayTag[InterfaceInfo] + protected implicit def MemberInfoArrayTag = arrayTag[MemberInfo] + protected implicit def AttributeInfoArrayTag = arrayTag[AttributeInfo] + protected implicit def InnerClassInfoArrayTag = arrayTag[InnerClassInfo] + + def readConstantPoolEntry(): PoolEntry + def readInterface(): String + def readMember(): JvmMemberInfo + def readAttribute(): JvmAttributeInfo + def readInnerClass(): JvmInnerClassInfo + + def createInfo( + version: JvmVersion, + entries: Array[PoolEntry], + flags: Int, + name: String, + superName: String, + interfaces: Array[String], + fields: Array[JvmMemberInfo], + methods: Array[JvmMemberInfo], + attributes: Array[JvmAttributeInfo] + ): JvmClassInfo = new JvmClassInfo(name, superName, interfaces, fields, methods, attributes) +} + +class JvmClassInfoBuilder(protected[this] val in: DataInput) extends ScalacClassfileModel { + def readInterface(): InterfaceInfo = nameAt(u2) + def readMember(): JvmMemberInfo = new JvmMemberInfo(u2.toShort, stringAt(u2), stringAt(u2), readAttributes()) + def readInnerClass(): JvmInnerClassInfo = new JvmInnerClassInfo(thisClass, nameAt(u2), nameAt(u2), stringAt(u2), u2.toShort) + + def readConstantPoolEntry(): Entry = (u1: @annotation.switch) match { + case CONSTANT_Utf8 => new Utf8_info(in.readUTF) + case CONSTANT_Integer => new Integer_info(in.readInt) + case CONSTANT_Float => new Float_info(in.readFloat) + case CONSTANT_Long => new Long_info(in.readLong) + case CONSTANT_Double => new Double_info(in.readDouble) + case CONSTANT_Class => new Class_info(u2) + case CONSTANT_String => new String_info(u2) + case CONSTANT_Fieldref => new Fieldref_info(u2, u2) + case CONSTANT_Methodref => new Methodref_info(u2, u2) + case CONSTANT_InterfaceMethodref => new InterfaceMethodref_info(u2, u2) + case CONSTANT_NameAndType => new NameAndType_info(u2, u2) + } + + // field_info attributes: + // ConstantValue (§4.7.2), Synthetic (§4.7.8), Signature (§4.7.9), Deprecated (§4.7.15), + // RuntimeVisibleAnnotations (§4.7.16) and RuntimeInvisibleAnnotations (§4.7.17). + // + // method_info attributes: + // Code (§4.7.3), Exceptions (§4.7.5), Synthetic (§4.7.8), Signature (§4.7.9), Deprecated (§4.7.15), + // RuntimeVisibleAnnotations (§4.7.16), RuntimeInvisibleAnnotations (§4.7.17), RuntimeVisibleParameterAnnotations (§4.7.18), + // RuntimeInvisibleParameterAnnotations (§4.7.19) and AnnotationDefault (§4.7.20). + + def readAttribute(): AttributeInfo = stringAt(u2) match { + case "Signature" => u4 ; new SignatureAttr(stringAt(u2)) + case "InnerClasses" => u4 ; new InnerClassesAttr(readInnerClasses()) + case name => val bytes = new Array[Byte](u4) ; in.readFully(bytes) ; new GenericAttr(name, bytes) + } +} + +object Classify { + + /* + + + 4.2.2 Unqualified Names + +Names of methods, fields and local variables are stored as unqualified +names. Unqualified names must not contain the characters '.', ';', '[' +or '/'. Method names are further constrained so that, with the exception +of the special method names <init> and <clinit> (§3.9), they must not +contain the characters '<' or '>'. + + 4.3 Descriptors and Signatures + +A descriptor is a string representing the type of a field or method. +Descriptors are represented in the class file format using modified +UTF-8 strings (§4.4.7) and thus may be drawn, where not further +constrained, from the entire Unicode character set. A signature is a +string representing the generic type of a field or method, or generic +type information for a class declaration. +*/ + +} + +object ConstantPool { + type UShort = Char + + final val CONSTANT_Utf8 = 1 + final val CONSTANT_Integer = 3 + final val CONSTANT_Float = 4 + final val CONSTANT_Long = 5 + final val CONSTANT_Double = 6 + final val CONSTANT_Class = 7 + final val CONSTANT_String = 8 + final val CONSTANT_Fieldref = 9 + final val CONSTANT_Methodref = 10 + final val CONSTANT_InterfaceMethodref = 11 + final val CONSTANT_NameAndType = 12 + + abstract class Name_Info(tag: Byte) extends PoolEntry(tag) { + def name_index: UShort + } + abstract class Ref_Info(tag: Byte) extends PoolEntry(tag) { + def class_index: UShort + def name_and_type_index: UShort + } + class Class_info(val name_index: UShort) extends Name_Info(CONSTANT_Class) { } + class Double_info(val value: Double) extends PoolEntry(CONSTANT_Double) { + override def width = 2 + } + class Fieldref_info(val class_index: UShort, val name_and_type_index: UShort) extends Ref_Info(CONSTANT_Fieldref) + class Float_info(val value: Float) extends PoolEntry(CONSTANT_Float) + class Integer_info(val value: Int) extends PoolEntry(CONSTANT_Integer) + class InterfaceMethodref_info(val class_index: UShort, val name_and_type_index: UShort) extends Ref_Info(CONSTANT_InterfaceMethodref) + class Long_info(val value: Long) extends PoolEntry(CONSTANT_Long) { + override def width = 2 + } + class Methodref_info(val class_index: UShort, val name_and_type_index: UShort) extends Ref_Info(CONSTANT_Methodref) + class NameAndType_info(val name_index: UShort, val descriptor_index: UShort) extends Name_Info(CONSTANT_NameAndType) { + override def toString = "NameAndType #%s:#%s;".format(name_index, descriptor_index) + } + class String_info(val string_index: UShort) extends PoolEntry(CONSTANT_String) { } + class Utf8_info(override val stringValue: String) extends PoolEntry(CONSTANT_Utf8) { + override def toString = ("Asciz " + stringValue).trim + } + + abstract class PoolEntry(tag: Byte) { + def width = 1 + def stringValue: String = sys.error("Not a String-valued constant pool entry: " + this) + override def toString = ( + getClass.getName.split("[.$]").last + "/" + tag + ) + } + object NoEntry extends PoolEntry(-1) { } +} + +abstract class JvmInfo(attributes: Array[JvmAttributeInfo]) { + // def flags: Short + def name: String + + val signature = attributes collectFirst { case x: SignatureAttr => x.value } getOrElse "" + val innerClasses = attributes collectFirst { case x: InnerClassesAttr => x.value } getOrElse Array() +} + + +class JvmClassInfo( + val name: String, + val superName: String, + val interfaces: Array[String], + val fields: Array[JvmMemberInfo], + val methods: Array[JvmMemberInfo], + attributes: Array[JvmAttributeInfo] +) extends JvmInfo(attributes) { + + def members = fields ++ methods sortBy (_.decodedName) + def memberDescriptors = members map (_.toErasedString) + def memberSignatures = members filter (_.hasSignature) map (_.toGenericString) + def descriptorsString = if (memberDescriptors.nonEmpty) memberDescriptors.mkString("\n-- Member Descriptors --\n", "\n", "\n") else "" + def signaturesString = if (memberSignatures.nonEmpty) memberSignatures.mkString("\n-- Member Signatures --\n", "\n", "\n") else "" + def innersString = if (innerClasses.isEmpty) "" else innerClasses.mkString("\n-- Inner Classes --\n", "\n", "\n") + def membersString = descriptorsString + signaturesString + def extendsString = if (superName == "") "" else " extends " + superName + def implementsString = if (interfaces.isEmpty) "" else interfaces.mkString("Implements: ", ", ", "") + + private def group(label: String, xs: Traversable[(String, String)]) = + xs map { case (name, value) => line(label, name, value) } mkString "\n" + + private def line(label: String, name: String, data: String) = + trimTrailingSpace(" %-15s %30s %s".format(label, name, data)) + + override def toString = ( + List( + "class " + name + extendsString, + if (signature == "") "" else line("class sig", "", signature), + group("interface", interfaces map (x => (("", x)))), + (innerClasses map (ic => line(ic.kind, ic.innerName, ic.nestString))).sorted.mkString("\n"), + group("descriptor", members map (x => (x.name, x.descriptor))), + group("signature", members filter (_.hasSignature) map (x => (x.name, x.signature))) + ) map trimTrailingSpace filterNot (_ == "") mkString ("", "\n", "\n") + ) +} + +// method_info or field_info { +// u2 access_flags; +// u2 name_index; +// u2 descriptor_index; +// u2 attributes_count; +// attribute_info attributes[attributes_count]; +// } +class JvmMemberInfo( + val flags: Short, + val name: String, + val descriptor: String, + attributes: Array[JvmAttributeInfo] +) extends JvmInfo(attributes) { + def decodedName = decode(name) + def hasSignature = signature != "" + def toErasedString = "%-30s %s".format(decodedName, descriptor) + def toGenericString = "%-30s %s".format(decodedName, signature) + + override def toString = ( + if (hasSignature) toGenericString else toErasedString + ) +} + +abstract class JvmAttributeInfo { + def name: String + def value: Any +} +class GenericAttr(val name: String, val value: Array[Byte]) extends JvmAttributeInfo { + // attribute_info { + // u2 attribute_name_index; + // u4 attribute_length; + // u1 info[attribute_length]; + // } +} +class SignatureAttr(val value: String) extends JvmAttributeInfo { + def name = "Signature" +} +class InnerClassesAttr(val value: Array[JvmInnerClassInfo]) extends JvmAttributeInfo { + def name = "InnerClasses" +} + +// package foo { class Foo { class Bar } } +// +// javap would say +// Bar = class foo.Foo$Bar of class foo.Foo +// which is translated as +// innerClass = foo.Foo$Bar +// outerClass = foo.Foo +// innerName = Bar + +class JvmInnerClassInfo( + thisClass: String, // classfile which is being parsed + val innerClass: String, // the full name of the inner/nested class + val outerClass: String, // the full name of the outer class - must be a prefix of innerClass + val innerName: String, // the simple name of the inner class - should (?) be a suffix of innerClass + val flags: Short // flags +) { + val isEntryOfEnclosingClass = !isAnonymousClass && (innerClass == thisClass) + val isEntryOfNestedClass = !isAnonymousClass && (outerClass == thisClass) + + def isTopLevelClass = outerClass == "" + def isAnonymousClass = innerName == "" + def isMemberClass = !isTopLevelClass + + def kind = ( + if (isEntryOfEnclosingClass) "inner/enclosing" + else if (isEntryOfNestedClass) "inner/nested" + else if (isAnonymousClass) "inner/anon" + else "inner" + ) + def nestString = ( + if (isEntryOfEnclosingClass) "enclosing class: " + outerClass + else if (isEntryOfNestedClass) "member class: " + innerClass + else if (isAnonymousClass) "anonymous class: " + innerClass + else innerClass + " in " + outerClass + ) + override def toString = innerName + "=" + nestString +} + +object JvmClassInfo { + private def classFiles(path: String) = + Directory(path).deepFiles filter (_ hasExtension "class") + + def classInfoMap(path: String): Map[String, JvmClassInfo] = { + classFiles(path) map (f => (f.path, JvmClassInfo fromFile f.jfile)) toMap + } + def classInfoList(path: String): List[(String, JvmClassInfo)] = { + classInfoMap(path).toList sortBy (_._1) + } + + def fromFile(file: java.io.File) = + fromStream(new BufferedInputStream(new FileInputStream(file))) + + def fromBytes(bytes: Array[Byte]) = + fromStream(new ByteArrayInputStream(bytes)) + + def fromPath(path: String) = + fromStream(new BufferedInputStream(new FileInputStream(path))) + + def fromStream(in0: InputStream) = { + val in = new DataInputStream(in0) + try fromDataInput(in) finally in.close() + } + + def fromDataInput(in: DataInput): JvmClassInfo = { + new JvmClassInfoBuilder(in) parse + } +} diff --git a/src/compiler/scala/reflect/internal/NameManglers.scala b/src/compiler/scala/reflect/internal/NameManglers.scala deleted file mode 100644 index ac22017569..0000000000 --- a/src/compiler/scala/reflect/internal/NameManglers.scala +++ /dev/null @@ -1,216 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Martin Odersky - */ - -package scala.reflect -package internal - -import java.security.MessageDigest -import scala.io.Codec -import Chars.isOperatorPart - -/** A trait to encapsulate name mangling. It's intended for the - * values and methods involved in assembling names out of other names, - * and not for simple synthetically named locals. - */ -trait NameManglers { - self: SymbolTable => - - trait NameManglingCommon { - self: CommonNames => - - val MODULE_SUFFIX_STRING = NameTransformer.MODULE_SUFFIX_STRING - val NAME_JOIN_STRING = NameTransformer.NAME_JOIN_STRING - - val MODULE_SUFFIX_NAME: TermName = newTermName(MODULE_SUFFIX_STRING) - val NAME_JOIN_NAME: TermName = newTermName(NAME_JOIN_STRING) - - def flattenedName(segments: Name*): NameType = compactedString(segments mkString NAME_JOIN_STRING) - - /** - * COMPACTIFY - * - * The hashed name has the form (prefix + marker + md5 + marker + suffix), where - * - prefix/suffix.length = MaxNameLength / 4 - * - md5.length = 32 - * - * We obtain the formula: - * - * FileNameLength = 2*(MaxNameLength / 4) + 2.marker.length + 32 + 6 - * - * (+6 for ".class"). MaxNameLength can therefore be computed as follows: - */ - private final val marker = "$$$$" - private final val MaxNameLength = math.min( - settings.maxClassfileName.value - 6, - 2 * (settings.maxClassfileName.value - 6 - 2*marker.length - 32) - ) - private lazy val md5 = MessageDigest.getInstance("MD5") - private def toMD5(s: String, edge: Int) = { - val prefix = s take edge - val suffix = s takeRight edge - - val cs = s.toArray - val bytes = Codec toUTF8 cs - md5 update bytes - val md5chars = md5.digest() map (b => (b & 0xFF).toHexString) mkString - - prefix + marker + md5chars + marker + suffix - } - private def compactedString(s: String) = - if (s.length <= MaxNameLength) s - else toMD5(s, MaxNameLength / 4) - } - - trait TypeNameMangling extends NameManglingCommon { - self: tpnme.type => - - } - - trait TermNameMangling extends NameManglingCommon { - self: nme.type => - - val IMPL_CLASS_SUFFIX = "$class" - val LOCALDUMMY_PREFIX = "<local " // owner of local blocks - val PROTECTED_PREFIX = "protected$" - val PROTECTED_SET_PREFIX = PROTECTED_PREFIX + "set" - val SINGLETON_SUFFIX = ".type" - val SUPER_PREFIX_STRING = "super$" - val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$" - val SETTER_SUFFIX: TermName = encode("_=") - - @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0") - def SPECIALIZED_SUFFIX_STRING = SPECIALIZED_SUFFIX.toString - @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0") - def SPECIALIZED_SUFFIX_NAME: TermName = SPECIALIZED_SUFFIX.toTermName - - def isConstructorName(name: Name) = name == CONSTRUCTOR || name == MIXIN_CONSTRUCTOR - def isExceptionResultName(name: Name) = name startsWith EXCEPTION_RESULT_PREFIX - def isImplClassName(name: Name) = name endsWith IMPL_CLASS_SUFFIX - def isLocalDummyName(name: Name) = name startsWith LOCALDUMMY_PREFIX - def isLocalName(name: Name) = name endsWith LOCAL_SUFFIX_STRING - def isLoopHeaderLabel(name: Name) = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX) - def isProtectedAccessorName(name: Name) = name startsWith PROTECTED_PREFIX - def isSuperAccessorName(name: Name) = name startsWith SUPER_PREFIX_STRING - def isReplWrapperName(name: Name) = name containsName INTERPRETER_IMPORT_WRAPPER - def isSetterName(name: Name) = name endsWith SETTER_SUFFIX - def isTraitSetterName(name: Name) = isSetterName(name) && (name containsName TRAIT_SETTER_SEPARATOR_STRING) - def isSingletonName(name: Name) = name endsWith SINGLETON_SUFFIX - def isModuleName(name: Name) = name endsWith MODULE_SUFFIX_NAME - - def isOpAssignmentName(name: Name) = name match { - case raw.NE | raw.LE | raw.GE | EMPTY => false - case _ => - name.endChar == '=' && name.startChar != '=' && isOperatorPart(name.startChar) - } - - /** The expanded setter name of `name` relative to this class `base` - */ - def expandedSetterName(name: TermName, base: Symbol): TermName = - expandedName(name, base, separator = TRAIT_SETTER_SEPARATOR_STRING) - - /** If `name` is an expandedName name, the original name. - * Otherwise `name` itself. - */ - def originalName(name: Name): Name = { - var i = name.length - while (i >= 2 && !(name(i - 1) == '$' && name(i - 2) == '$')) i -= 1 - if (i >= 2) { - while (i >= 3 && name(i - 3) == '$') i -= 1 - name.subName(i, name.length) - } else name - } - - def unspecializedName(name: Name): Name = ( - if (name endsWith SPECIALIZED_SUFFIX) - name.subName(0, name.lastIndexOf('m') - 1) - else name - ) - - /** Return the original name and the types on which this name - * is specialized. For example, - * {{{ - * splitSpecializedName("foo$mIcD$sp") == ('foo', "I", "D") - * }}} - * `foo$mIcD$sp` is the name of a method specialized on two type - * parameters, the first one belonging to the method itself, on Int, - * and another one belonging to the enclosing class, on Double. - */ - def splitSpecializedName(name: Name): (Name, String, String) = - if (name endsWith SPECIALIZED_SUFFIX) { - val name1 = name dropRight SPECIALIZED_SUFFIX.length - val idxC = name1 lastIndexOf 'c' - val idxM = name1 lastIndexOf 'm' - - (name1.subName(0, idxM - 1), - name1.subName(idxC + 1, name1.length).toString, - name1.subName(idxM + 1, idxC).toString) - } else - (name, "", "") - - def getterName(name: TermName): TermName = if (isLocalName(name)) localToGetter(name) else name - def getterToLocal(name: TermName): TermName = name append LOCAL_SUFFIX_STRING - def getterToSetter(name: TermName): TermName = name append SETTER_SUFFIX - def localToGetter(name: TermName): TermName = name dropRight LOCAL_SUFFIX_STRING.length - - def dropLocalSuffix(name: Name): Name = if (name endsWith ' ') name dropRight 1 else name - - def setterToGetter(name: TermName): TermName = { - val p = name.pos(TRAIT_SETTER_SEPARATOR_STRING) - if (p < name.length) - setterToGetter(name drop (p + TRAIT_SETTER_SEPARATOR_STRING.length)) - else - name.subName(0, name.length - SETTER_SUFFIX.length) - } - - def defaultGetterName(name: Name, pos: Int): TermName = { - val prefix = if (isConstructorName(name)) "init" else name - newTermName(prefix + DEFAULT_GETTER_STRING + pos) - } - def defaultGetterToMethod(name: Name): TermName = { - val p = name.pos(DEFAULT_GETTER_STRING) - if (p < name.length) name.toTermName.subName(0, p) - else name.toTermName - } - - // def anonNumberSuffix(name: Name): Name = { - // ("" + name) lastIndexOf '$' match { - // case -1 => nme.EMPTY - // case idx => - // val s = name drop idx - // if (s.toString forall (_.isDigit)) s - // else nme.EMPTY - // } - // } - - // If the name ends with $nn where nn are - // all digits, strip the $ and the digits. - // Otherwise return the argument. - def stripAnonNumberSuffix(name: Name): Name = { - var pos = name.length - while (pos > 0 && name(pos - 1).isDigit) - pos -= 1 - - if (pos <= 0 || pos == name.length || name(pos - 1) != '$') name - else name.subName(0, pos - 1) - } - - def stripModuleSuffix(name: Name): Name = ( - if (isModuleName(name)) name dropRight MODULE_SUFFIX_STRING.length else name - ) - - def dropSingletonName(name: Name): TypeName = name dropRight SINGLETON_SUFFIX.length toTypeName - def singletonName(name: Name): TypeName = name append SINGLETON_SUFFIX toTypeName - def implClassName(name: Name): TypeName = name append IMPL_CLASS_SUFFIX toTypeName - def interfaceName(implname: Name): TypeName = implname dropRight IMPL_CLASS_SUFFIX.length toTypeName - def localDummyName(clazz: Symbol): TermName = newTermName(LOCALDUMMY_PREFIX + clazz.name + ">") - def superName(name: Name): TermName = newTermName(SUPER_PREFIX_STRING + name) - - /** The name of an accessor for protected symbols. */ - def protName(name: Name): TermName = newTermName(PROTECTED_PREFIX + name) - - /** The name of a setter for protected symbols. Used for inherited Java fields. */ - def protSetterName(name: Name): TermName = newTermName(PROTECTED_SET_PREFIX + name) - } -} diff --git a/src/compiler/scala/reflect/internal/Names.scala b/src/compiler/scala/reflect/internal/Names.scala index d2b55d9d39..23eaa1088c 100644 --- a/src/compiler/scala/reflect/internal/Names.scala +++ b/src/compiler/scala/reflect/internal/Names.scala @@ -356,8 +356,10 @@ trait Names extends api.Names { final def endsWith(char: Char): Boolean = len > 0 && endChar == char final def endsWith(name: String): Boolean = endsWith(newTermName(name)) - def dropRight(n: Int) = subName(0, len - n) - def drop(n: Int) = subName(n, len) + def dropRight(n: Int): ThisNameType = subName(0, len - n) + def drop(n: Int): ThisNameType = subName(n, len) + def stripSuffix(suffix: Name): ThisNameType = + if (this endsWith suffix) dropRight(suffix.length) else thisName def indexOf(ch: Char) = { val idx = pos(ch) @@ -395,14 +397,14 @@ trait Names extends api.Names { // def decodedName: ThisNameType = newName(decoded) def encodedName: ThisNameType = encode - /** Replace operator symbols by corresponding $op_name. */ + /** Replace operator symbols by corresponding \$op_name. */ def encode: ThisNameType = { val str = toString val res = NameTransformer.encode(str) if (res == str) thisName else newName(res) } - /** Replace $op_name by corresponding operator symbol. */ + /** Replace \$op_name by corresponding operator symbol. */ def decode: String = { if (this containsChar '$') { val str = toString diff --git a/src/compiler/scala/reflect/internal/Reporters.scala b/src/compiler/scala/reflect/internal/Reporters.scala deleted file mode 100644 index 20d4a1d026..0000000000 --- a/src/compiler/scala/reflect/internal/Reporters.scala +++ /dev/null @@ -1,74 +0,0 @@ -package scala.reflect -package internal - -trait Reporters { self: SymbolTable => - - import self.{Reporter => ApiReporter} - import scala.tools.nsc.reporters._ - import scala.tools.nsc.reporters.{Reporter => NscReporter} - import scala.tools.nsc.Settings - - def mkConsoleReporter(minSeverity: Int = 1): ApiReporter = { - val settings = new Settings() - if (minSeverity <= 0) settings.verbose.value = true - if (minSeverity > 1) settings.nowarn.value = true - wrapNscReporter(new ConsoleReporter(settings)) - } - - abstract class ApiToNscReporterProxy(val apiReporter: ApiReporter) extends AbstractReporter { - import apiReporter.{Severity => ApiSeverity} - val API_INFO = apiReporter.INFO - val API_WARNING = apiReporter.WARNING - val API_ERROR = apiReporter.ERROR - - type NscSeverity = Severity - val NSC_INFO = INFO - val NSC_WARNING = WARNING - val NSC_ERROR = ERROR - - def display(pos: Position, msg: String, nscSeverity: NscSeverity): Unit = - apiReporter.log(pos, msg, nscSeverity match { - case NSC_INFO => API_INFO - case NSC_WARNING => API_WARNING - case NSC_ERROR => API_ERROR - }) - - def displayPrompt(): Unit = - apiReporter.interactive() - } - - def wrapApiReporter(apiReporter: ApiReporter): NscReporter = new ApiToNscReporterProxy(apiReporter) { - val settings = new Settings() - settings.verbose.value = true - settings.nowarn.value = false - } - - class NscToApiReporterProxy(val nscReporter: NscReporter) extends ApiReporter { - val API_INFO = INFO - val API_WARNING = WARNING - val API_ERROR = ERROR - - def display(info: Info): Unit = info.severity match { - case API_INFO => nscReporter.info(info.pos, info.msg, false) - case API_WARNING => nscReporter.warning(info.pos, info.msg) - case API_ERROR => nscReporter.error(info.pos, info.msg) - } - - def interactive(): Unit = nscReporter match { - case nscReporter: AbstractReporter => nscReporter.displayPrompt() - case _ => // do nothing - } - - override def flush(): Unit = { - super.flush() - nscReporter.flush() - } - - override def reset(): Unit = { - super.reset() - nscReporter.reset() - } - } - - def wrapNscReporter(nscReporter: NscReporter): ApiReporter = new NscToApiReporterProxy(nscReporter) -} diff --git a/src/compiler/scala/reflect/internal/Scopes.scala b/src/compiler/scala/reflect/internal/Scopes.scala index ef48d6102f..36e8ebb212 100644 --- a/src/compiler/scala/reflect/internal/Scopes.scala +++ b/src/compiler/scala/reflect/internal/Scopes.scala @@ -113,7 +113,7 @@ trait Scopes extends api.Scopes { self: SymbolTable => * * @param sym ... */ - def enter(sym: Symbol): Symbol = { enter(newScopeEntry(sym, this)); sym } + def enter[T <: Symbol](sym: T): T = { enter(newScopeEntry(sym, this)); sym } /** enter a symbol, asserting that no symbol with same name exists in scope * diff --git a/src/compiler/scala/reflect/internal/StdAttachments.scala b/src/compiler/scala/reflect/internal/StdAttachments.scala new file mode 100644 index 0000000000..ae2ad87deb --- /dev/null +++ b/src/compiler/scala/reflect/internal/StdAttachments.scala @@ -0,0 +1,10 @@ +package scala.reflect +package internal + +import scala.reflect.makro.runtime.{Context => MacroContext} + +trait StdAttachments { + self: SymbolTable => + + case class ReifyAttachment(original: Symbol) +}
\ No newline at end of file diff --git a/src/compiler/scala/reflect/internal/StdNames.scala b/src/compiler/scala/reflect/internal/StdNames.scala index bf468affe6..a55efea2e6 100644 --- a/src/compiler/scala/reflect/internal/StdNames.scala +++ b/src/compiler/scala/reflect/internal/StdNames.scala @@ -6,27 +6,141 @@ package scala.reflect package internal -import scala.collection.immutable -import NameTransformer.MODULE_SUFFIX_STRING +import java.security.MessageDigest +import Chars.isOperatorPart import annotation.switch import language.implicitConversions +import scala.collection.immutable +import scala.io.Codec -trait StdNames extends NameManglers { self: SymbolTable => +trait StdNames { + self: SymbolTable => def encode(str: String): TermName = newTermNameCached(NameTransformer.encode(str)) implicit def lowerTermNames(n: TermName): String = n.toString - // implicit def stringToTermName(s: String): TermName = newTermName(s) - - /** This should be the first trait in the linearization. */ - trait Keywords { + /** Tensions: would like the keywords to be the very first names entered into the names + * storage so their ids count from 0, which simplifies the parser. Switched to abstract + * classes to avoid all the indirection which is generated with implementation-containing + * traits. Since all these classes use eager vals, that means the constructor with the + * keywords must run first. If it's the top in the superclass chain, then CommonNames + * must inherit from it, which means TypeNames would inherit keywords as well. + * + * Solution: Keywords extends CommonNames and uses early defs to beat the + * CommonNames constructor out of the starting gate. This is its builder. + */ + private class KeywordSetBuilder { private var kws: Set[TermName] = Set() - private def kw(s: String): TermName = { + def apply(s: String): TermName = { val result = newTermNameCached(s) kws = kws + result result } + def result: Set[TermName] = { + val result = kws + kws = null + result + } + } + + private final object compactify extends (String => String) { + val md5 = MessageDigest.getInstance("MD5") + + /** + * COMPACTIFY + * + * The hashed name has the form (prefix + marker + md5 + marker + suffix), where + * - prefix/suffix.length = MaxNameLength / 4 + * - md5.length = 32 + * + * We obtain the formula: + * + * FileNameLength = 2*(MaxNameLength / 4) + 2.marker.length + 32 + 6 + * + * (+6 for ".class"). MaxNameLength can therefore be computed as follows: + */ + val marker = "$$$$" + val MaxNameLength = math.min( + settings.maxClassfileName.value - 6, + 2 * (settings.maxClassfileName.value - 6 - 2*marker.length - 32) + ) + def toMD5(s: String, edge: Int): String = { + val prefix = s take edge + val suffix = s takeRight edge + + val cs = s.toArray + val bytes = Codec toUTF8 cs + md5 update bytes + val md5chars = md5.digest() map (b => (b & 0xFF).toHexString) mkString + + prefix + marker + md5chars + marker + suffix + } + def apply(s: String): String = ( + if (s.length <= MaxNameLength) s + else toMD5(s, MaxNameLength / 4) + ) + } + + abstract class CommonNames { + type NameType <: Name + protected implicit def createNameType(name: String): NameType + + def flattenedName(segments: Name*): NameType = + compactify(segments mkString NAME_JOIN_STRING) + + val MODULE_SUFFIX_STRING: String = NameTransformer.MODULE_SUFFIX_STRING + val NAME_JOIN_STRING: String = NameTransformer.NAME_JOIN_STRING + val SINGLETON_SUFFIX: String = ".type" + + val ANON_CLASS_NAME: NameType = "$anon" + val ANON_FUN_NAME: NameType = "$anonfun" + val EMPTY: NameType = "" + val EMPTY_PACKAGE_NAME: NameType = "<empty>" + val IMPL_CLASS_SUFFIX = "$class" + val IMPORT: NameType = "<import>" + val MODULE_SUFFIX_NAME: NameType = MODULE_SUFFIX_STRING + val MODULE_VAR_SUFFIX: NameType = "$module" + val NAME_JOIN_NAME: NameType = NAME_JOIN_STRING + val PACKAGE: NameType = "package" + val ROOT: NameType = "<root>" + val SPECIALIZED_SUFFIX: NameType = "$sp" + + // value types (and AnyRef) are all used as terms as well + // as (at least) arguments to the @specialize annotation. + final val Boolean: NameType = "Boolean" + final val Byte: NameType = "Byte" + final val Char: NameType = "Char" + final val Double: NameType = "Double" + final val Float: NameType = "Float" + final val Int: NameType = "Int" + final val Long: NameType = "Long" + final val Short: NameType = "Short" + final val Unit: NameType = "Unit" + + final val ScalaValueNames: scala.List[NameType] = + scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit) + + // some types whose companions we utilize + final val AnyRef: NameType = "AnyRef" + final val Array: NameType = "Array" + final val List: NameType = "List" + final val Seq: NameType = "Seq" + final val Symbol: NameType = "Symbol" + final val ClassTag: NameType = "ClassTag" + final val TypeTag : NameType = "TypeTag" + final val ConcreteTypeTag: NameType = "ConcreteTypeTag" + + // fictions we use as both types and terms + final val ERROR: NameType = "<error>" + final val NO_NAME: NameType = "<none>" // formerly NOSYMBOL + final val WILDCARD: NameType = "_" + } + + /** This should be the first trait in the linearization. */ + // abstract class Keywords extends CommonNames { + abstract class Keywords extends { + private val kw = new KeywordSetBuilder final val ABSTRACTkw: TermName = kw("abstract") final val CASEkw: TermName = kw("case") @@ -81,66 +195,20 @@ trait StdNames extends NameManglers { self: SymbolTable => final val HASHkw: TermName = kw("#") final val ATkw: TermName = kw("@") - final val keywords = { - val result = kws.toSet - kws = null - result - } - + final val keywords = kw.result + } with CommonNames { final val javaKeywords = new JavaKeywords() } - trait CommonNames /*extends LibraryCommonNames*/ { - - type NameType <: Name - protected implicit def createNameType(name: String): NameType - - val EMPTY: NameType = "" - val ANON_FUN_NAME: NameType = "$anonfun" - val ANON_CLASS_NAME: NameType = "$anon" - val EMPTY_PACKAGE_NAME: NameType = "<empty>" - val IMPORT: NameType = "<import>" - val MODULE_VAR_SUFFIX: NameType = "$module" - val ROOT: NameType = "<root>" - val PACKAGE: NameType = "package" - val SPECIALIZED_SUFFIX: NameType = "$sp" - - // value types (and AnyRef) are all used as terms as well - // as (at least) arguments to the @specialize annotation. - final val Boolean: NameType = "Boolean" - final val Byte: NameType = "Byte" - final val Char: NameType = "Char" - final val Double: NameType = "Double" - final val Float: NameType = "Float" - final val Int: NameType = "Int" - final val Long: NameType = "Long" - final val Short: NameType = "Short" - final val Unit: NameType = "Unit" - - final val ScalaValueNames: scala.List[NameType] = - scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit) - - // some types whose companions we utilize - final val AnyRef: NameType = "AnyRef" - final val Array: NameType = "Array" - final val List: NameType = "List" - final val Seq: NameType = "Seq" - final val Symbol: NameType = "Symbol" - final val ClassTag: NameType = "ClassTag" - final val TypeTag : NameType = "TypeTag" - final val ConcreteTypeTag: NameType = "ConcreteTypeTag" - - // fictions we use as both types and terms - final val ERROR: NameType = "<error>" - final val NO_NAME: NameType = "<none>" // formerly NOSYMBOL - final val WILDCARD: NameType = "_" - } + abstract class TypeNames extends Keywords { + type NameType = TypeName + protected implicit def createNameType(name: String): TypeName = newTypeNameCached(name) - trait TypeNames extends CommonNames { final val BYNAME_PARAM_CLASS_NAME: NameType = "<byname>" final val EQUALS_PATTERN_NAME: NameType = "<equals>" final val JAVA_REPEATED_PARAM_CLASS_NAME: NameType = "<repeated...>" final val LOCAL_CHILD: NameType = "<local child>" + final val REFINE_CLASS_NAME: NameType = "<refinement>" final val REPEATED_PARAM_CLASS_NAME: NameType = "<repeated>" final val WILDCARD_STAR: NameType = "_*" @@ -161,7 +229,7 @@ trait StdNames extends NameManglers { self: SymbolTable => final val Annotation: NameType = "Annotation" final val ClassfileAnnotation: NameType = "ClassfileAnnotation" final val Enum: NameType = "Enum" - + final val Group: NameType = "Group" final val Tree: NameType = "Tree" final val TypeTree: NameType = "TypeTree" @@ -189,34 +257,195 @@ trait StdNames extends NameManglers { self: SymbolTable => final val SignatureATTR: NameType = "Signature" final val SourceFileATTR: NameType = "SourceFile" final val SyntheticATTR: NameType = "Synthetic" + + def dropSingletonName(name: Name): TypeName = name dropRight SINGLETON_SUFFIX.length toTypeName + def singletonName(name: Name): TypeName = name append SINGLETON_SUFFIX toTypeName + def implClassName(name: Name): TypeName = name append IMPL_CLASS_SUFFIX toTypeName + def interfaceName(implname: Name): TypeName = implname dropRight IMPL_CLASS_SUFFIX.length toTypeName } - trait TermNames extends Keywords with CommonNames { + abstract class TermNames extends Keywords { + type NameType = TermName + protected implicit def createNameType(name: String): TermName = newTermNameCached(name) + + /** Base strings from which synthetic names are derived. */ + val BITMAP_PREFIX = "bitmap$" + val CHECK_IF_REFUTABLE_STRING = "check$ifrefutable$" + val DEFAULT_GETTER_STRING = "$default$" + val DO_WHILE_PREFIX = "doWhile$" + val EVIDENCE_PARAM_PREFIX = "evidence$" + val EXCEPTION_RESULT_PREFIX = "exceptionResult" + val EXPAND_SEPARATOR_STRING = "$$" + val INTERPRETER_IMPORT_WRAPPER = "$iw" + val INTERPRETER_LINE_PREFIX = "line" + val INTERPRETER_VAR_PREFIX = "res" + val INTERPRETER_WRAPPER_SUFFIX = "$object" + val LOCALDUMMY_PREFIX = "<local " // owner of local blocks + val PROTECTED_PREFIX = "protected$" + val PROTECTED_SET_PREFIX = PROTECTED_PREFIX + "set" + val SUPER_PREFIX_STRING = "super$" + val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$" + val WHILE_PREFIX = "while$" + // Compiler internal names - val EXPAND_SEPARATOR_STRING = "$$" - - val ANYNAME: NameType = "<anyname>" - val CONSTRUCTOR: NameType = "<init>" - val FAKE_LOCAL_THIS: NameType = "this$" - val INITIALIZER: NameType = CONSTRUCTOR // Is this buying us something? - val LAZY_LOCAL: NameType = "$lzy" - val LOCAL_SUFFIX_STRING = " " - val MIRROR_PREFIX: NameType = "$mr." - val MIRROR_SHORT: NameType = "$mr" - val MIRROR_FREE_PREFIX: NameType = "free$" - val MIRROR_FREE_THIS_SUFFIX: NameType = "$this" - val MIRROR_FREE_VALUE_SUFFIX: NameType = "$value" - val MIRROR_SYMDEF_PREFIX: NameType = "symdef$" - val MIXIN_CONSTRUCTOR: NameType = "$init$" - val MODULE_INSTANCE_FIELD: NameType = NameTransformer.MODULE_INSTANCE_NAME // "MODULE$" - val OUTER: NameType = "$outer" - val OUTER_LOCAL: NameType = OUTER + LOCAL_SUFFIX_STRING // "$outer ", note the space - val OUTER_SYNTH: NameType = "<outer>" // emitted by virtual pattern matcher, replaced by outer accessor in explicitouter - val SELECTOR_DUMMY: NameType = "<unapply-selector>" - val SELF: NameType = "$this" - val SPECIALIZED_INSTANCE: NameType = "specInstance$" - val STAR: NameType = "*" - val THIS: NameType = "_$this" + val ANYNAME: NameType = "<anyname>" + val CONSTRUCTOR: NameType = "<init>" + val FAKE_LOCAL_THIS: NameType = "this$" + val INITIALIZER: NameType = CONSTRUCTOR // Is this buying us something? + val LAZY_LOCAL: NameType = "$lzy" + val LOCAL_SUFFIX_STRING = " " + val MIRROR_FREE_PREFIX: NameType = "free$" + val MIRROR_FREE_THIS_SUFFIX: NameType = "$this" + val MIRROR_FREE_VALUE_SUFFIX: NameType = "$value" + val MIRROR_PREFIX: NameType = "$mr." + val MIRROR_SHORT: NameType = "$mr" + val MIRROR_SYMDEF_PREFIX: NameType = "symdef$" + val MIXIN_CONSTRUCTOR: NameType = "$init$" + val MODULE_INSTANCE_FIELD: NameType = NameTransformer.MODULE_INSTANCE_NAME // "MODULE$" + val OUTER: NameType = "$outer" + val OUTER_LOCAL: NameType = OUTER + LOCAL_SUFFIX_STRING // "$outer ", note the space + val OUTER_SYNTH: NameType = "<outer>" // emitted by virtual pattern matcher, replaced by outer accessor in explicitouter + val SELECTOR_DUMMY: NameType = "<unapply-selector>" + val SELF: NameType = "$this" + val SETTER_SUFFIX: NameType = encode("_=") + val SPECIALIZED_INSTANCE: NameType = "specInstance$" + val STAR: NameType = "*" + val THIS: NameType = "_$this" + + @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0") + def SPECIALIZED_SUFFIX_STRING = SPECIALIZED_SUFFIX.toString + @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0") + def SPECIALIZED_SUFFIX_NAME: TermName = SPECIALIZED_SUFFIX.toTermName + + def isConstructorName(name: Name) = name == CONSTRUCTOR || name == MIXIN_CONSTRUCTOR + def isExceptionResultName(name: Name) = name startsWith EXCEPTION_RESULT_PREFIX + def isImplClassName(name: Name) = name endsWith IMPL_CLASS_SUFFIX + def isLocalDummyName(name: Name) = name startsWith LOCALDUMMY_PREFIX + def isLocalName(name: Name) = name endsWith LOCAL_SUFFIX_STRING + def isLoopHeaderLabel(name: Name) = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX) + def isProtectedAccessorName(name: Name) = name startsWith PROTECTED_PREFIX + def isSuperAccessorName(name: Name) = name startsWith SUPER_PREFIX_STRING + def isReplWrapperName(name: Name) = name containsName INTERPRETER_IMPORT_WRAPPER + def isSetterName(name: Name) = name endsWith SETTER_SUFFIX + def isTraitSetterName(name: Name) = isSetterName(name) && (name containsName TRAIT_SETTER_SEPARATOR_STRING) + def isSingletonName(name: Name) = name endsWith SINGLETON_SUFFIX + def isModuleName(name: Name) = name endsWith MODULE_SUFFIX_NAME + + def isOpAssignmentName(name: Name) = name match { + case raw.NE | raw.LE | raw.GE | EMPTY => false + case _ => + name.endChar == '=' && name.startChar != '=' && isOperatorPart(name.startChar) + } + + /** The expanded name of `name` relative to this class `base` with given `separator` + */ + def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName = + newTermNameCached(base.fullName('$') + separator + name) + + /** The expanded setter name of `name` relative to this class `base` + */ + def expandedSetterName(name: TermName, base: Symbol): TermName = + expandedName(name, base, separator = TRAIT_SETTER_SEPARATOR_STRING) + + /** If `name` is an expandedName name, the original name. + * Otherwise `name` itself. + */ + def originalName(name: Name): Name = { + var i = name.length + while (i >= 2 && !(name(i - 1) == '$' && name(i - 2) == '$')) i -= 1 + if (i >= 2) { + while (i >= 3 && name(i - 3) == '$') i -= 1 + name.subName(i, name.length) + } else name + } + + def unspecializedName(name: Name): Name = ( + if (name endsWith SPECIALIZED_SUFFIX) + name.subName(0, name.lastIndexOf('m') - 1) + else name + ) + + /* + def anonNumberSuffix(name: Name): Name = { + ("" + name) lastIndexOf '$' match { + case -1 => nme.EMPTY + case idx => + val s = name drop idx + if (s.toString forall (_.isDigit)) s + else nme.EMPTY + } + } + */ + + /** Return the original name and the types on which this name + * is specialized. For example, + * {{{ + * splitSpecializedName("foo$mIcD$sp") == ('foo', "I", "D") + * }}} + * `foo$mIcD$sp` is the name of a method specialized on two type + * parameters, the first one belonging to the method itself, on Int, + * and another one belonging to the enclosing class, on Double. + */ + def splitSpecializedName(name: Name): (Name, String, String) = + if (name endsWith SPECIALIZED_SUFFIX) { + val name1 = name dropRight SPECIALIZED_SUFFIX.length + val idxC = name1 lastIndexOf 'c' + val idxM = name1 lastIndexOf 'm' + + (name1.subName(0, idxM - 1), + name1.subName(idxC + 1, name1.length).toString, + name1.subName(idxM + 1, idxC).toString) + } else + (name, "", "") + + def getterName(name: TermName): TermName = if (isLocalName(name)) localToGetter(name) else name + def getterToLocal(name: TermName): TermName = name append LOCAL_SUFFIX_STRING + def getterToSetter(name: TermName): TermName = name append SETTER_SUFFIX + def localToGetter(name: TermName): TermName = name dropRight LOCAL_SUFFIX_STRING.length + + def dropLocalSuffix(name: Name): Name = if (name endsWith ' ') name dropRight 1 else name + + def setterToGetter(name: TermName): TermName = { + val p = name.pos(TRAIT_SETTER_SEPARATOR_STRING) + if (p < name.length) + setterToGetter(name drop (p + TRAIT_SETTER_SEPARATOR_STRING.length)) + else + name.subName(0, name.length - SETTER_SUFFIX.length) + } + + def defaultGetterName(name: Name, pos: Int): TermName = { + val prefix = if (isConstructorName(name)) "init" else name + newTermName(prefix + DEFAULT_GETTER_STRING + pos) + } + def defaultGetterToMethod(name: Name): TermName = { + val p = name.pos(DEFAULT_GETTER_STRING) + if (p < name.length) name.toTermName.subName(0, p) + else name.toTermName + } + + // If the name ends with $nn where nn are + // all digits, strip the $ and the digits. + // Otherwise return the argument. + def stripAnonNumberSuffix(name: Name): Name = { + var pos = name.length + while (pos > 0 && name(pos - 1).isDigit) + pos -= 1 + + if (pos <= 0 || pos == name.length || name(pos - 1) != '$') name + else name.subName(0, pos - 1) + } + + def stripModuleSuffix(name: Name): Name = ( + if (isModuleName(name)) name dropRight MODULE_SUFFIX_STRING.length else name + ) + def localDummyName(clazz: Symbol): TermName = newTermName(LOCALDUMMY_PREFIX + clazz.name + ">") + def superName(name: Name): TermName = newTermName(SUPER_PREFIX_STRING + name) + + /** The name of an accessor for protected symbols. */ + def protName(name: Name): TermName = newTermName(PROTECTED_PREFIX + name) + + /** The name of a setter for protected symbols. Used for inherited Java fields. */ + def protSetterName(name: Name): TermName = newTermName(PROTECTED_SET_PREFIX + name) final val Nil: NameType = "Nil" final val Predef: NameType = "Predef" @@ -291,11 +520,14 @@ trait StdNames extends NameManglers { self: SymbolTable => val AnnotationInfo: NameType = "AnnotationInfo" val Any: NameType = "Any" val AnyVal: NameType = "AnyVal" + val AppliedTypeTree: NameType = "AppliedTypeTree" val Apply: NameType = "Apply" val ArrayAnnotArg: NameType = "ArrayAnnotArg" + val Constant: NameType = "Constant" val ConstantType: NameType = "ConstantType" val EmptyPackage: NameType = "EmptyPackage" val EmptyPackageClass: NameType = "EmptyPackageClass" + val ExistentialTypeTree: NameType = "ExistentialTypeTree" val Expr: NameType = "Expr" val Ident: NameType = "Ident" val Import: NameType = "Import" @@ -330,6 +562,9 @@ trait StdNames extends NameManglers { self: SymbolTable => val applyOrElse: NameType = "applyOrElse" val args : NameType = "args" val argv : NameType = "argv" + val arrayClass: NameType = "arrayClass" + val arrayElementClass: NameType = "arrayElementClass" + val arrayTagToClassManifest: NameType = "arrayTagToClassManifest" val arrayValue: NameType = "arrayValue" val array_apply : NameType = "array_apply" val array_clone : NameType = "array_clone" @@ -347,6 +582,7 @@ trait StdNames extends NameManglers { self: SymbolTable => val checkInitialized: NameType = "checkInitialized" val classOf: NameType = "classOf" val clone_ : NameType = if (forMSIL) "MemberwiseClone" else "clone" // sn.OClone causes checkinit failure + val concreteTypeTagToManifest: NameType = "concreteTypeTagToManifest" val conforms: NameType = "conforms" val copy: NameType = "copy" val definitions: NameType = "definitions" @@ -395,22 +631,27 @@ trait StdNames extends NameManglers { self: SymbolTable => val macroContext : NameType = "c" val main: NameType = "main" val manifest: NameType = "manifest" + val manifestToConcreteTypeTag: NameType = "manifestToConcreteTypeTag" val map: NameType = "map" + val materializeArrayTag: NameType = "materializeArrayTag" val materializeClassTag: NameType = "materializeClassTag" - val materializeTypeTag: NameType = "materializeTypeTag" val materializeConcreteTypeTag: NameType = "materializeConcreteTypeTag" + val materializeErasureTag: NameType= "materializeErasureTag" + val materializeTypeTag: NameType = "materializeTypeTag" val mirror : NameType = "mirror" val moduleClass : NameType = "moduleClass" val name: NameType = "name" val ne: NameType = "ne" val newArray: NameType = "newArray" + val newFreeExistential: NameType = "newFreeExistential" val newFreeTerm: NameType = "newFreeTerm" val newFreeType: NameType = "newFreeType" val newNestedSymbol: NameType = "newNestedSymbol" val newScopeWith: NameType = "newScopeWith" + val next: NameType = "next" val nmeNewTermName: NameType = "newTermName" val nmeNewTypeName: NameType = "newTypeName" - val next: NameType = "next" + val normalize: NameType = "normalize" val notifyAll_ : NameType = "notifyAll" val notify_ : NameType = "notify" val null_ : NameType = "null" @@ -465,6 +706,7 @@ trait StdNames extends NameManglers { self: SymbolTable => val view_ : NameType = "view" val wait_ : NameType = "wait" val withFilter: NameType = "withFilter" + val wrap: NameType = "wrap" val zip: NameType = "zip" val synthSwitch: NameType = "$synthSwitch" @@ -502,19 +744,11 @@ trait StdNames extends NameManglers { self: SymbolTable => val toInteger: NameType = "toInteger" } - object tpnme extends AbsTypeNames with TypeNames /*with LibraryTypeNames*/ with TypeNameMangling { - type NameType = TypeName - protected implicit def createNameType(name: String): TypeName = newTypeNameCached(name) - - val REFINE_CLASS_NAME: NameType = "<refinement>" - } + object tpnme extends TypeNames with AbsTypeNames { } /** For fully qualified type names. */ object fulltpnme extends TypeNames { - type NameType = TypeName - protected implicit def createNameType(name: String): TypeName = newTypeNameCached(name) - val RuntimeNothing: NameType = "scala.runtime.Nothing$" val RuntimeNull: NameType = "scala.runtime.Null$" val JavaLangEnum: NameType = "java.lang.Enum" @@ -529,18 +763,9 @@ trait StdNames extends NameManglers { self: SymbolTable => val RuntimeNull = toBinary(fulltpnme.RuntimeNull).toTypeName } - object fullnme extends TermNames { - type NameType = TermName - protected implicit def createNameType(name: String): TermName = newTermNameCached(name) - - val MirrorPackage: NameType = "scala.reflect.mirror" - } - val javanme = nme.javaKeywords - object nme extends AbsTermNames with TermNames /*with LibraryTermNames*/ with TermNameMangling { - type NameType = TermName - protected implicit def createNameType(name: String): TermName = newTermNameCached(name) + object nme extends TermNames with AbsTermNames { /** Translate a String into a list of simple TypeNames and TermNames. * In all segments before the last, type/term is determined by whether @@ -580,45 +805,26 @@ trait StdNames extends NameManglers { self: SymbolTable => def newBitmapName(bitmapPrefix: Name, n: Int) = bitmapPrefix append ("" + n) - val BITMAP_PREFIX: String = "bitmap$" val BITMAP_NORMAL: NameType = BITMAP_PREFIX + "" // initialization bitmap for public/protected lazy vals val BITMAP_TRANSIENT: NameType = BITMAP_PREFIX + "trans$" // initialization bitmap for transient lazy vals val BITMAP_PRIVATE: NameType = BITMAP_PREFIX + "priv$" // initialization bitmap for private lazy vals val BITMAP_CHECKINIT: NameType = BITMAP_PREFIX + "init$" // initialization bitmap for checkinit values val BITMAP_CHECKINIT_TRANSIENT: NameType = BITMAP_PREFIX + "inittrans$" // initialization bitmap for transient checkinit values - /** The expanded name of `name` relative to this class `base` with given `separator` - */ - def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName = - newTermNameCached(base.fullName('$') + separator + name) - def isModuleVarName(name: Name): Boolean = stripAnonNumberSuffix(name) endsWith MODULE_VAR_SUFFIX def moduleVarName(name: TermName): TermName = newTermNameCached("" + name + MODULE_VAR_SUFFIX) - val ROOTPKG: TermName = "_root_" + val ROOTPKG: TermName = "_root_" + val EQEQ_LOCAL_VAR: TermName = "eqEqTemp$" - /** Base strings from which synthetic names are derived. */ - val CHECK_IF_REFUTABLE_STRING = "check$ifrefutable$" - val DEFAULT_GETTER_STRING = "$default$" - val DO_WHILE_PREFIX = "doWhile$" - val EQEQ_LOCAL_VAR_STRING = "eqEqTemp$" - val EVIDENCE_PARAM_PREFIX = "evidence$" - val EXCEPTION_RESULT_PREFIX = "exceptionResult" - val INTERPRETER_IMPORT_WRAPPER = "$iw" - val INTERPRETER_LINE_PREFIX = "line" - val INTERPRETER_VAR_PREFIX = "res" - val INTERPRETER_WRAPPER_SUFFIX = "$object" - val WHILE_PREFIX = "while$" - - val EQEQ_LOCAL_VAR: TermName = newTermName(EQEQ_LOCAL_VAR_STRING) - - def getCause = sn.GetCause - def getClass_ = sn.GetClass - def getMethod_ = sn.GetMethod - def invoke_ = sn.Invoke + def getCause = sn.GetCause + def getClass_ = sn.GetClass + def getComponentType = sn.GetComponentType + def getMethod_ = sn.GetMethod + def invoke_ = sn.Invoke val ADD = encode("+") val AND = encode("&") @@ -777,6 +983,11 @@ trait StdNames extends NameManglers { self: SymbolTable => case 22 => nme._22 case _ => newTermName("_" + j) } + + @deprecated("Use a method in tpnme", "2.10.0") def dropSingletonName(name: Name): TypeName = tpnme.dropSingletonName(name) + @deprecated("Use a method in tpnme", "2.10.0") def singletonName(name: Name): TypeName = tpnme.singletonName(name) + @deprecated("Use a method in tpnme", "2.10.0") def implClassName(name: Name): TypeName = tpnme.implClassName(name) + @deprecated("Use a method in tpnme", "2.10.0") def interfaceName(implname: Name): TypeName = tpnme.interfaceName(implname) } abstract class SymbolNames { @@ -802,6 +1013,7 @@ trait StdNames extends NameManglers { self: SymbolTable => val ForName : TermName val GetCause : TermName val GetClass : TermName + val GetComponentType : TermName val GetMethod : TermName val Invoke : TermName val JavaLang : TermName @@ -810,12 +1022,7 @@ trait StdNames extends NameManglers { self: SymbolTable => } class JavaKeywords { - private var kws: Set[TermName] = Set() - private def kw(s: String): TermName = { - val result = newTermNameCached(s) - kws = kws + result - result - } + private val kw = new KeywordSetBuilder final val ABSTRACTkw: TermName = kw("abstract") final val ASSERTkw: TermName = kw("assert") @@ -868,11 +1075,7 @@ trait StdNames extends NameManglers { self: SymbolTable => final val VOLATILEkw: TermName = kw("volatile") final val WHILEkw: TermName = kw("while") - final val keywords = { - val result = kws.toSet - kws = null - result - } + final val keywords = kw.result } private abstract class JavaNames extends SymbolNames { @@ -896,12 +1099,13 @@ trait StdNames extends NameManglers { self: SymbolTable => final val Throwable: TypeName = "java.lang.Throwable" final val ValueType: TypeName = tpnme.NO_NAME - final val ForName: TermName = newTermName("forName") - final val GetCause: TermName = newTermName("getCause") - final val GetClass: TermName = newTermName("getClass") - final val GetMethod: TermName = newTermName("getMethod") - final val Invoke: TermName = newTermName("invoke") - final val JavaLang: TermName = newTermName("java.lang") + final val ForName: TermName = newTermName("forName") + final val GetCause: TermName = newTermName("getCause") + final val GetClass: TermName = newTermName("getClass") + final val GetComponentType: TermName = newTermName("getComponentType") + final val GetMethod: TermName = newTermName("getMethod") + final val Invoke: TermName = newTermName("invoke") + final val JavaLang: TermName = newTermName("java.lang") val Boxed = immutable.Map[TypeName, TypeName]( tpnme.Boolean -> BoxedBoolean, @@ -933,12 +1137,13 @@ trait StdNames extends NameManglers { self: SymbolTable => final val Throwable: TypeName = "System.Exception" final val ValueType: TypeName = "System.ValueType" - final val ForName: TermName = newTermName("GetType") - final val GetCause: TermName = newTermName("InnerException") /* System.Reflection.TargetInvocationException.InnerException */ - final val GetClass: TermName = newTermName("GetType") - final val GetMethod: TermName = newTermName("GetMethod") - final val Invoke: TermName = newTermName("Invoke") - final val JavaLang: TermName = newTermName("System") + final val ForName: TermName = newTermName("GetType") + final val GetCause: TermName = newTermName("InnerException") /* System.Reflection.TargetInvocationException.InnerException */ + final val GetClass: TermName = newTermName("GetType") + final val GetComponentType: TermName = newTermName("GetElementType") + final val GetMethod: TermName = newTermName("GetMethod") + final val Invoke: TermName = newTermName("Invoke") + final val JavaLang: TermName = newTermName("System") val Boxed = immutable.Map[TypeName, TypeName]( tpnme.Boolean -> "System.Boolean", diff --git a/src/compiler/scala/reflect/internal/SymbolCreations.scala b/src/compiler/scala/reflect/internal/SymbolCreations.scala index a1163b0f57..ac82ffe62a 100644 --- a/src/compiler/scala/reflect/internal/SymbolCreations.scala +++ b/src/compiler/scala/reflect/internal/SymbolCreations.scala @@ -11,7 +11,6 @@ import scala.collection.mutable.ListBuffer import util.Statistics._ import Flags._ import api.Modifier -import scala.tools.util.StringOps.{ ojoin } trait SymbolCreations { self: SymbolTable => diff --git a/src/compiler/scala/reflect/internal/SymbolFlags.scala b/src/compiler/scala/reflect/internal/SymbolFlags.scala index febcec8c7c..7741d700b9 100644 --- a/src/compiler/scala/reflect/internal/SymbolFlags.scala +++ b/src/compiler/scala/reflect/internal/SymbolFlags.scala @@ -11,7 +11,6 @@ import scala.collection.mutable.ListBuffer import util.Statistics._ import Flags._ import api.Modifier -import scala.tools.util.StringOps.{ ojoin } trait SymbolFlags { self: SymbolTable => diff --git a/src/compiler/scala/reflect/internal/SymbolTable.scala b/src/compiler/scala/reflect/internal/SymbolTable.scala index 0268339ed0..9158c2a4d4 100644 --- a/src/compiler/scala/reflect/internal/SymbolTable.scala +++ b/src/compiler/scala/reflect/internal/SymbolTable.scala @@ -36,8 +36,9 @@ abstract class SymbolTable extends api.Universe with Importers with Required with TreeBuildUtil - with Reporters + with FrontEnds with CapturedVariables + with StdAttachments { def rootLoader: LazyType def log(msg: => AnyRef): Unit @@ -52,7 +53,7 @@ abstract class SymbolTable extends api.Universe /** Overridden when we know more about what was happening during a failure. */ def supplementErrorMessage(msg: String): String = msg - + private[scala] def printCaller[T](msg: String)(result: T) = { Console.err.println(msg + ": " + result) Console.err.println("Called from:") @@ -75,6 +76,19 @@ abstract class SymbolTable extends api.Universe result } + // For too long have we suffered in order to sort NAMES. + // I'm pretty sure there's a reasonable default for that. + // Notice challenge created by Ordering's invariance. + implicit def lowPriorityNameOrdering[T <: Names#Name]: Ordering[T] = + SimpleNameOrdering.asInstanceOf[Ordering[T]] + + private object SimpleNameOrdering extends Ordering[Names#Name] { + def compare(n1: Names#Name, n2: Names#Name) = ( + if (n1 eq n2) 0 + else n1.toString compareTo n2.toString + ) + } + /** Dump each symbol to stdout after shutdown. */ final val traceSymbolActivity = sys.props contains "scalac.debug.syms" diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala index c9947c3c09..c2ef633d58 100644 --- a/src/compiler/scala/reflect/internal/Symbols.scala +++ b/src/compiler/scala/reflect/internal/Symbols.scala @@ -47,13 +47,13 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** Create a new free term. Its owner is NoSymbol. */ - def newFreeTerm(name: TermName, info: Type, value: => Any, origin: String, newFlags: Long = 0L): FreeTerm = - new FreeTerm(name, value, origin) initFlags newFlags setInfo info + def newFreeTermSymbol(name: TermName, info: Type, value: => Any, flags: Long = 0L, origin: String): FreeTerm = + new FreeTerm(name, value, origin) initFlags flags setInfo info /** Create a new free type. Its owner is NoSymbol. */ - def newFreeType(name: TypeName, info: Type, value: => Any, origin: String, newFlags: Long = 0L): FreeType = - new FreeType(name, value, origin) initFlags newFlags setInfo info + def newFreeTypeSymbol(name: TypeName, info: Type, value: => Any, flags: Long = 0L, origin: String): FreeType = + new FreeType(name, value, origin) initFlags flags setInfo info /** The original owner of a class. Used by the backend to generate * EnclosingMethod attributes. @@ -232,7 +232,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => newTermSymbol(name, pos, PARAM | newFlags) /** Create local dummy for template (owner of local blocks) */ - final def newLocalDummy(pos: Position) = + final def newLocalDummy(pos: Position): TermSymbol = newTermSymbol(nme.localDummyName(this), pos) setInfo NoType final def newMethod(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): MethodSymbol = createMethodSymbol(name, pos, METHOD | newFlags) @@ -240,15 +240,15 @@ trait Symbols extends api.Symbols { self: SymbolTable => newMethod(name, pos, LABEL) /** Propagates ConstrFlags (JAVA, specifically) from owner to constructor. */ - final def newConstructor(pos: Position, newFlags: Long = 0L) = + final def newConstructor(pos: Position, newFlags: Long = 0L): MethodSymbol = newMethod(nme.CONSTRUCTOR, pos, getFlag(ConstrFlags) | newFlags) /** Static constructor with info set. */ - def newStaticConstructor(pos: Position) = + def newStaticConstructor(pos: Position): MethodSymbol = newConstructor(pos, STATIC) setInfo UnitClass.tpe /** Instance constructor with info set. */ - def newClassConstructor(pos: Position) = + def newClassConstructor(pos: Position): MethodSymbol = newConstructor(pos) setInfo MethodType(Nil, this.tpe) def newLinkedModule(clazz: Symbol, newFlags: Long = 0L): ModuleSymbol = { @@ -266,10 +266,10 @@ trait Symbols extends api.Symbols { self: SymbolTable => newModule(name, pos, PackageFlags | newFlags) } - final def newThisSym(name: TermName = nme.this_, pos: Position = NoPosition) = + final def newThisSym(name: TermName = nme.this_, pos: Position = NoPosition): TermSymbol = newTermSymbol(name, pos, SYNTHETIC) - final def newImport(pos: Position) = + final def newImport(pos: Position): TermSymbol = newTermSymbol(nme.IMPORT, pos) final def newModuleSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleSymbol = @@ -299,45 +299,45 @@ trait Symbols extends api.Symbols { self: SymbolTable => * * pre.memberType(m) */ - final def newOverloaded(pre: Type, alternatives: List[Symbol]): Symbol = ( + final def newOverloaded(pre: Type, alternatives: List[Symbol]): TermSymbol = ( newTermSymbol(alternatives.head.name.toTermName, alternatives.head.pos, OVERLOADED) setInfo OverloadedType(pre, alternatives) ) - final def newErrorValue(name: TermName) = + final def newErrorValue(name: TermName): TermSymbol = newTermSymbol(name, pos, SYNTHETIC | IS_ERROR) setInfo ErrorType /** Symbol of a type definition type T = ... */ - final def newAliasType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol = + final def newAliasType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): AliasTypeSymbol = createAliasTypeSymbol(name, pos, newFlags) /** Symbol of an abstract type type T >: ... <: ... */ - final def newAbstractType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol = + final def newAbstractType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): AbstractTypeSymbol = createAbstractTypeSymbol(name, pos, DEFERRED | newFlags) /** Symbol of a type parameter */ - final def newTypeParameter(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) = + final def newTypeParameter(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol = newAbstractType(name, pos, PARAM | newFlags) /** Symbol of an existential type T forSome { ... } */ - final def newExistential(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol = + final def newExistential(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol = newAbstractType(name, pos, EXISTENTIAL | newFlags) /** Synthetic value parameters when parameter symbols are not available */ - final def newSyntheticValueParamss(argtypess: List[List[Type]]): List[List[Symbol]] = { + final def newSyntheticValueParamss(argtypess: List[List[Type]]): List[List[TermSymbol]] = { var cnt = 0 def freshName() = { cnt += 1; nme.syntheticParamName(cnt) } mmap(argtypess)(tp => newValueParameter(freshName(), owner.pos.focus, SYNTHETIC) setInfo tp) } - def newSyntheticTypeParam(): Symbol = newSyntheticTypeParam("T0", 0L) - def newSyntheticTypeParam(name: String, newFlags: Long): Symbol = newTypeParameter(newTypeName(name), NoPosition, newFlags) setInfo TypeBounds.empty - def newSyntheticTypeParams(num: Int): List[Symbol] = (0 until num).toList map (n => newSyntheticTypeParam("T" + n, 0L)) + def newSyntheticTypeParam(): TypeSymbol = newSyntheticTypeParam("T0", 0L) + def newSyntheticTypeParam(name: String, newFlags: Long): TypeSymbol = newTypeParameter(newTypeName(name), NoPosition, newFlags) setInfo TypeBounds.empty + def newSyntheticTypeParams(num: Int): List[TypeSymbol] = (0 until num).toList map (n => newSyntheticTypeParam("T" + n, 0L)) /** Create a new existential type skolem with this symbol its owner, * based on the given symbol and origin. @@ -352,13 +352,13 @@ trait Symbols extends api.Symbols { self: SymbolTable => def newGADTSkolem(name: TypeName, origin: Symbol, info: Type): TypeSkolem = newTypeSkolemSymbol(name, origin, origin.pos, origin.flags & ~(EXISTENTIAL | PARAM) | CASEACCESSOR | SYNTHETIC) setInfo info - final def freshExistential(suffix: String): Symbol = + final def freshExistential(suffix: String): TypeSymbol = newExistential(freshExistentialName(suffix), pos) /** Synthetic value parameters when parameter symbols are not available. * Calling this method multiple times will re-use the same parameter names. */ - final def newSyntheticValueParams(argtypes: List[Type]): List[Symbol] = + final def newSyntheticValueParams(argtypes: List[Type]): List[TermSymbol] = newSyntheticValueParamss(List(argtypes)).head /** Synthetic value parameter when parameter symbol is not available. @@ -372,27 +372,27 @@ trait Symbols extends api.Symbols { self: SymbolTable => * with name `T` in its typeParams list. While type checking the parameters, result type and * body of the method, there's a local copy of `T` which is a TypeSkolem. */ - final def newTypeSkolem: Symbol = + final def newTypeSkolem: TypeSkolem = owner.newTypeSkolemSymbol(name.toTypeName, this, pos, flags) - final def newClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) = + final def newClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = newClassSymbol(name, pos, newFlags) /** A new class with its info set to a ClassInfoType with given scope and parents. */ - def newClassWithInfo(name: TypeName, parents: List[Type], scope: Scope, pos: Position = NoPosition, newFlags: Long = 0L) = { + def newClassWithInfo(name: TypeName, parents: List[Type], scope: Scope, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = { val clazz = newClass(name, pos, newFlags) clazz setInfo ClassInfoType(parents, scope, clazz) } - final def newErrorClass(name: TypeName) = + final def newErrorClass(name: TypeName): ClassSymbol = newClassWithInfo(name, Nil, new ErrorScope(this), pos, SYNTHETIC | IS_ERROR) - final def newModuleClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) = + final def newModuleClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleClassSymbol = newModuleClassSymbol(name, pos, newFlags | MODULE) - final def newAnonymousFunctionClass(pos: Position = NoPosition, newFlags: Long = 0L) = + final def newAnonymousFunctionClass(pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = newClassSymbol(tpnme.ANON_FUN_NAME, pos, FINAL | SYNTHETIC | newFlags) - final def newAnonymousFunctionValue(pos: Position, newFlags: Long = 0L) = + final def newAnonymousFunctionValue(pos: Position, newFlags: Long = 0L): TermSymbol = newTermSymbol(nme.ANON_FUN_NAME, pos, SYNTHETIC | newFlags) setInfo NoType def newImplClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = { @@ -402,11 +402,12 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** Refinement types P { val x: String; type T <: Number } * also have symbols, they are refinementClasses */ - final def newRefinementClass(pos: Position) = createRefinementClassSymbol(pos, 0L) + final def newRefinementClass(pos: Position): RefinementClassSymbol = + createRefinementClassSymbol(pos, 0L) /** Create a new getter for current symbol (which must be a field) */ - final def newGetter: Symbol = ( + final def newGetter: MethodSymbol = ( owner.newMethod(nme.getterName(name.toTermName), NoPosition, getterFlags(flags)) setPrivateWithin privateWithin setInfo MethodType(Nil, tpe) @@ -707,7 +708,10 @@ trait Symbols extends api.Symbols { self: SymbolTable => || isAnonOrRefinementClass // has uninteresting <anon> or <refinement> prefix || nme.isReplWrapperName(name) // has ugly $iw. prefix (doesn't call isInterpreterWrapper due to nesting) ) - def isFBounded = info.baseTypeSeq exists (_ contains this) + def isFBounded = info match { + case TypeBounds(_, _) => info.baseTypeSeq exists (_ contains this) + case _ => false + } /** Is symbol a monomorphic type? * assumption: if a type starts out as monomorphic, it will not acquire @@ -715,13 +719,8 @@ trait Symbols extends api.Symbols { self: SymbolTable => */ final def isMonomorphicType = isType && { - var is = infos - (is eq null) || { - while (is.prev ne null) { is = is.prev } - is.info.isComplete && !is.info.isHigherKinded // was: is.info.typeParams.isEmpty. - // YourKit listed the call to PolyType.typeParams as a hot spot but it is likely an artefact. - // The change to isHigherKinded did not reduce the total running time. - } + val info = originalInfo + info.isComplete && !info.isHigherKinded } def isStrictFP = hasAnnotation(ScalaStrictFPAttr) || (enclClass hasAnnotation ScalaStrictFPAttr) @@ -1123,6 +1122,14 @@ trait Symbols extends api.Symbols { self: SymbolTable => // ------ info and type ------------------------------------------------------------------- private[Symbols] var infos: TypeHistory = null + def originalInfo = { + if (infos eq null) null + else { + var is = infos + while (is.prev ne null) { is = is.prev } + is.info + } + } /** Get type. The type of a symbol is: * for a type symbol, the type corresponding to the symbol itself, @@ -1205,8 +1212,9 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** Set new info valid from start of this phase. */ def updateInfo(info: Type): Symbol = { - assert(phaseId(infos.validFrom) <= phase.id) - if (phaseId(infos.validFrom) == phase.id) infos = infos.prev + val pid = phaseId(infos.validFrom) + assert(pid <= phase.id, (pid, phase.id)) + if (pid == phase.id) infos = infos.prev infos = TypeHistory(currentPeriod, info, infos) _validTo = if (info.isComplete) currentPeriod else NoPeriod this @@ -1417,7 +1425,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** Reset symbol to initial state */ - def reset(completer: Type) { + def reset(completer: Type): this.type = { resetFlags() infos = null _validTo = NoPeriod @@ -1647,7 +1655,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => * symbol with the same owner, and the name of this symbol with $class * appended to it. */ - final def implClass: Symbol = owner.info.decl(nme.implClassName(name)) + final def implClass: Symbol = owner.info.decl(tpnme.implClassName(name)) /** The class that is logically an outer class of given `clazz`. * This is the enclosing class, except for classes defined locally to constructors, @@ -2045,7 +2053,8 @@ trait Symbols extends api.Symbols { self: SymbolTable => */ def sealedDescendants: Set[Symbol] = children.flatMap(_.sealedDescendants) + this - @inline final def orElse[T](alt: => Symbol): Symbol = if (this ne NoSymbol) this else alt + @inline final def orElse(alt: => Symbol): Symbol = if (this ne NoSymbol) this else alt + @inline final def andAlso(f: Symbol => Unit): Symbol = if (this eq NoSymbol) NoSymbol else { f(this) ; this } // ------ toString ------------------------------------------------------------------- @@ -2235,13 +2244,13 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** String representation of existentially bound variable */ def existentialToString = if (isSingletonExistential && !settings.debug.value) - "val " + nme.dropSingletonName(name) + ": " + dropSingletonType(info.bounds.hi) + "val " + tpnme.dropSingletonName(name) + ": " + dropSingletonType(info.bounds.hi) else defString } /** A class for term symbols */ class TermSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TermName) - extends Symbol(initOwner, initPos, initName) { + extends Symbol(initOwner, initPos, initName) with TermSymbolApi { private[this] var _referenced: Symbol = NoSymbol privateWithin = NoSymbol @@ -2410,7 +2419,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** A class for module symbols */ class ModuleSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TermName) - extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag { + extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag with ModuleSymbolApi { def distinguishingFlag = MODULE private var flatname: TermName = null @@ -2435,14 +2444,14 @@ trait Symbols extends api.Symbols { self: SymbolTable => } class PackageSymbol protected[Symbols] (owner0: Symbol, pos0: Position, name0: TermName) - extends ModuleSymbol(owner0, pos0, name0) with DistinguishingFlag { + extends ModuleSymbol(owner0, pos0, name0) with DistinguishingFlag with PackageSymbolApi { override def distinguishingFlag = super.distinguishingFlag | PACKAGE override def isPackage = true } /** A class for method symbols */ class MethodSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TermName) - extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag { + extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag with MethodSymbolApi { def distinguishingFlag = METHOD // MethodSymbols pick up MODULE when trait-owned object accessors are cloned // during mixin composition. @@ -2504,7 +2513,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => * of this class. Classes are instances of a subclass. */ abstract class TypeSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TypeName) - extends Symbol(initOwner, initPos, initName) { + extends Symbol(initOwner, initPos, initName) with TypeSymbolApi { privateWithin = NoSymbol private[this] var _rawname: TypeName = initName @@ -2628,10 +2637,11 @@ trait Symbols extends api.Symbols { self: SymbolTable => info.baseTypeIndex(that) >= 0 ) - override def reset(completer: Type) { + override def reset(completer: Type): this.type = { super.reset(completer) tpePeriod = NoPeriod tyconRunId = NoRunId + this } /*** example: @@ -2705,7 +2715,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** A class for class symbols */ class ClassSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TypeName) - extends TypeSymbol(initOwner, initPos, initName) { + extends TypeSymbol(initOwner, initPos, initName) with ClassSymbolApi { type TypeOfClonedSymbol = ClassSymbol private[this] var flatname: TypeName = _ @@ -2752,7 +2762,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => override def toInterface: Symbol = ( if (isImplClass) { if (phase.next.erasedTypes) lastParent - else owner.info.decl(nme.interfaceName(name)) + else owner.info.decl(tpnme.interfaceName(name)) } else super.toInterface ) @@ -2814,9 +2824,10 @@ trait Symbols extends api.Symbols { self: SymbolTable => else super.sourceFile override def sourceFile_=(f: AbstractFileType) { source = f } - override def reset(completer: Type) { + override def reset(completer: Type): this.type = { super.reset(completer) thissym = this + this } /** the type this.type in this class */ @@ -2963,12 +2974,15 @@ trait Symbols extends api.Symbols { self: SymbolTable => ) } - class FreeTerm(name0: TermName, value0: => Any, val origin: String) extends TermSymbol(NoSymbol, NoPosition, name0) { + trait FreeSymbol extends Symbol { + def origin: String + } + class FreeTerm(name0: TermName, value0: => Any, val origin: String) extends TermSymbol(NoSymbol, NoPosition, name0) with FreeSymbol { def value = value0 override def isFreeTerm = true } - class FreeType(name0: TypeName, value0: => Any, val origin: String) extends TypeSkolem(NoSymbol, NoPosition, name0, NoSymbol) { + class FreeType(name0: TypeName, value0: => Any, val origin: String) extends TypeSkolem(NoSymbol, NoPosition, name0, NoSymbol) with FreeSymbol { def value = value0 override def isFreeType = true } @@ -3011,7 +3025,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => override def ownerChain: List[Symbol] = List() override def ownersIterator: Iterator[Symbol] = Iterator.empty override def alternatives: List[Symbol] = List() - override def reset(completer: Type) {} + override def reset(completer: Type): this.type = this override def info: Type = NoType override def existentialBound: Type = NoType override def rawInfo: Type = NoType diff --git a/src/compiler/scala/reflect/internal/TreeBuildUtil.scala b/src/compiler/scala/reflect/internal/TreeBuildUtil.scala index fbcd5043bc..d4d4652e91 100644 --- a/src/compiler/scala/reflect/internal/TreeBuildUtil.scala +++ b/src/compiler/scala/reflect/internal/TreeBuildUtil.scala @@ -1,6 +1,8 @@ package scala.reflect package internal +import Flags._ + trait TreeBuildUtil extends api.TreeBuildUtil { self: SymbolTable => // ``staticClass'' and ``staticModule'' rely on ClassLoaders @@ -51,9 +53,11 @@ trait TreeBuildUtil extends api.TreeBuildUtil { self: SymbolTable => try selectOverloadedMethod(owner, name, index) catch { case _: MissingRequirementError => NoSymbol } - def newFreeTerm(name: String, info: Type, value: => Any, origin: String) = newFreeTerm(newTermName(name), info, value, origin) + def newFreeTerm(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null) = newFreeTermSymbol(newTermName(name), info, value, flags, origin) + + def newFreeType(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null) = newFreeTypeSymbol(newTypeName(name), info, value, (if (flags == 0L) PARAM else flags) | DEFERRED, origin) - def newFreeType(name: String, info: Type, value: => Any, origin: String) = newFreeType(newTypeName(name), info, value, origin) + def newFreeExistential(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null) = newFreeTypeSymbol(newTypeName(name), info, value, (if (flags == 0L) EXISTENTIAL else flags) | DEFERRED, origin) def modifiersFromInternalFlags(flags: Long, privateWithin: Name, annotations: List[Tree]): Modifiers = Modifiers(flags, privateWithin, annotations) diff --git a/src/compiler/scala/reflect/internal/TreeGen.scala b/src/compiler/scala/reflect/internal/TreeGen.scala index 1a374b6e59..f2f9842595 100644 --- a/src/compiler/scala/reflect/internal/TreeGen.scala +++ b/src/compiler/scala/reflect/internal/TreeGen.scala @@ -7,13 +7,14 @@ abstract class TreeGen extends api.AbsTreeGen { import global._ import definitions._ - def rootId(name: Name) = Select(Ident(nme.ROOTPKG), name) - def rootScalaDot(name: Name) = Select(rootId(nme.scala_) setSymbol ScalaPackage, name) - def scalaDot(name: Name) = Select(Ident(nme.scala_) setSymbol ScalaPackage, name) - def scalaAnyRefConstr = scalaDot(tpnme.AnyRef) setSymbol AnyRefClass - def scalaUnitConstr = scalaDot(tpnme.Unit) setSymbol UnitClass - def productConstr = scalaDot(tpnme.Product) setSymbol ProductRootClass - def serializableConstr = scalaDot(tpnme.Serializable) setSymbol SerializableClass + def rootId(name: Name) = Select(Ident(nme.ROOTPKG), name) + def rootScalaDot(name: Name) = Select(rootId(nme.scala_) setSymbol ScalaPackage, name) + def scalaDot(name: Name) = Select(Ident(nme.scala_) setSymbol ScalaPackage, name) + def scalaAnnotationDot(name: Name) = Select(scalaDot(nme.annotation), name) + def scalaAnyRefConstr = scalaDot(tpnme.AnyRef) setSymbol AnyRefClass + def scalaUnitConstr = scalaDot(tpnme.Unit) setSymbol UnitClass + def productConstr = scalaDot(tpnme.Product) setSymbol ProductRootClass + def serializableConstr = scalaDot(tpnme.Serializable) setSymbol SerializableClass def scalaFunctionConstr(argtpes: List[Tree], restpe: Tree, abstractFun: Boolean = false): Tree = { val cls = if (abstractFun) @@ -48,6 +49,9 @@ abstract class TreeGen extends api.AbsTreeGen { def mkMethodCall(target: Tree, targs: List[Type], args: List[Tree]): Tree = Apply(mkTypeApply(target, targs map TypeTree), args) + def mkNullaryCall(method: Symbol, targs: List[Type]): Tree = + mkTypeApply(mkAttributedRef(method), targs map TypeTree) + /** Builds a reference to value whose type is given stable prefix. * The type must be suitable for this. For example, it * must not be a TypeRef pointing to an abstract type variable. diff --git a/src/compiler/scala/reflect/internal/TreeInfo.scala b/src/compiler/scala/reflect/internal/TreeInfo.scala index 039c8e557a..f4878139e9 100644 --- a/src/compiler/scala/reflect/internal/TreeInfo.scala +++ b/src/compiler/scala/reflect/internal/TreeInfo.scala @@ -602,7 +602,7 @@ abstract class TreeInfo { object ReifiedTree { def unapply(tree: Tree): Option[(Tree, List[Tree], Tree, Tree)] = tree match { - case reifee @ Block((mrDef @ ValDef(_, _, _, _)) :: symbolTable, Apply(Apply(_, List(tree)), List(Apply(_, List(tpe))))) if mrDef.name == nme.MIRROR_SHORT => + case reifee @ Block((mrDef @ ValDef(_, _, _, _)) :: symbolTable, Apply(Apply(_, List(tree)), List(Apply(_, tpe :: _)))) if mrDef.name == nme.MIRROR_SHORT => Some(reifee, symbolTable, tree, tpe) case _ => None @@ -629,7 +629,7 @@ abstract class TreeInfo { object ReifiedType { def unapply(tree: Tree): Option[(Tree, List[Tree], Tree)] = tree match { - case reifee @ Block((mrDef @ ValDef(_, _, _, _)) :: symbolTable, Apply(_, List(tpe))) if mrDef.name == nme.MIRROR_SHORT => + case reifee @ Block((mrDef @ ValDef(_, _, _, _)) :: symbolTable, Apply(_, tpe :: _)) if mrDef.name == nme.MIRROR_SHORT => Some(reifee, symbolTable, tpe) case _ => None @@ -646,11 +646,11 @@ abstract class TreeInfo { } object FreeDef { - def unapply(tree: Tree): Option[(Tree, TermName, Tree, String)] = tree match { - case FreeTermDef(mrRef, name, binding, origin) => - Some(mrRef, name, binding, origin) - case FreeTypeDef(mrRef, name, binding, origin) => - Some(mrRef, name, binding, origin) + def unapply(tree: Tree): Option[(Tree, TermName, Tree, Long, String)] = tree match { + case FreeTermDef(mrRef, name, binding, flags, origin) => + Some(mrRef, name, binding, flags, origin) + case FreeTypeDef(mrRef, name, binding, flags, origin) => + Some(mrRef, name, binding, flags, origin) case _ => None } @@ -659,30 +659,31 @@ abstract class TreeInfo { object FreeTermDef { lazy val newFreeTermMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeTerm) - def unapply(tree: Tree): Option[(Tree, TermName, Tree, String)] = tree match { - case ValDef(_, name, _, Apply(Select(mrRef @ Ident(_), newFreeTerm), List(_, _, binding, Literal(Constant(origin: String))))) + def unapply(tree: Tree): Option[(Tree, TermName, Tree, Long, String)] = tree match { + case ValDef(_, name, _, Apply(Select(mrRef @ Ident(_), newFreeTerm), List(_, _, binding, Literal(Constant(flags: Long)), Literal(Constant(origin: String))))) if mrRef.name == nme.MIRROR_SHORT && newFreeTerm == newFreeTermMethod.name => - Some(mrRef, name, binding, origin) + Some(mrRef, name, binding, flags, origin) case _ => None } } object FreeTypeDef { - lazy val newFreeTypeMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeType) + lazy val newFreeExistentialMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeType) + lazy val newFreeTypeMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeExistential) - def unapply(tree: Tree): Option[(Tree, TermName, Tree, String)] = tree match { - case ValDef(_, name, _, Apply(Select(mrRef1 @ Ident(_), newFreeType), List(_, _, value, Literal(Constant(origin: String))))) - if mrRef1.name == nme.MIRROR_SHORT && newFreeType == newFreeTypeMethod.name => + def unapply(tree: Tree): Option[(Tree, TermName, Tree, Long, String)] = tree match { + case ValDef(_, name, _, Apply(Select(mrRef1 @ Ident(_), newFreeType), List(_, _, value, Literal(Constant(flags: Long)), Literal(Constant(origin: String))))) + if mrRef1.name == nme.MIRROR_SHORT && (newFreeType == newFreeTypeMethod.name || newFreeType == newFreeExistentialMethod.name) => value match { - case Apply(TypeApply(Select(Select(mrRef2 @ Ident(_), typeTag), apply), List(binding)), List(Literal(Constant(null)))) + case Apply(TypeApply(Select(Select(mrRef2 @ Ident(_), typeTag), apply), List(binding)), List(Literal(Constant(null)), _)) if mrRef2.name == nme.MIRROR_SHORT && typeTag == nme.TypeTag && apply == nme.apply => - Some(mrRef1, name, binding, origin) - case Apply(TypeApply(Select(mrRef2 @ Ident(_), typeTag), List(binding)), List(Literal(Constant(null)))) + Some(mrRef1, name, binding, flags, origin) + case Apply(TypeApply(Select(mrRef2 @ Ident(_), typeTag), List(binding)), List(Literal(Constant(null)), _)) if mrRef2.name == nme.MIRROR_SHORT && typeTag == nme.TypeTag => - Some(mrRef1, name, binding, origin) + Some(mrRef1, name, binding, flags, origin) case _ => - throw new Error("unsupported free type def: " + showRaw(tree)) + throw new Error("unsupported free type def: %s%n%s".format(value, showRaw(value))) } case _ => None diff --git a/src/compiler/scala/reflect/internal/TreePrinters.scala b/src/compiler/scala/reflect/internal/TreePrinters.scala index 486a3d3567..3093bb049a 100644 --- a/src/compiler/scala/reflect/internal/TreePrinters.scala +++ b/src/compiler/scala/reflect/internal/TreePrinters.scala @@ -373,6 +373,9 @@ trait TreePrinters extends api.TreePrinters { self: SymbolTable => case Select(qualifier, name) => print(backquotedPath(qualifier), ".", symName(tree, name)) + case bqid: BackQuotedIdent => + print("`%s`" format symName(tree, bqid.name)) + case Ident(name) => print(symName(tree, name)) diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala index afb1d8061e..c049df47af 100644 --- a/src/compiler/scala/reflect/internal/Types.scala +++ b/src/compiler/scala/reflect/internal/Types.scala @@ -264,7 +264,23 @@ trait Types extends api.Types { self: SymbolTable => def nonPrivateDeclaration(name: Name): Symbol = nonPrivateDecl(name) def declarations = decls def typeArguments = typeArgs - def erasure = transformedType(this) + def erasure = this match { + case ConstantType(value) => widen.erasure // [Eugene to Martin] constant types are unaffected by erasure. weird. + case _ => + var result = transformedType(this) + result = result.normalize match { // necessary to deal with erasures of HK types, typeConstructor won't work + case PolyType(undets, underlying) => existentialAbstraction(undets, underlying) // we don't want undets in the result + case _ => result + } + // [Eugene] erasure screws up all ThisTypes for modules into PackageTypeRefs + // we need to unscrew them, or certain typechecks will fail mysteriously + // http://groups.google.com/group/scala-internals/browse_thread/thread/6d3277ae21b6d581 + result = result.map(tpe => tpe match { + case tpe: PackageTypeRef => ThisType(tpe.sym) + case _ => tpe + }) + result + } def substituteTypes(from: List[Symbol], to: List[Type]): Type = subst(from, to) // [Eugene] to be discussed and refactored @@ -277,7 +293,7 @@ trait Types extends api.Types { self: SymbolTable => case SuperType(_, _) => false case SingleType(pre, sym) => notConcreteSym(sym) case ConstantType(_) => false - case TypeRef(_, sym, _) => notConcreteSym(sym) + case TypeRef(_, sym, args) => notConcreteSym(sym) || (args exists (arg => notConcreteTpe(arg))) case RefinedType(_, _) => false case ExistentialType(_, _) => false case AnnotatedType(_, tp, _) => notConcreteTpe(tp) @@ -1342,7 +1358,8 @@ trait Types extends api.Types { self: SymbolTable => if (period != currentPeriod) { tpe.underlyingPeriod = currentPeriod if (!isValid(period)) { - tpe.underlyingCache = tpe.pre.memberType(tpe.sym).resultType; + // [Eugene to Paul] needs review + tpe.underlyingCache = if (tpe.sym == NoSymbol) ThisType(RootClass) else tpe.pre.memberType(tpe.sym).resultType; assert(tpe.underlyingCache ne tpe, tpe) } } @@ -1492,7 +1509,8 @@ trait Types extends api.Types { self: SymbolTable => case tv: TypeVar => tvs += tv case _ => } - val varToParamMap: Map[Type, Symbol] = tvs map (tv => tv -> tv.origin.typeSymbol.cloneSymbol) toMap + val varToParamMap: Map[Type, Symbol] = + mapFrom[TypeVar, Type, Symbol](tvs.toList)(_.origin.typeSymbol.cloneSymbol) val paramToVarMap = varToParamMap map (_.swap) val varToParam = new TypeMap { def apply(tp: Type) = varToParamMap get tp match { @@ -2082,7 +2100,7 @@ trait Types extends api.Types { self: SymbolTable => // TODO: is there another way a typeref's symbol can refer to a symbol defined in its pre? case _ => sym } - + override def kind = "AliasTypeRef" } trait AbstractTypeRef extends NonClassTypeRef { @@ -2135,6 +2153,7 @@ trait Types extends api.Types { self: SymbolTable => override def bounds = thisInfo.bounds // def transformInfo(tp: Type): Type = appliedType(tp.asSeenFrom(pre, sym.owner), typeArgsOrDummies) override protected[Types] def baseTypeSeqImpl: BaseTypeSeq = transform(bounds.hi).baseTypeSeq prepend this + override def kind = "AbstractTypeRef" } /** A class for named types of the form @@ -2309,7 +2328,7 @@ trait Types extends api.Types { self: SymbolTable => else if (sym.isPackageClass || sym.isPackageObjectOrClass) sym.skipPackageObject.fullName + "." else if (isStable && nme.isSingletonName(sym.name)) - nme.dropSingletonName(sym.name) + "." + tpnme.dropSingletonName(sym.name) + "." else super.prefixString ) @@ -2579,7 +2598,7 @@ trait Types extends api.Types { self: SymbolTable => !(qset contains sym) && !isQuantified(pre) case _ => false - } + } } override def safeToString: String = { @@ -3455,7 +3474,7 @@ trait Types extends api.Types { self: SymbolTable => case TypeRef(pre, sym, _) if sameLength(sym.typeParams, args) => val eparams = typeParamsToExistentials(sym) val bounds = args map (TypeBounds upper _) - (eparams, bounds).zipped foreach (_ setInfo _) + foreach2(eparams, bounds)(_ setInfo _) newExistentialType(eparams, typeRef(pre, sym, eparams map (_.tpe))) case _ => @@ -3637,7 +3656,7 @@ trait Types extends api.Types { self: SymbolTable => else owner.newValueParameter(name.toTermName) paramStack = newParams :: paramStack try { - (newParams, ptypes).zipped foreach ((p, t) => p setInfo this(t)) + foreach2(newParams, ptypes)((p, t) => p setInfo this(t)) val restpe1 = this(restpe) if (isType) PolyType(newParams, restpe1) else MethodType(newParams, restpe1) @@ -4813,9 +4832,14 @@ trait Types extends api.Types { self: SymbolTable => if (sym.isPackage) tp else { val pre1 = this(pre) - val sym1 = adaptToNewRun(pre1, sym) - if ((pre1 eq pre) && (sym1 eq sym)) tp - else singleType(pre1, sym1) + try { + val sym1 = adaptToNewRun(pre1, sym) + if ((pre1 eq pre) && (sym1 eq sym)) tp + else singleType(pre1, sym1) + } catch { + case _: MissingTypeControl => + tp + } } case TypeRef(pre, sym, args) => if (sym.isPackageClass) tp diff --git a/src/compiler/scala/reflect/internal/pickling/UnPickler.scala b/src/compiler/scala/reflect/internal/pickling/UnPickler.scala index f89aa9bf5c..fd3fac1b37 100644 --- a/src/compiler/scala/reflect/internal/pickling/UnPickler.scala +++ b/src/compiler/scala/reflect/internal/pickling/UnPickler.scala @@ -447,7 +447,7 @@ abstract class UnPickler /*extends reflect.generic.UnPickler*/ { private def readArrayAnnot() = { readByte() // skip the `annotargarray` tag val end = readNat() + readIndex - until(end, () => readClassfileAnnotArg(readNat())).toArray(classfileAnnotArgManifest) + until(end, () => readClassfileAnnotArg(readNat())).toArray(classfileAnnotArgTag) } protected def readClassfileAnnotArg(i: Int): ClassfileAnnotArg = bytes(index(i)) match { case ANNOTINFO => NestedAnnotArg(at(i, readAnnotation)) @@ -816,16 +816,10 @@ abstract class UnPickler /*extends reflect.generic.UnPickler*/ { throw new RuntimeException("malformed Scala signature of " + classRoot.name + " at " + readIndex + "; " + msg) protected def errorMissingRequirement(name: Name, owner: Symbol): Symbol = - missingHook(owner, name) orElse { - val what = if (name.isTypeName) "type" else "value" - MissingRequirementError.notFound( - "while unpickling %s, reference %s %s of %s/%s/%s".format( - filename, - what, name.decode, owner.tpe.widen, - owner.tpe.typeSymbol.ownerChain, - owner.info.members.mkString("\n ", "\n ", "")) - ) - } + missingHook(owner, name) orElse MissingRequirementError.notFound( + "bad reference while unpickling %s: %s not found in %s".format( + filename, name.longString, owner.tpe.widen) + ) def inferMethodAlternative(fun: Tree, argtpes: List[Type], restpe: Type) {} // can't do it; need a compiler for that. @@ -849,7 +843,7 @@ abstract class UnPickler /*extends reflect.generic.UnPickler*/ { atPhase(p) (sym setInfo tp) if (currentRunId != definedAtRunId) sym.setInfo(adaptToNewRunMap(tp)) - } + } catch { case e: MissingRequirementError => throw toTypeError(e) } diff --git a/src/compiler/scala/reflect/internal/util/Collections.scala b/src/compiler/scala/reflect/internal/util/Collections.scala index 9dbf1adeef..2e119f8ccc 100644 --- a/src/compiler/scala/reflect/internal/util/Collections.scala +++ b/src/compiler/scala/reflect/internal/util/Collections.scala @@ -24,18 +24,21 @@ trait Collections { ) /** All these mm methods are "deep map" style methods for - * mapping etc. on a list of lists. + * mapping etc. on a list of lists while avoiding unnecessary + * intermediate structures like those created via flatten. */ final def mexists[A](xss: List[List[A]])(p: A => Boolean) = xss exists (_ exists p) + final def mforall[A](xss: List[List[A]])(p: A => Boolean) = + xss forall (_ forall p) final def mmap[A, B](xss: List[List[A]])(f: A => B) = xss map (_ map f) final def mforeach[A](xss: List[List[A]])(f: A => Unit) = xss foreach (_ foreach f) final def mfind[A](xss: List[List[A]])(p: A => Boolean): Option[A] = { - for (xs <- xss; x <- xs) - if (p(x)) return Some(x) - None + var res: Option[A] = null + mforeach(xss)(x => if ((res eq null) && p(x)) res = Some(x)) + if (res eq null) None else res } final def mfilter[A](xss: List[List[A]])(p: A => Boolean) = for (xs <- xss; x <- xs; if p(x)) yield x @@ -66,6 +69,31 @@ trait Collections { } lb.toList } + + final def flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Traversable[B]]): List[B] = { + val lb = new ListBuffer[B] + for (x <- elems ; if pf isDefinedAt x) + lb ++= pf(x) + + lb.toList + } + + final def distinctBy[A, B](xs: List[A])(f: A => B): List[A] = { + val buf = new ListBuffer[A] + val seen = mutable.Set[B]() + xs foreach { x => + val y = f(x) + if (!seen(y)) { + buf += x + seen += y + } + } + buf.toList + } + + @tailrec final def flattensToEmpty(xss: Seq[Seq[_]]): Boolean = { + xss.isEmpty || xss.head.isEmpty && flattensToEmpty(xss.tail) + } final def foreachWithIndex[A, B](xs: List[A])(f: (A, Int) => Unit) { var index = 0 @@ -82,6 +110,10 @@ trait Collections { xs find p getOrElse orElse } + final def mapFrom[A, A1 >: A, B](xs: List[A])(f: A => B): Map[A1, B] = { + Map[A1, B](xs map (x => (x, f(x))): _*) + } + final def mapWithIndex[A, B](xs: List[A])(f: (A, Int) => B): List[B] = { val lb = new ListBuffer[B] var index = 0 diff --git a/src/compiler/scala/reflect/internal/util/Origins.scala b/src/compiler/scala/reflect/internal/util/Origins.scala index b9985c8f50..19b3adda9d 100644 --- a/src/compiler/scala/reflect/internal/util/Origins.scala +++ b/src/compiler/scala/reflect/internal/util/Origins.scala @@ -88,7 +88,7 @@ object Origins { sys.addShutdownHook(counters foreach (_.purge())) } - def apply[T: Manifest](tag: String): Origins = apply(tag, manifest[T].erasure) + def apply[T: ClassTag](tag: String): Origins = apply(tag, classTag[T].erasure) def apply(tag: String, clazz: Class[_]): Origins = apply(tag, new OneLine(clazz)) def apply(tag: String, orElse: => Origins): Origins = { counters find (_.tag == tag) getOrElse { diff --git a/src/compiler/scala/reflect/makro/runtime/Context.scala b/src/compiler/scala/reflect/makro/runtime/Context.scala index 184008658e..ca02822788 100644 --- a/src/compiler/scala/reflect/makro/runtime/Context.scala +++ b/src/compiler/scala/reflect/makro/runtime/Context.scala @@ -10,11 +10,12 @@ abstract class Context extends scala.reflect.makro.Context with Enclosures with Names with Reifiers - with Reporters + with FrontEnds with Settings with Symbols with Typers - with Util { + with Util + with Traces { val mirror: Global diff --git a/src/compiler/scala/reflect/makro/runtime/Enclosures.scala b/src/compiler/scala/reflect/makro/runtime/Enclosures.scala index f9a6987e48..ab38fc024d 100644 --- a/src/compiler/scala/reflect/makro/runtime/Enclosures.scala +++ b/src/compiler/scala/reflect/makro/runtime/Enclosures.scala @@ -6,31 +6,18 @@ trait Enclosures { import mirror._ + private def site = callsiteTyper.context + private def enclTrees = site.enclosingContextChain map (_.tree) + private def enclPoses = enclosingMacros map (_.macroApplication.pos) filterNot (_ eq NoPosition) + // vals are eager to simplify debugging // after all we wouldn't save that much time by making them lazy - - val macroApplication: Tree = expandee - - val enclosingMacros: List[Context] = this :: mirror.analyzer.openMacros - - val enclosingImplicits: List[(Type, Tree)] = callsiteTyper.context.openImplicits - - val enclosingPosition: Position = enclosingMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication.pos).getOrElse(NoPosition) - - val enclosingApplication: Tree = { - def loop(context: analyzer.Context): Tree = context match { - case analyzer.NoContext => EmptyTree - case context if context.tree.isInstanceOf[Apply] => context.tree - case context => loop(context.outer) - } - - val context = callsiteTyper.context - loop(context) - } - - val enclosingMethod: Tree = callsiteTyper.context.enclMethod.tree - - val enclosingClass: Tree = callsiteTyper.context.enclClass.tree - - val enclosingUnit: CompilationUnit = currentRun.currentUnit -}
\ No newline at end of file + val macroApplication: Tree = expandee + val enclosingApplication: Tree = enclTrees collectFirst { case t: Apply => t } getOrElse EmptyTree + val enclosingClass: Tree = site.enclClass.tree + val enclosingImplicits: List[(Type, Tree)] = site.openImplicits + val enclosingMacros: List[Context] = this :: mirror.analyzer.openMacros // include self + val enclosingMethod: Tree = site.enclMethod.tree + val enclosingPosition: Position = if (enclPoses.isEmpty) NoPosition else enclPoses.head.pos + val enclosingUnit: CompilationUnit = currentRun.currentUnit +} diff --git a/src/compiler/scala/reflect/makro/runtime/Reporters.scala b/src/compiler/scala/reflect/makro/runtime/FrontEnds.scala index 0fd037bdd2..7cfa8e80f3 100644 --- a/src/compiler/scala/reflect/makro/runtime/Reporters.scala +++ b/src/compiler/scala/reflect/makro/runtime/FrontEnds.scala @@ -1,21 +1,21 @@ package scala.reflect.makro package runtime -trait Reporters { +trait FrontEnds { self: Context => import mirror._ - def reporter: mirror.Reporter = wrapNscReporter(mirror.reporter) + def frontEnd: FrontEnd = wrapReporter(mirror.reporter) - def setReporter(reporter: mirror.Reporter): this.type = { - mirror.reporter = wrapApiReporter(reporter) + def setFrontEnd(frontEnd: FrontEnd): this.type = { + mirror.reporter = wrapFrontEnd(frontEnd) this } - def withReporter[T](reporter: Reporter)(op: => T): T = { + def withFrontEnd[T](frontEnd: FrontEnd)(op: => T): T = { val old = mirror.reporter - setReporter(reporter) + setFrontEnd(frontEnd) try op finally mirror.reporter = old } diff --git a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala index 2488b06d6c..1c5af4b752 100644 --- a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala +++ b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala @@ -10,60 +10,25 @@ trait Reifiers { self: Context => import mirror._ + import definitions._ - lazy val reflectMirrorPrefix: Tree = { - // [Eugene] how do I typecheck this without undergoing this tiresome (and, in general, incorrect) procedure? - val prefix: Tree = Select(Select(Ident(definitions.ScalaPackage), newTermName("reflect")), newTermName("mirror")) - val prefixTpe = typeCheck(TypeApply(Select(prefix, newTermName("asInstanceOf")), List(SingletonTypeTree(prefix)))).tpe - typeCheck(prefix) setType prefixTpe - } - - def reifyTree(prefix: Tree, tree: Tree): Tree = - reifyTopLevel(prefix, tree) - - def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Tree = - reifyTopLevel(prefix, tpe, dontSpliceAtTopLevel, requireConcreteTypeTag) - - def unreifyTree(tree: Tree): Tree = - Select(tree, definitions.ExprEval) + lazy val reflectMirrorPrefix: Tree = ReflectMirrorPrefix - def reifyTopLevel(prefix: Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Tree = { - // [Eugene] the plumbing is not very pretty, but anyways factoring out the reifier seems like a necessary step to me - import scala.reflect.reify._ - val reifier = mkReifier(mirror)(callsiteTyper, prefix, reifee, dontSpliceAtTopLevel, requireConcreteTypeTag) - - try { - val result = reifier.reified - logFreeVars(expandee.pos, result) - result - } catch { - case ex: reifier.ReificationError => -// // this is a "soft" exception - it will normally be caught by the macro -// // consequently, we need to log the stack trace here, so that it doesn't get lost -// if (settings.Yreifydebug.value) { -// val message = new java.io.StringWriter() -// ex.printStackTrace(new java.io.PrintWriter(message)) -// println(scala.compat.Platform.EOL + message) -// } - val xlated = new ReificationError(ex.pos, ex.msg) - xlated.setStackTrace(ex.getStackTrace) - throw xlated - case ex: reifier.UnexpectedReificationError => - val xlated = new UnexpectedReificationError(ex.pos, ex.msg, ex.cause) - xlated.setStackTrace(ex.getStackTrace) - throw xlated - } + def reifyTree(prefix: Tree, tree: Tree): Tree = { + val result = scala.reflect.reify.`package`.reifyTree(mirror)(callsiteTyper, prefix, tree) + logFreeVars(enclosingPosition, result) + result } - class ReificationError(var pos: Position, val msg: String) extends Throwable(msg) - - object ReificationError extends ReificationErrorExtractor { - def unapply(error: ReificationError): Option[(Position, String)] = Some((error.pos, error.msg)) + def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, concrete: Boolean = false): Tree = { + val result = scala.reflect.reify.`package`.reifyType(mirror)(callsiteTyper, prefix, tpe, dontSpliceAtTopLevel, concrete) + logFreeVars(enclosingPosition, result) + result } - class UnexpectedReificationError(val pos: Position, val msg: String, val cause: Throwable = null) extends Throwable(msg, cause) + def reifyErasure(tpe: Type, concrete: Boolean = true): Tree = + scala.reflect.reify.`package`.reifyErasure(mirror)(callsiteTyper, tpe, concrete) - object UnexpectedReificationError extends UnexpectedReificationErrorExtractor { - def unapply(error: UnexpectedReificationError): Option[(Position, String, Throwable)] = Some((error.pos, error.msg, error.cause)) - } + def unreifyTree(tree: Tree): Tree = + Select(tree, definitions.ExprEval) } diff --git a/src/compiler/scala/reflect/makro/runtime/Symbols.scala b/src/compiler/scala/reflect/makro/runtime/Symbols.scala index 552ad2a303..6341523486 100644 --- a/src/compiler/scala/reflect/makro/runtime/Symbols.scala +++ b/src/compiler/scala/reflect/makro/runtime/Symbols.scala @@ -5,4 +5,6 @@ trait Symbols { self: Context => def isLocatable(sym: Symbol) = sym.isLocatable + + def isStatic(sym: Symbol) = sym.isStatic }
\ No newline at end of file diff --git a/src/compiler/scala/reflect/makro/runtime/Traces.scala b/src/compiler/scala/reflect/makro/runtime/Traces.scala new file mode 100644 index 0000000000..6b61842316 --- /dev/null +++ b/src/compiler/scala/reflect/makro/runtime/Traces.scala @@ -0,0 +1,8 @@ +package scala.reflect.makro +package runtime + +trait Traces extends util.Traces { + self: Context => + + def globalSettings = mirror.settings +} diff --git a/src/compiler/scala/reflect/makro/runtime/Typers.scala b/src/compiler/scala/reflect/makro/runtime/Typers.scala index 38e819746d..c61e492250 100644 --- a/src/compiler/scala/reflect/makro/runtime/Typers.scala +++ b/src/compiler/scala/reflect/makro/runtime/Typers.scala @@ -4,13 +4,12 @@ package runtime trait Typers { self: Context => - val openMacros: List[Context] = this :: mirror.analyzer.openMacros + def openMacros: List[Context] = this :: mirror.analyzer.openMacros - val openImplicits: List[(Type, Tree)] = callsiteTyper.context.openImplicits + def openImplicits: List[(Type, Tree)] = callsiteTyper.context.openImplicits def typeCheck(tree: Tree, pt: Type = mirror.WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree = { - def trace(msg: Any) = if (mirror.settings.Ymacrodebug.value) println(msg) - trace("typechecking %s with expected type %s, implicit views = %s, macros = %s".format(tree, pt, !withImplicitViewsDisabled, !withMacrosDisabled)) + macroLogVerbose("typechecking %s with expected type %s, implicit views = %s, macros = %s".format(tree, pt, !withImplicitViewsDisabled, !withMacrosDisabled)) val wrapper1 = if (!withImplicitViewsDisabled) (callsiteTyper.context.withImplicitsEnabled[Tree] _) else (callsiteTyper.context.withImplicitsDisabled[Tree] _) val wrapper2 = if (!withMacrosDisabled) (callsiteTyper.context.withMacrosEnabled[Tree] _) else (callsiteTyper.context.withMacrosDisabled[Tree] _) def wrapper (tree: => Tree) = wrapper1(wrapper2(tree)) @@ -21,25 +20,24 @@ trait Typers { // (also see reflect.runtime.ToolBoxes.typeCheckExpr for a workaround that might work for you) wrapper(callsiteTyper.silent(_.typed(tree, mirror.analyzer.EXPRmode, pt)) match { case mirror.analyzer.SilentResultValue(result) => - trace(result) + macroLogVerbose(result) result case error @ mirror.analyzer.SilentTypeError(_) => - trace(error.err.errMsg) + macroLogVerbose(error.err.errMsg) if (!silent) throw new mirror.TypeError(error.err.errPos, error.err.errMsg) mirror.EmptyTree }) } def inferImplicitValue(pt: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = { - def trace(msg: Any) = if (mirror.settings.Ymacrodebug.value) println(msg) - trace("inferring implicit value of type %s, macros = %s".format(pt, !withMacrosDisabled)) + macroLogVerbose("inferring implicit value of type %s, macros = %s".format(pt, !withMacrosDisabled)) import mirror.analyzer.SearchResult - val wrapper1 = if (!withMacrosDisabled) (callsiteTyper.context.withMacrosEnabled[SearchResult] _) else (callsiteTyper.context.withMacrosDisabled[SearchResult] _) + val context = callsiteTyper.context + val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _) def wrapper (inference: => SearchResult) = wrapper1(inference) - val context = callsiteTyper.context.makeImplicit(true) wrapper(mirror.analyzer.inferImplicit(mirror.EmptyTree, pt, true, false, context, !silent, pos)) match { case failure if failure.tree.isEmpty => - trace("implicit search has failed. to find out the reason, turn on -Xlog-implicits") + macroLogVerbose("implicit search has failed. to find out the reason, turn on -Xlog-implicits") if (context.hasErrors) throw new mirror.TypeError(context.errBuffer.head.errPos, context.errBuffer.head.errMsg) mirror.EmptyTree case success => @@ -48,17 +46,16 @@ trait Typers { } def inferImplicitView(tree: Tree, from: Type, to: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, reportAmbiguous: Boolean = true, pos: Position = enclosingPosition): Tree = { - def trace(msg: Any) = if (mirror.settings.Ymacrodebug.value) println(msg) - trace("inferring implicit view from %s to %s for %s, macros = %s, reportAmbiguous = %s".format(from, to, tree, !withMacrosDisabled, reportAmbiguous)) + macroLogVerbose("inferring implicit view from %s to %s for %s, macros = %s, reportAmbiguous = %s".format(from, to, tree, !withMacrosDisabled, reportAmbiguous)) import mirror.analyzer.SearchResult - val wrapper1 = if (!withMacrosDisabled) (callsiteTyper.context.withMacrosEnabled[SearchResult] _) else (callsiteTyper.context.withMacrosDisabled[SearchResult] _) + val context = callsiteTyper.context + val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _) def wrapper (inference: => SearchResult) = wrapper1(inference) val fun1 = mirror.definitions.FunctionClass(1) val viewTpe = mirror.TypeRef(fun1.typeConstructor.prefix, fun1, List(from, to)) - val context = callsiteTyper.context.makeImplicit(reportAmbiguous) - wrapper(mirror.analyzer.inferImplicit(mirror.EmptyTree, viewTpe, reportAmbiguous, true, context, !silent, pos)) match { + wrapper(mirror.analyzer.inferImplicit(tree, viewTpe, reportAmbiguous, true, context, !silent, pos)) match { case failure if failure.tree.isEmpty => - trace("implicit search has failed. to find out the reason, turn on -Xlog-implicits") + macroLogVerbose("implicit search has failed. to find out the reason, turn on -Xlog-implicits") if (context.hasErrors) throw new mirror.TypeError(context.errBuffer.head.errPos, context.errBuffer.head.errMsg) mirror.EmptyTree case success => diff --git a/src/compiler/scala/reflect/makro/util/Traces.scala b/src/compiler/scala/reflect/makro/util/Traces.scala new file mode 100644 index 0000000000..2363cc4bac --- /dev/null +++ b/src/compiler/scala/reflect/makro/util/Traces.scala @@ -0,0 +1,18 @@ +package scala.reflect.makro +package util + +trait Traces { + def globalSettings: tools.nsc.Settings + + // [Eugene] lots of ways to log: + // 1) trace(...) + // 2) log(...) + // 3) if (foo) { doStuff(); includingSomeLogs(); } + // what is the conventional way of unifying this? + val macroDebugLite = globalSettings.YmacrodebugLite.value + val macroDebugVerbose = globalSettings.YmacrodebugVerbose.value + val macroTraceLite = scala.tools.nsc.util.trace when (macroDebugLite || macroDebugVerbose) + val macroTraceVerbose = scala.tools.nsc.util.trace when macroDebugVerbose + @inline final def macroLogLite(msg: => Any) { if (macroDebugLite || macroDebugVerbose) println(msg) } + @inline final def macroLogVerbose(msg: => Any) { if (macroDebugVerbose) println(msg) } +}
\ No newline at end of file diff --git a/src/compiler/scala/reflect/reify/Errors.scala b/src/compiler/scala/reflect/reify/Errors.scala index 30c6c06c7b..4466f281b8 100644 --- a/src/compiler/scala/reflect/reify/Errors.scala +++ b/src/compiler/scala/reflect/reify/Errors.scala @@ -1,7 +1,8 @@ package scala.reflect package reify -import scala.tools.nsc.Global +import scala.reflect.makro.ReificationError +import scala.reflect.makro.UnexpectedReificationError trait Errors { self: Reifier => @@ -9,11 +10,7 @@ trait Errors { import mirror._ import definitions._ - class ReificationError(var pos: Position, val msg: String) extends Throwable(msg) - class UnexpectedReificationError(val pos: Position, val msg: String, val cause: Throwable = null) extends Throwable(msg) - - lazy val defaultErrorPosition: Position = - mirror.analyzer.openMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication.pos).getOrElse(NoPosition) + def defaultErrorPosition = analyzer.enclosingMacroPosition // expected errors: these can happen if the user casually writes whatever.reify(...) // hence we don't crash here, but nicely report a typechecking error and bail out asap @@ -60,4 +57,4 @@ trait Errors { val msg = "internal error: erroneous reifees are not supported, make sure that your reifee has typechecked successfully before passing it to the reifier" throw new UnexpectedReificationError(defaultErrorPosition, msg) } -}
\ No newline at end of file +} diff --git a/src/compiler/scala/reflect/reify/Reifier.scala b/src/compiler/scala/reflect/reify/Reifier.scala index 16c26734b2..fea825358e 100644 --- a/src/compiler/scala/reflect/reify/Reifier.scala +++ b/src/compiler/scala/reflect/reify/Reifier.scala @@ -2,6 +2,8 @@ package scala.reflect package reify import scala.tools.nsc.Global +import scala.reflect.makro.ReificationError +import scala.reflect.makro.UnexpectedReificationError /** Given a tree or a type, generate a tree that when executed at runtime produces the original tree or type. * See more info in the comments to ``reify'' in scala.reflect.api.Universe. @@ -21,7 +23,7 @@ abstract class Reifier extends Phases val prefix: Tree val reifee: Any val dontSpliceAtTopLevel: Boolean - val requireConcreteTypeTag: Boolean + val concrete: Boolean /** * For ``reifee'' and other reification parameters, generate a tree of the form @@ -72,22 +74,23 @@ abstract class Reifier extends Phases if (tree.tpe exists (sub => sub.typeSymbol.isLocalToReifee)) CannotReifyReifeeThatHasTypeLocalToReifee(tree) - val manifestedType = typer.packedType(tree, NoSymbol) - val manifestedRtype = reifyType(manifestedType) - val tagModule = if (definitelyConcrete) ConcreteTypeTagModule else TypeTagModule - var typeTagCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType))) - var exprCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), ExprModule.name), List(TypeTree(manifestedType))) - Apply(Apply(exprCtor, List(rtree)), List(Apply(typeTagCtor, List(manifestedRtype)))) + val taggedType = typer.packedType(tree, NoSymbol) + val tagModule = if (reificationIsConcrete) ConcreteTypeTagModule else TypeTagModule + val tagCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(taggedType))) + val exprCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), ExprModule.name), List(TypeTree(taggedType))) + val tagArgs = List(reify(taggedType), reifyErasure(mirror)(typer, taggedType, concrete = false)) + Apply(Apply(exprCtor, List(rtree)), List(Apply(tagCtor, tagArgs))) case tpe: Type => reifyTrace("reifying = ")(tpe.toString) reifyTrace("prefix = ")(prefix) val rtree = reify(tpe) - val manifestedType = tpe - var tagModule = if (definitelyConcrete) ConcreteTypeTagModule else TypeTagModule - var ctor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType))) - Apply(ctor, List(rtree)) + val taggedType = tpe + val tagModule = if (reificationIsConcrete) ConcreteTypeTagModule else TypeTagModule + val ctor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(taggedType))) + val args = List(rtree, reifyErasure(mirror)(typer, taggedType, concrete = false)) + Apply(ctor, args) case _ => throw new Error("reifee %s of type %s is not supported".format(reifee, if (reifee == null) "null" else reifee.getClass.toString)) @@ -126,10 +129,17 @@ abstract class Reifier extends Phases // 3) local freeterm inlining in Metalevels // 4) trivial tree splice inlining in Reify (Trees.scala) // 5) trivial type splice inlining in Reify (Types.scala) - val freevarBindings = symbolTable collect { case freedef @ FreeDef(_, _, binding, _) => binding.symbol } toSet + val freevarBindings = symbolTable collect { case entry @ FreeDef(_, _, binding, _, _) => binding.symbol } toSet + // [Eugene] yeah, ugly and extremely brittle, but we do need to do resetAttrs. will be fixed later + var importantSymbols = Set[Symbol](PredefModule, ScalaRunTimeModule) + importantSymbols ++= importantSymbols map (_.companionSymbol) + importantSymbols ++= importantSymbols map (_.moduleClass) + importantSymbols ++= importantSymbols map (_.linkedClassOfClass) + def importantSymbol(sym: Symbol): Boolean = sym != null && sym != NoSymbol && importantSymbols(sym) val untyped = resetAllAttrs(wrapped, leaveAlone = { case ValDef(_, mr, _, _) if mr == nme.MIRROR_SHORT => true case tree if freevarBindings contains tree.symbol => true + case tree if importantSymbol(tree.symbol) => true case _ => false }) diff --git a/src/compiler/scala/reflect/reify/codegen/Symbols.scala b/src/compiler/scala/reflect/reify/codegen/Symbols.scala index 2fc0002838..21a08b7efb 100644 --- a/src/compiler/scala/reflect/reify/codegen/Symbols.scala +++ b/src/compiler/scala/reflect/reify/codegen/Symbols.scala @@ -63,9 +63,9 @@ trait Symbols { assert(value.isInstanceOf[Ident], showRaw(value)) val capturedTpe = capturedVariableType(sym) val capturedValue = referenceCapturedVariable(sym) - locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(capturedTpe), capturedValue, reify(origin(sym)))) + locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(capturedTpe), capturedValue, reify(sym.flags), reify(origin(sym)))) } else { - locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(sym.tpe), value, reify(origin(sym)))) + locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(sym.tpe), value, reify(sym.flags), reify(origin(sym)))) } } @@ -76,9 +76,9 @@ trait Symbols { case None => if (reifyDebug) println("Free type: %s (%s)".format(sym, sym.accurateKindString)) var name = newTermName(nme.MIRROR_FREE_PREFIX + sym.name) - val phantomTypeTag = Apply(TypeApply(Select(Ident(nme.MIRROR_SHORT), nme.TypeTag), List(value)), List(Literal(Constant(null)))) - // todo. implement info reification for free types: type bounds, HK-arity, whatever else that can be useful - locallyReify(sym, name, mirrorCall(nme.newFreeType, reify(sym.name.toString), reify(sym.info), phantomTypeTag, reify(origin(sym)))) + val phantomTypeTag = Apply(TypeApply(Select(Ident(nme.MIRROR_SHORT), nme.TypeTag), List(value)), List(Literal(Constant(null)), Literal(Constant(null)))) + val flavor = if (sym.isExistential) nme.newFreeExistential else nme.newFreeType + locallyReify(sym, name, mirrorCall(flavor, reify(sym.name.toString), reify(sym.info), phantomTypeTag, reify(sym.flags), reify(origin(sym)))) } def reifySymDef(sym: Symbol): Tree = @@ -105,9 +105,9 @@ trait Symbols { filledIn = false newSymbolTable foreach { case entry => - val att = entry.attachment + val att = entry.attachmentOpt[ReifyAttachment] att match { - case sym: Symbol => + case Some(ReifyAttachment(sym)) => // don't duplicate reified symbols when merging inlined reifee if (!(locallyReified contains sym)) { val ValDef(_, name, _, _) = entry @@ -134,7 +134,7 @@ trait Symbols { // todo. tried to declare a private class here to carry an attachment, but it's path-dependent // so got troubles with exchanging free variables between nested and enclosing quasiquotes // attaching just Symbol isn't good either, so we need to think of a principled solution - val local = ValDef(NoMods, name, TypeTree(), reified) setAttachment sym + val local = ValDef(NoMods, name, TypeTree(), reified) withAttachment ReifyAttachment(sym) localReifications += local filledIn = false locallyReified(sym) = Ident(name) @@ -149,8 +149,9 @@ trait Symbols { while (i < localReifications.length) { // fillInSymbol might create new locallyReified symbols, that's why this is done iteratively val reified = localReifications(i) - reified.attachment match { - case sym: Symbol => fillIns += fillInSymbol(sym) + val att = reified.attachmentOpt[ReifyAttachment] + att match { + case Some(ReifyAttachment(sym)) => fillIns += fillInSymbol(sym) case other => // do nothing } i += 1 @@ -169,9 +170,15 @@ trait Symbols { if (sym.annotations.isEmpty) EmptyTree else Apply(Select(locallyReified(sym), nme.setAnnotations), List(reify(sym.annotations))) } else { - val rset = Apply(Select(locallyReified(sym), nme.setTypeSignature), List(reifyType(sym.info))) - if (sym.annotations.isEmpty) rset - else Apply(Select(rset, nme.setAnnotations), List(reify(sym.annotations))) + import scala.reflect.internal.Flags._ + if (sym hasFlag LOCKED) { + // [Eugene] better to have a symbol without a type signature, than to crash with a CyclicReference + EmptyTree + } else { + val rset = Apply(Select(locallyReified(sym), nme.setTypeSignature), List(reify(sym.info))) + if (sym.annotations.isEmpty) rset + else Apply(Select(rset, nme.setAnnotations), List(reify(sym.annotations))) + } } } }
\ No newline at end of file diff --git a/src/compiler/scala/reflect/reify/codegen/Trees.scala b/src/compiler/scala/reflect/reify/codegen/Trees.scala index 5ad53c0009..c9f5fc5b8d 100644 --- a/src/compiler/scala/reflect/reify/codegen/Trees.scala +++ b/src/compiler/scala/reflect/reify/codegen/Trees.scala @@ -7,6 +7,7 @@ trait Trees { import mirror._ import definitions._ import treeInfo._ + import scala.reflect.api.Modifier // unfortunately, these are necessary to reify AnnotatedTypes // I'd gladly got rid of them, but I don't fancy making a metaprogramming API that doesn't work with annotated types @@ -46,7 +47,7 @@ trait Trees { reifyMirrorObject(EmptyTree) case mirror.emptyValDef => mirrorSelect(nme.emptyValDef) - case FreeDef(_, _, _, _) => + case FreeDef(_, _, _, _, _) => reifyNestedFreeDef(tree) case FreeRef(_, _) => reifyNestedFreeRef(tree) @@ -57,6 +58,28 @@ trait Trees { case NestedExpr(_, _, _) => reifyNestedExpr(tree) case Literal(const @ Constant(_)) => + // [Eugene] was necessary when we reified erasures as normalized tycons + // now, when we do existentialAbstraction on normalizations, everything works great + // todo. find an explanation +// if (const.tag == ClazzTag) { +//// def preprocess(tpe: Type): Type = tpe.typeSymbol match { +//// case ArrayClass => appliedType(ArrayClass, preprocess(tpe.typeArgs.head)) +//// case _ => tpe.typeConstructor +//// } +//// val tpe = preprocess(const.typeValue) +// val tpe = const.typeValue +// var reified = reify(tpe) +// reified = mirrorCall(nme.Literal, mirrorCall(nme.Constant, reified)) +//// val skolems = ClassClass.typeParams map (_ => newTypeName(typer.context.unit.fresh.newName("_$"))) +//// var existential = mirrorCall(nme.AppliedTypeTree, mirrorCall(nme.TypeTree, reify(ClassClass.typeConstructor)), mkList(skolems map (skolem => mirrorCall(nme.Ident, reify(skolem))))) +//// existential = mirrorCall(nme.ExistentialTypeTree, existential, reify(skolems map (skolem => TypeDef(Modifiers(Set(Modifier.deferred: Modifier)), skolem, Nil, TypeBoundsTree(Ident(NothingClass) setType NothingClass.tpe, Ident(AnyClass) setType AnyClass.tpe))))) +//// reified = mirrorCall(nme.TypeApply, mirrorCall(nme.Select, reified, reify(nme.asInstanceOf_)), mkList(List(existential))) +// // why is this required?? +//// reified = mirrorCall(nme.TypeApply, mirrorCall(nme.Select, reified, reify(nme.asInstanceOf_)), mkList(List(mirrorCall(nme.TypeTree, reify(appliedType(ClassClass.tpe, List(AnyClass.tpe))))))) +// reified +// } else { +// mirrorCall(nme.Literal, reifyProduct(const)) +// } mirrorCall(nme.Literal, reifyProduct(const)) case Import(expr, selectors) => mirrorCall(nme.Import, reify(expr), mkList(selectors map reifyProduct)) @@ -68,11 +91,11 @@ trait Trees { // however, reification of AnnotatedTypes is special. see ``reifyType'' to find out why. if (reifyTreeSymbols && tree.hasSymbol) { if (reifyDebug) println("reifying symbol %s for tree %s".format(tree.symbol, tree)) - rtree = Apply(Select(rtree, nme.setSymbol), List(reifySymRef(tree.symbol))) + rtree = Apply(Select(rtree, nme.setSymbol), List(reify(tree.symbol))) } if (reifyTreeTypes && tree.tpe != null) { if (reifyDebug) println("reifying type %s for tree %s".format(tree.tpe, tree)) - rtree = Apply(Select(rtree, nme.setType), List(reifyType(tree.tpe))) + rtree = Apply(Select(rtree, nme.setType), List(reify(tree.tpe))) } rtree @@ -98,7 +121,7 @@ trait Trees { case InlinedTreeSplice(_, inlinedSymbolTable, tree, _) => if (reifyDebug) println("inlining the splicee") // all free vars local to the enclosing reifee should've already been inlined by ``Metalevels'' - inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _) if binding.symbol.isLocalToReifee => assert(false, freedef) } + inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _, _) if binding.symbol.isLocalToReifee => assert(false, freedef) } symbolTable ++= inlinedSymbolTable tree case tree => @@ -172,7 +195,7 @@ trait Trees { val spliced = spliceType(tpe) if (spliced == EmptyTree) { if (reifyDebug) println("splicing failed: reify as is") - mirrorCall(nme.TypeTree, reifyType(tpe)) + mirrorCall(nme.TypeTree, reify(tpe)) } else { spliced match { case TypeRefToFreeType(freeType) => @@ -189,7 +212,7 @@ trait Trees { mirrorCall(nme.Ident, reify(sym)) } else { if (reifyDebug) println("tpe is an alias, but not a locatable: reify as TypeTree(%s)".format(tpe)) - mirrorCall(nme.TypeTree, reifyType(tpe)) + mirrorCall(nme.TypeTree, reify(tpe)) } } } diff --git a/src/compiler/scala/reflect/reify/codegen/Types.scala b/src/compiler/scala/reflect/reify/codegen/Types.scala index 948728088e..1f336f4b0f 100644 --- a/src/compiler/scala/reflect/reify/codegen/Types.scala +++ b/src/compiler/scala/reflect/reify/codegen/Types.scala @@ -65,8 +65,16 @@ trait Types { private var spliceTypesEnabled = !dontSpliceAtTopLevel /** Keeps track of whether this reification contains abstract type parameters */ - var maybeConcrete = true - var definitelyConcrete = true + private var _reificationIsConcrete = true + def reificationIsConcrete = _reificationIsConcrete + def reificationIsConcrete_=(value: Boolean) { + _reificationIsConcrete = value + if (!value && concrete) { + assert(current.isInstanceOf[Type], current) + val offender = current.asInstanceOf[Type] + CannotReifyConcreteTypeTagHavingUnresolvedTypeParameters(offender) + } + } private type SpliceCacheKey = (Symbol, Symbol) private lazy val spliceCache: collection.mutable.Map[SpliceCacheKey, Tree] = { @@ -75,11 +83,13 @@ trait Types { } def spliceType(tpe: Type): Tree = { - if (tpe.isSpliceable) { + // [Eugene] it seems that depending on the context the very same symbol can be either a spliceable tparam or a quantified existential. very weird! + val quantified = currentQuantified + if (tpe.isSpliceable && !(quantified contains tpe.typeSymbol)) { if (reifyDebug) println("splicing " + tpe) if (spliceTypesEnabled) { - var tagClass = if (requireConcreteTypeTag) ConcreteTypeTagClass else TypeTagClass + var tagClass = if (concrete) ConcreteTypeTagClass else TypeTagClass val tagTpe = singleType(prefix.tpe, prefix.tpe member tagClass.name) // [Eugene] this should be enough for an abstract type, right? @@ -89,22 +99,18 @@ trait Types { // if this fails, it might produce the dreaded "erroneous or inaccessible type" error // to find out the whereabouts of the error run scalac with -Ydebug if (reifyDebug) println("launching implicit search for %s.%s[%s]".format(prefix, tagClass.name, tpe)) - val positionBearer = mirror.analyzer.openMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication).getOrElse(EmptyTree).asInstanceOf[Tree] - typer.resolveTypeTag(positionBearer, prefix.tpe, tpe, requireConcreteTypeTag) match { + typer.resolveTypeTag(defaultErrorPosition, prefix.tpe, tpe, concrete) match { case failure if failure.isEmpty => if (reifyDebug) println("implicit search was fruitless") - definitelyConcrete &= false - maybeConcrete &= false EmptyTree case success => if (reifyDebug) println("implicit search has produced a result: " + success) - definitelyConcrete |= requireConcreteTypeTag - maybeConcrete |= true + reificationIsConcrete &= concrete var splice = Select(success, nme.tpe) splice match { case InlinedTypeSplice(_, inlinedSymbolTable, tpe) => // all free vars local to the enclosing reifee should've already been inlined by ``Metalevels'' - inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _) if binding.symbol.isLocalToReifee => assert(false, freedef) } + inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _, _) if binding.symbol.isLocalToReifee => assert(false, freedef) } symbolTable ++= inlinedSymbolTable reifyTrace("inlined the splicee: ")(tpe) case tpe => @@ -117,8 +123,7 @@ trait Types { if (reifyDebug) println("splicing has been cancelled: spliceTypesEnabled = false") } - if (requireConcreteTypeTag) - CannotReifyConcreteTypeTagHavingUnresolvedTypeParameters(tpe) + reificationIsConcrete = false } spliceTypesEnabled = true diff --git a/src/compiler/scala/reflect/reify/package.scala b/src/compiler/scala/reflect/reify/package.scala index 85cf92fe2f..3f9d6200cd 100644 --- a/src/compiler/scala/reflect/reify/package.scala +++ b/src/compiler/scala/reflect/reify/package.scala @@ -1,14 +1,16 @@ package scala.reflect import scala.tools.nsc.Global +import scala.reflect.makro.ReificationError +import scala.reflect.makro.UnexpectedReificationError package object reify { - def mkReifier(global: Global)(typer: global.analyzer.Typer, prefix: global.Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Reifier { val mirror: global.type } = { + private def mkReifier(global: Global)(typer: global.analyzer.Typer, prefix: global.Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, concrete: Boolean = false): Reifier { val mirror: global.type } = { val typer1: typer.type = typer val prefix1: prefix.type = prefix val reifee1 = reifee val dontSpliceAtTopLevel1 = dontSpliceAtTopLevel - val requireConcreteTypeTag1 = requireConcreteTypeTag + val concrete1 = concrete new { val mirror: global.type = global @@ -16,7 +18,41 @@ package object reify { val prefix = prefix1 val reifee = reifee1 val dontSpliceAtTopLevel = dontSpliceAtTopLevel1 - val requireConcreteTypeTag = requireConcreteTypeTag1 + val concrete = concrete1 } with Reifier } + + def reifyTree(global: Global)(typer: global.analyzer.Typer, prefix: global.Tree, tree: global.Tree): global.Tree = + mkReifier(global)(typer, prefix, tree, false, false).reified.asInstanceOf[global.Tree] + + def reifyType(global: Global)(typer: global.analyzer.Typer, prefix: global.Tree, tpe: global.Type, dontSpliceAtTopLevel: Boolean = false, concrete: Boolean = false): global.Tree = + mkReifier(global)(typer, prefix, tpe, dontSpliceAtTopLevel, concrete).reified.asInstanceOf[global.Tree] + + def reifyErasure(global: Global)(typer0: global.analyzer.Typer, tpe: global.Type, concrete: Boolean = true): global.Tree = { + import global._ + import definitions._ + import analyzer.enclosingMacroPosition + + def erasureTagInScope = typer0.context.withMacrosDisabled(typer0.resolveErasureTag(enclosingMacroPosition, tpe, concrete = concrete)) + def arrayTagInScope = typer0.context.withMacrosDisabled(typer0.resolveArrayTag(enclosingMacroPosition, tpe)) + val inScope = (erasureTagInScope, arrayTagInScope) + + inScope match { + case (success, _) if !success.isEmpty => + Select(success, nme.erasure) + case (_, success) if !success.isEmpty => + gen.mkMethodCall(arrayElementClassMethod, List(success)) + case _ => + if (tpe.typeSymbol == ArrayClass) { + val componentTpe = tpe.typeArguments(0) + val componentErasure = reifyErasure(global)(typer0, componentTpe, concrete) + gen.mkMethodCall(arrayClassMethod, List(componentErasure)) + } else { + if (tpe.isSpliceable && concrete) throw new ReificationError(enclosingMacroPosition, "tpe %s is an unresolved spliceable type".format(tpe)) + var erasure = tpe.erasure + if (tpe.typeSymbol.isDerivedValueClass && global.phase.id < global.currentRun.erasurePhase.id) erasure = tpe + gen.mkNullaryCall(Predef_classOf, List(erasure)) + } + } + } } diff --git a/src/compiler/scala/reflect/reify/phases/Calculate.scala b/src/compiler/scala/reflect/reify/phases/Calculate.scala index e4f3fce407..93ef46472e 100644 --- a/src/compiler/scala/reflect/reify/phases/Calculate.scala +++ b/src/compiler/scala/reflect/reify/phases/Calculate.scala @@ -46,6 +46,7 @@ trait Calculate { bindRelatedSymbol(tree.symbol.companionClass, "companionClass") bindRelatedSymbol(tree.symbol.companionModule, "companionModule") Some(tree.symbol) collect { case termSymbol: TermSymbol => bindRelatedSymbol(termSymbol.referenced, "referenced") } + Some(tree) collect { case labelDef: LabelDef => labelDef.params foreach (param => bindRelatedSymbol(param.symbol, "labelParam")) } def bindRelatedSymbol(related: Symbol, name: String): Unit = if (related != null && related != NoSymbol) { if (reifyDebug) println("boundSym (" + name + "): " + related) diff --git a/src/compiler/scala/reflect/reify/phases/Metalevels.scala b/src/compiler/scala/reflect/reify/phases/Metalevels.scala index bb0b8ac138..206f3b1118 100644 --- a/src/compiler/scala/reflect/reify/phases/Metalevels.scala +++ b/src/compiler/scala/reflect/reify/phases/Metalevels.scala @@ -115,7 +115,7 @@ trait Metalevels { if (reifyDebug) println("entering inlineable splice: " + splicee) val Block(mrDef :: symbolTable, expr) = splicee // [Eugene] how to express the fact that a scrutinee is both of some type and matches an extractor? - val freedefsToInline = symbolTable collect { case freedef @ FreeTermDef(_, _, binding, _) if binding.symbol.isLocalToReifee => freedef.asInstanceOf[ValDef] } + val freedefsToInline = symbolTable collect { case freedef @ FreeTermDef(_, _, binding, _, _) if binding.symbol.isLocalToReifee => freedef.asInstanceOf[ValDef] } freedefsToInline foreach (vdef => this.freedefsToInline(vdef.name) = vdef) val symbolTable1 = symbolTable diff freedefsToInline val tree1 = Select(Block(mrDef :: symbolTable1, expr), flavor) @@ -138,7 +138,7 @@ trait Metalevels { // some of them need to be rebuilt, some of them need to be removed, because they're no longer necessary case FreeRef(mr, name) if freedefsToInline contains name => if (reifyDebug) println("inlineable free ref: %s in %s".format(name, showRaw(tree))) - val freedef @ FreeDef(_, _, binding, _) = freedefsToInline(name) + val freedef @ FreeDef(_, _, binding, _, _) = freedefsToInline(name) if (reifyDebug) println("related definition: %s".format(showRaw(freedef))) val inlined = reify(binding) if (reifyDebug) println("verdict: inlined as %s".format(showRaw(inlined))) diff --git a/src/compiler/scala/reflect/reify/phases/Reify.scala b/src/compiler/scala/reflect/reify/phases/Reify.scala index 02a96987ed..e03ff5832c 100644 --- a/src/compiler/scala/reflect/reify/phases/Reify.scala +++ b/src/compiler/scala/reflect/reify/phases/Reify.scala @@ -19,11 +19,30 @@ trait Reify extends Symbols import definitions._ import treeInfo._ + // `reify` looked so nice, I wanted to push the last bit of orthogonal + // logic out of it so you can see the improvement. There is no cost to + // wrapper methods of this form because the inliner will eliminate them, + // but they are very good at separating concerns like pushing/popping + // a stack, and they are great for composition and reuse. + // + // Also, please avoid public vars whenever possible. + private object reifyStack { + var currents: List[Any] = reifee :: Nil + + @inline final def push[T](reifee: Any)(body: => T): T = { + currents ::= reifee + try body + finally currents = currents.tail + } + } + def currentQuantified = flatCollect(reifyStack.currents)({ case ExistentialType(quantified, _) => quantified }) + def current = reifyStack.currents.head + /** * Reifies any supported value. * For internal use only, use ``reified'' instead. */ - def reify(reifee: Any): Tree = reifee match { + def reify(reifee: Any): Tree = reifyStack.push(reifee)(reifee match { // before adding some case here, in global scope, please, consider // whether it can be localized like reifyAnnotationInfo or reifyScope // this will help reification stay as sane as possible @@ -33,7 +52,7 @@ trait Reify extends Symbols case tree: Tree => reifyTree(tree) // disabled because this is a very special case that I plan to remove later // why do I dislike annotations? see comments to `reifyAnnotationInfo` -// case ann: AnnotationInfo => reifyAnnotationInfo(ann) +// case ann: AnnotationInfo => reifyAnnotationInfo(ann) case pos: Position => reifyPosition(pos) case mods: mirror.Modifiers => reifyModifiers(mods) case xs: List[_] => reifyList(xs) @@ -42,5 +61,5 @@ trait Reify extends Symbols case null => Literal(Constant(null)) case _ => throw new Error("reifee %s of type %s is not supported".format(reifee, reifee.getClass)) - } + }) }
\ No newline at end of file diff --git a/src/compiler/scala/reflect/reify/phases/Reshape.scala b/src/compiler/scala/reflect/reify/phases/Reshape.scala index e700604612..4ab306a13f 100644 --- a/src/compiler/scala/reflect/reify/phases/Reshape.scala +++ b/src/compiler/scala/reflect/reify/phases/Reshape.scala @@ -78,12 +78,6 @@ trait Reshape { if (reifyDebug) println("unapplying unapply: " + tree) val fun1 = extractExtractor(fun) Apply(fun1, args).copyAttrs(unapply) - case Literal(const @ Constant(tpe: Type)) => - // todo. implement this - ??? - case Literal(const @ Constant(sym: Symbol)) => - // todo. implement this - ??? case _ => tree } diff --git a/src/compiler/scala/reflect/runtime/Mirror.scala b/src/compiler/scala/reflect/runtime/Mirror.scala index 20024ed058..bf4bc83bea 100644 --- a/src/compiler/scala/reflect/runtime/Mirror.scala +++ b/src/compiler/scala/reflect/runtime/Mirror.scala @@ -25,7 +25,7 @@ class Mirror(var classLoader: ClassLoader) extends Universe with api.Mirror { def symbolOfInstance(obj: Any): Symbol = classToScala(obj.getClass) def typeOfInstance(obj: Any): Type = typeToScala(obj.getClass) // to do add getClass/getType for instances of primitive types, probably like this: - // def getClass[T <: AnyVal : Manifest](x: T): Symbol = manifest[T].getClass + // def getClass[T <: AnyVal : ClassTag](x: T): Symbol = classTag[T].sym def getValueOfField(receiver: AnyRef, field: Symbol): Any = { fieldToJava(field).get(receiver) diff --git a/src/compiler/scala/reflect/runtime/SynchronizedOps.scala b/src/compiler/scala/reflect/runtime/SynchronizedOps.scala index dd806beb2a..907c0dd369 100644 --- a/src/compiler/scala/reflect/runtime/SynchronizedOps.scala +++ b/src/compiler/scala/reflect/runtime/SynchronizedOps.scala @@ -39,7 +39,7 @@ trait SynchronizedOps extends internal.SymbolTable trait SynchronizedScope extends Scope { override def isEmpty: Boolean = synchronized { super.isEmpty } override def size: Int = synchronized { super.size } - override def enter(sym: Symbol) = synchronized { super.enter(sym) } + override def enter[T <: Symbol](sym: T): T = synchronized { super.enter(sym) } override def rehash(sym: Symbol, newname: Name) = synchronized { super.rehash(sym, newname) } override def unlink(e: ScopeEntry) = synchronized { super.unlink(e) } override def unlink(sym: Symbol) = synchronized { super.unlink(sym) } diff --git a/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala b/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala index 6fc5f7ed8a..8378f1a892 100644 --- a/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala +++ b/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala @@ -14,11 +14,11 @@ trait SynchronizedSymbols extends internal.Symbols { self: SymbolTable => override def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): ModuleSymbol = synchronized { super.connectModuleToClass(m, moduleClass) } - override def newFreeTerm(name: TermName, info: Type, value: => Any, origin: String = null, newFlags: Long = 0L): FreeTerm = - new FreeTerm(name, value, origin) with SynchronizedTermSymbol initFlags newFlags setInfo info + override def newFreeTermSymbol(name: TermName, info: Type, value: => Any, flags: Long = 0L, origin: String = null): FreeTerm = + new FreeTerm(name, value, origin) with SynchronizedTermSymbol initFlags flags setInfo info - override def newFreeType(name: TypeName, info: Type, value: => Any, origin: String = null, newFlags: Long = 0L): FreeType = - new FreeType(name, value, origin) with SynchronizedTypeSymbol initFlags newFlags setInfo info + override def newFreeTypeSymbol(name: TypeName, info: Type, value: => Any, flags: Long = 0L, origin: String = null): FreeType = + new FreeType(name, value, origin) with SynchronizedTypeSymbol initFlags flags setInfo info override protected def makeNoSymbol: NoSymbol = new NoSymbol with SynchronizedSymbol @@ -46,7 +46,7 @@ trait SynchronizedSymbols extends internal.Symbols { self: SymbolTable => override def typeParams: List[Symbol] = synchronized { super.typeParams } - override def reset(completer: Type) = synchronized { super.reset(completer) } + override def reset(completer: Type): this.type = synchronized { super.reset(completer) } override def infosString: String = synchronized { super.infosString } diff --git a/src/compiler/scala/reflect/runtime/ToolBoxes.scala b/src/compiler/scala/reflect/runtime/ToolBoxes.scala index 6d832a590f..7b1fc9fc0d 100644 --- a/src/compiler/scala/reflect/runtime/ToolBoxes.scala +++ b/src/compiler/scala/reflect/runtime/ToolBoxes.scala @@ -16,14 +16,11 @@ import scala.compat.Platform.EOL trait ToolBoxes extends { self: Universe => - import self.{Reporter => ApiReporter} - import scala.tools.nsc.reporters.{Reporter => NscReporter} + def mkToolBox(frontEnd: FrontEnd = mkSilentFrontEnd(), options: String = "") = new ToolBox(frontEnd, options) - def mkToolBox(reporter: ApiReporter = mkSilentReporter(), options: String = "") = new ToolBox(reporter, options) + class ToolBox(val frontEnd: FrontEnd, val options: String) extends AbsToolBox { - class ToolBox(val reporter: ApiReporter, val options: String) extends AbsToolBox { - - class ToolBoxGlobal(settings: scala.tools.nsc.Settings, reporter: NscReporter) + class ToolBoxGlobal(settings: scala.tools.nsc.Settings, reporter: Reporter) extends ReflectGlobal(settings, reporter, ToolBox.this.classLoader) { import definitions._ @@ -116,7 +113,7 @@ trait ToolBoxes extends { self: Universe => override def transform(tree: Tree): Tree = tree match { case Ident(name) if reversedFreeTermNames contains name => - Ident(reversedFreeTermNames(name)) + Ident(reversedFreeTermNames(name)) setType tree.tpe case _ => super.transform(tree) } @@ -200,11 +197,7 @@ trait ToolBoxes extends { self: Universe => val run = new Run reporter.reset() run.compileUnits(List(unit), run.namerPhase) - if (reporter.hasErrors) { - var msg = "reflective compilation has failed: " + EOL + EOL - msg += ToolBox.this.reporter.infos map (_.msg) mkString EOL - throw new ToolBoxError(ToolBox.this, msg) - } + throwIfErrors() val className = mdef.symbol.fullName if (settings.debug.value) println("generated: "+className) @@ -250,6 +243,15 @@ trait ToolBoxes extends { self: Universe => settings.Yshowsymkinds.value = saved3 } } + + // reporter doesn't accumulate errors, but the front-end does + def throwIfErrors() = { + if (frontEnd.hasErrors) { + var msg = "reflective compilation has failed: " + EOL + EOL + msg += frontEnd.infos map (_.msg) mkString EOL + throw new ToolBoxError(ToolBox.this, msg) + } + } } // todo. is not going to work with quoted arguments with embedded whitespaces @@ -263,19 +265,13 @@ trait ToolBoxes extends { self: Universe => lazy val compiler: ToolBoxGlobal = { try { - val errorFn: String => Unit = msg => reporter.log(NoPosition, msg, reporter.ERROR) - // [Eugene] settings shouldn't be passed via reporters, this is crazy -// val command = reporter match { -// case reporter: AbstractReporter => new CompilerCommand(arguments.toList, reporter.settings, errorFn) -// case _ => new CompilerCommand(arguments.toList, errorFn) -// } + val errorFn: String => Unit = msg => frontEnd.log(NoPosition, msg, frontEnd.ERROR) val command = new CompilerCommand(arguments.toList, errorFn) command.settings.outputDirs setSingleOutput virtualDirectory - val nscReporter = new ApiToNscReporterProxy(reporter) { val settings = command.settings } - val instance = new ToolBoxGlobal(command.settings, nscReporter) - if (nscReporter.hasErrors) { + val instance = new ToolBoxGlobal(command.settings, new FrontEndToReporterProxy(frontEnd) { val settings = command.settings }) + if (frontEnd.hasErrors) { var msg = "reflective compilation has failed: cannot initialize the compiler: " + EOL + EOL - msg += reporter.infos map (_.msg) mkString EOL + msg += frontEnd.infos map (_.msg) mkString EOL throw new ToolBoxError(this, msg) } instance.phase = (new instance.Run).typerPhase // need to manually set a phase, because otherwise TypeHistory will crash diff --git a/src/compiler/scala/tools/cmd/FromString.scala b/src/compiler/scala/tools/cmd/FromString.scala index 9592e7a716..91356b3c19 100644 --- a/src/compiler/scala/tools/cmd/FromString.scala +++ b/src/compiler/scala/tools/cmd/FromString.scala @@ -7,19 +7,19 @@ package scala.tools package cmd import nsc.io.{ Path, File, Directory } -import scala.reflect.Manifest +import scala.reflect.TypeTag /** A general mechanism for defining how a command line argument * (always a String) is transformed into an arbitrary type. A few * example instances are in the companion object, but in general * either IntFromString will suffice or you'll want custom transformers. */ -abstract class FromString[+T](implicit m: Manifest[T]) extends PartialFunction[String, T] { +abstract class FromString[+T](implicit t: TypeTag[T]) extends PartialFunction[String, T] { def apply(s: String): T def isDefinedAt(s: String): Boolean = true def zero: T = apply("") - def targetString: String = m.toString + def targetString: String = t.toString } object FromString { diff --git a/src/compiler/scala/tools/cmd/gen/AnyVals.scala b/src/compiler/scala/tools/cmd/gen/AnyVals.scala index e8230b8ca4..83cd9c2578 100644 --- a/src/compiler/scala/tools/cmd/gen/AnyVals.scala +++ b/src/compiler/scala/tools/cmd/gen/AnyVals.scala @@ -15,18 +15,27 @@ trait AnyValReps { case class Op(val op : String, val doc : String) - private def companionCoercions(tos: String*) = { + private def companionCoercions(tos: AnyValRep*) = { tos.toList map (to => - """implicit def %s2%s(x: %s): %s = x.to%s""".format(javaEquiv, to, name, to.capitalize, to.capitalize) + """implicit def @javaequiv@2%s(x: @name@): %s = x.to%s""".format(to.javaEquiv, to.name, to.name) ) } - def implicitCoercions: List[String] = javaEquiv match { - case "byte" => companionCoercions("short", "int", "long", "float", "double") - case "short" | "char" => companionCoercions("int", "long", "float", "double") - case "int" => companionCoercions("long", "float", "double") - case "long" => companionCoercions("float", "double") - case "float" => companionCoercions("double") - case _ => Nil + def coercionCommentExtra = "" + def coercionComment = """ + /** Language mandated coercions from @name@ to "wider" types.%s + */""".format(coercionCommentExtra) + + def implicitCoercions: List[String] = { + val coercions = this match { + case B => companionCoercions(S, I, L, F, D) + case S | C => companionCoercions(I, L, F, D) + case I => companionCoercions(L, F, D) + case L => companionCoercions(F, D) + case F => companionCoercions(D) + case _ => Nil + } + if (coercions.isEmpty) Nil + else coercionComment :: coercions } def isCardinal: Boolean = isIntegerType(this) @@ -174,7 +183,7 @@ trait AnyValReps { } def objectLines = { val comp = if (isCardinal) cardinalCompanion else floatingCompanion - ((comp + allCompanions).trim.lines map interpolate).toList ++ implicitCoercions + (comp + allCompanions + "\n" + nonUnitCompanions).trim.lines.toList ++ implicitCoercions map interpolate } /** Makes a set of binary operations based on the given set of ops, args, and resultFn. @@ -238,8 +247,9 @@ trait AnyValReps { def classDoc = interpolate(classDocTemplate) def objectDoc = "" def mkImports = "" - def mkClass = assemble("final class", "private", "AnyVal", classLines) + "\n" - def mkObject = assemble("object", "", "AnyValCompanion", objectLines) + "\n" + + def mkClass = assemble("final class " + name + " private extends AnyVal", classLines) + def mkObject = assemble("object " + name + " extends AnyValCompanion", objectLines) def make() = List[String]( headerTemplate, mkImports, @@ -249,11 +259,10 @@ trait AnyValReps { mkObject ) mkString "" - def assemble(what: String, ctor: String, parent: String, lines: List[String]): String = { - val decl = "%s %s %s extends %s ".format(what, name, ctor, parent) - val body = if (lines.isEmpty) "{ }\n\n" else lines map indent mkString ("{\n", "\n", "\n}\n") + def assemble(decl: String, lines: List[String]): String = { + val body = if (lines.isEmpty) " { }\n\n" else lines map indent mkString (" {\n", "\n", "\n}\n") - decl + body + decl + body + "\n" } override def toString = name } @@ -310,6 +319,8 @@ def unbox(x: java.lang.Object): @name@ = @unboxImpl@ override def toString = "object scala.@name@" """ + def nonUnitCompanions = "" // todo + def cardinalCompanion = """ /** The smallest value representable as a @name@. */ @@ -446,7 +457,7 @@ def ^(x: Boolean): Boolean = sys.error("stub") override def getClass(): Class[Boolean] = sys.error("stub") """.trim.lines.toList - def objectLines = interpolate(allCompanions).lines.toList + def objectLines = interpolate(allCompanions + "\n" + nonUnitCompanions).lines.toList } object U extends AnyValRep("Unit", None, "void") { override def classDoc = """ diff --git a/src/compiler/scala/tools/cmd/program/DumpClass.scala b/src/compiler/scala/tools/cmd/program/DumpClass.scala new file mode 100644 index 0000000000..a583f1d3ea --- /dev/null +++ b/src/compiler/scala/tools/cmd/program/DumpClass.scala @@ -0,0 +1,40 @@ +/* NEST (New Scala Test) + * Copyright 2007-2011 LAMP/EPFL + * @author Paul Phillips + */ + +package scala.tools +package cmd +package program + +import scala.reflect.internal.JvmClassInfo +import scala.tools.nsc.io.Directory + +object DumpClass { + private val usage = """ + |Usage: dump-class [options] <path> <path> ... + | + |Parses and dumps the bytecode of all classes found at the given paths. + |""".stripMargin + + private val unaryOps = List( + "signatures" -> "dump signatures" + ) + private val info = Simple.scalaProgramInfo("dump-class", usage) + private val spec = Simple(info, unaryOps, Nil, null) + + def deepInfos(dir: String) = { + val files = Directory(dir).deepFiles.toList filter (_ hasExtension "class") + files.sortBy(_.path) map (f => (f.path, JvmClassInfo fromPath f.path)) + } + + def main(args: Array[String]): Unit = { + val runner = spec instance args + import runner._ + + if (args.isEmpty) + println(usage) + else + (residualArgs flatMap deepInfos) sortBy (_._1) map (_._2) foreach println + } +} diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index 92a0efff1e..2f1e15168a 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -5,7 +5,7 @@ package scala.tools.nsc -import util.{ FreshNameCreator, Position, NoPosition, SourceFile, NoSourceFile } +import util.{ FreshNameCreator, Position, NoPosition, BatchSourceFile, SourceFile, NoSourceFile } import scala.collection.mutable import scala.collection.mutable.{ LinkedHashSet, ListBuffer } @@ -88,10 +88,13 @@ trait CompilationUnits { self: Global => reporter.warning(pos, msg) def deprecationWarning(pos: Position, msg: String) = - currentRun.deprecationWarnings.warn(pos, msg) + currentRun.deprecationWarnings0.warn(pos, msg) def uncheckedWarning(pos: Position, msg: String) = - currentRun.uncheckedWarnings.warn(pos, msg) + currentRun.uncheckedWarnings0.warn(pos, msg) + + def inlinerWarning(pos: Position, msg: String) = + currentRun.inlinerWarnings.warn(pos, msg) def incompleteInputError(pos: Position, msg:String) = reporter.incompleteInputError(pos, msg) diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 403b5717b0..8c6c927640 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -8,15 +8,13 @@ package scala.tools.nsc import java.io.{ File, FileOutputStream, PrintWriter, IOException, FileNotFoundException } import java.nio.charset.{ Charset, CharsetDecoder, IllegalCharsetNameException, UnsupportedCharsetException } import compat.Platform.currentTime - import scala.tools.util.{ Profiling, PathResolver } import scala.collection.{ mutable, immutable } import io.{ SourceReader, AbstractFile, Path } -import reporters.{ Reporter => NscReporter, ConsoleReporter } +import reporters.{ Reporter, ConsoleReporter } import util.{ NoPosition, Exceptional, ClassPath, SourceFile, NoSourceFile, Statistics, StatisticsInfo, BatchSourceFile, ScriptSourceFile, ShowPickled, ScalaClassLoader, returning } import scala.reflect.internal.pickling.{ PickleBuffer, PickleFormat } import settings.{ AestheticSettings } - import symtab.{ Flags, SymbolTable, SymbolLoaders, SymbolTrackers } import symtab.classfile.Pickler import dependencies.DependencyAnalysis @@ -25,25 +23,25 @@ import ast._ import ast.parser._ import typechecker._ import transform._ - import backend.icode.{ ICodes, GenICode, ICodeCheckers } import backend.{ ScalaPrimitives, Platform, MSILPlatform, JavaPlatform } import backend.jvm.GenJVM import backend.opt.{ Inliners, InlineExceptionHandlers, ClosureElimination, DeadCodeElimination } import backend.icode.analysis._ import language.postfixOps - -class Global(var currentSettings: Settings, var reporter: NscReporter) extends SymbolTable - with ClassLoaders - with ToolBoxes - with CompilationUnits - with Plugins - with PhaseAssembly - with Trees - with FreeVars - with TreePrinters - with DocComments - with Positions { +import reflect.internal.StdAttachments + +class Global(var currentSettings: Settings, var reporter: Reporter) extends SymbolTable + with ClassLoaders + with ToolBoxes + with CompilationUnits + with Plugins + with PhaseAssembly + with Trees + with FreeVars + with TreePrinters + with DocComments + with Positions { override def settings = currentSettings @@ -51,7 +49,7 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S // alternate constructors ------------------------------------------ - def this(reporter: NscReporter) = + def this(reporter: Reporter) = this(new Settings(err => reporter.error(null, err)), reporter) def this(settings: Settings) = @@ -135,6 +133,16 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S infolevel = InfoLevel.Verbose } + def withInfoLevel[T](infolevel: nodePrinters.InfoLevel.Value)(op: => T) = { + val saved = nodePrinters.infolevel + try { + nodePrinters.infolevel = infolevel + op + } finally { + nodePrinters.infolevel = saved + } + } + /** Representing ASTs as graphs */ object treeBrowsers extends { val global: Global.this.type = Global.this @@ -950,6 +958,11 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S reporter.warning(NoPosition, "there were %d %s warnings; re-run with %s for details".format(warnings.size, what, option.name)) } + def newUnitParser(code: String) = new syntaxAnalyzer.UnitParser(newCompilationUnit(code)) + def newUnitScanner(code: String) = new syntaxAnalyzer.UnitScanner(newCompilationUnit(code)) + def newCompilationUnit(code: String) = new CompilationUnit(newSourceFile(code)) + def newSourceFile(code: String) = new BatchSourceFile("<console>", code) + /** A Run is a single execution of the compiler on a sets of units */ class Run { @@ -961,10 +974,17 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S /** The currently compiled unit; set from GlobalPhase */ var currentUnit: CompilationUnit = NoCompilationUnit - val deprecationWarnings = new ConditionalWarning("deprecation", settings.deprecation) - val uncheckedWarnings = new ConditionalWarning("unchecked", settings.unchecked) + // This change broke sbt; I gave it the thrilling name of uncheckedWarnings0 so + // as to recover uncheckedWarnings for its ever-fragile compiler interface. + val deprecationWarnings0 = new ConditionalWarning("deprecation", settings.deprecation) + val uncheckedWarnings0 = new ConditionalWarning("unchecked", settings.unchecked) val featureWarnings = new ConditionalWarning("feature", settings.feature) - val allConditionalWarnings = List(deprecationWarnings, uncheckedWarnings, featureWarnings) + val inlinerWarnings = new ConditionalWarning("inliner", settings.YinlinerWarnings) + val allConditionalWarnings = List(deprecationWarnings0, uncheckedWarnings0, featureWarnings, inlinerWarnings) + + // for sbt's benefit + def uncheckedWarnings: List[(Position, String)] = uncheckedWarnings0.warnings.toList + def deprecationWarnings: List[(Position, String)] = deprecationWarnings0.warnings.toList var reportedFeature = Set[Symbol]() @@ -1275,7 +1295,7 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S // nothing to compile, but we should still report use of deprecated options if (sources.isEmpty) { - checkDeprecatedSettings(new CompilationUnit(new BatchSourceFile("<no file>", ""))) + checkDeprecatedSettings(newCompilationUnit("")) reportCompileErrors() return } @@ -1511,7 +1531,7 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S /** We resolve the class/object ambiguity by passing a type/term name. */ def showDef(fullName: Name, declsOnly: Boolean, ph: Phase) = { - val boringOwners = Set(definitions.AnyClass, definitions.AnyRefClass, definitions.ObjectClass) + val boringOwners = Set[Symbol](definitions.AnyClass, definitions.AnyRefClass, definitions.ObjectClass) def phased[T](body: => T): T = afterPhase(ph)(body) def boringMember(sym: Symbol) = boringOwners(sym.owner) def symString(sym: Symbol) = if (sym.isTerm) sym.defString else sym.toString @@ -1594,7 +1614,7 @@ object Global { * This allows the use of a custom Global subclass with the software which * wraps Globals, such as scalac, fsc, and the repl. */ - def fromSettings(settings: Settings, reporter: NscReporter): Global = { + def fromSettings(settings: Settings, reporter: Reporter): Global = { // !!! The classpath isn't known until the Global is created, which is too // late, so we have to duplicate it here. Classpath is too tightly coupled, // it is a construct external to the compiler and should be treated as such. @@ -1602,7 +1622,7 @@ object Global { val loader = ScalaClassLoader.fromURLs(new PathResolver(settings).result.asURLs, parentLoader) val name = settings.globalClass.value val clazz = Class.forName(name, true, loader) - val cons = clazz.getConstructor(classOf[Settings], classOf[NscReporter]) + val cons = clazz.getConstructor(classOf[Settings], classOf[Reporter]) cons.newInstance(settings, reporter).asInstanceOf[Global] } @@ -1610,7 +1630,7 @@ object Global { /** A global instantiated this way honors -Yglobal-class setting, and * falls back on calling the Global constructor directly. */ - def apply(settings: Settings, reporter: NscReporter): Global = { + def apply(settings: Settings, reporter: Reporter): Global = { val g = ( if (settings.globalClass.isDefault) null else try fromSettings(settings, reporter) catch { case x => diff --git a/src/compiler/scala/tools/nsc/Phases.scala b/src/compiler/scala/tools/nsc/Phases.scala index 1fa576afb6..aa0ea1bdd8 100644 --- a/src/compiler/scala/tools/nsc/Phases.scala +++ b/src/compiler/scala/tools/nsc/Phases.scala @@ -14,7 +14,7 @@ object Phases { /** A class for tracking something about each phase. */ - class Model[T: Manifest] { + class Model[T] { case class Cell(ph: Phase, value: T) { def name = ph.name def id = ph.id diff --git a/src/compiler/scala/tools/nsc/ToolBoxes.scala b/src/compiler/scala/tools/nsc/ToolBoxes.scala index eb298833b8..8bf977090b 100644 --- a/src/compiler/scala/tools/nsc/ToolBoxes.scala +++ b/src/compiler/scala/tools/nsc/ToolBoxes.scala @@ -4,11 +4,9 @@ import util.ScalaClassLoader trait ToolBoxes { self: Global => - import self.{Reporter => ApiReporter} + def mkToolBox(frontEnd: FrontEnd = mkSilentFrontEnd(), options: String = "") = new ToolBox(frontEnd, options) - def mkToolBox(reporter: ApiReporter = mkSilentReporter(), options: String = "") = new ToolBox(reporter, options) - - class ToolBox(val reporter: ApiReporter, val options: String) extends AbsToolBox { + class ToolBox(val frontEnd: FrontEnd, val options: String) extends AbsToolBox { def typeCheck(tree0: Tree, pt: Type = WildcardType, freeTypes: Map[FreeType, Type] = Map[FreeType, Type](), silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree = { val tree = substituteFreeTypes(tree0, freeTypes) val currentTyper = typer @@ -41,9 +39,10 @@ trait ToolBoxes { self: Global => def runExpr(tree0: Tree, freeTypes: Map[FreeType, Type] = Map[FreeType, Type]()): Any = { var tree = substituteFreeTypes(tree0, freeTypes) // need to reset the tree, otherwise toolbox will refuse to work with it - tree = resetAllAttrs(tree0.duplicate) + // upd. this has to be done by the user himself, otherwise we run into troubles. see SI-5713 +// tree = resetAllAttrs(tree0.duplicate) val imported = importer.importTree(tree) - val toolBox = libraryClasspathMirror.mkToolBox(reporter.asInstanceOf[libraryClasspathMirror.Reporter], options) + val toolBox = libraryClasspathMirror.mkToolBox(frontEnd.asInstanceOf[libraryClasspathMirror.FrontEnd], options) try toolBox.runExpr(imported) catch { case ex: toolBox.ToolBoxError => diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala index 8e7eeed3cc..b3ed446563 100755 --- a/src/compiler/scala/tools/nsc/ast/DocComments.scala +++ b/src/compiler/scala/tools/nsc/ast/DocComments.scala @@ -7,7 +7,7 @@ package scala.tools.nsc package ast import symtab._ -import reporters.{Reporter => NscReporter} +import reporters._ import util.{Position, NoPosition} import util.DocStrings._ import scala.reflect.internal.Chars._ @@ -21,8 +21,6 @@ trait DocComments { self: Global => var cookedDocComments = Map[Symbol, String]() - def reporter: NscReporter - /** The raw doc comment map */ val docComments = mutable.HashMap[Symbol, DocComment]() diff --git a/src/compiler/scala/tools/nsc/ast/FreeVars.scala b/src/compiler/scala/tools/nsc/ast/FreeVars.scala index 1bf36e8bf2..a1983d1834 100644 --- a/src/compiler/scala/tools/nsc/ast/FreeVars.scala +++ b/src/compiler/scala/tools/nsc/ast/FreeVars.scala @@ -13,9 +13,9 @@ trait FreeVars extends reflect.internal.FreeVars { self: Global => case Reified(_, symbolTable, _) => // logging free vars only when they are untyped prevents avalanches of duplicate messages symbolTable foreach { - case FreeTermDef(_, _, binding, origin) if settings.logFreeTerms.value && binding.tpe == null => + case FreeTermDef(_, _, binding, _, origin) if settings.logFreeTerms.value && binding.tpe == null => reporter.echo(position, "free term: %s %s".format(showRaw(binding), origin)) - case FreeTypeDef(_, _, binding, origin) if settings.logFreeTypes.value && binding.tpe == null => + case FreeTypeDef(_, _, binding, _, origin) if settings.logFreeTypes.value && binding.tpe == null => reporter.echo(position, "free type: %s %s".format(showRaw(binding), origin)) case _ => // do nothing diff --git a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala index 108c8fcbfa..5d849b9622 100644 --- a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala +++ b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala @@ -63,10 +63,14 @@ abstract class NodePrinters { } trait DefaultPrintAST extends PrintAST { + val printPos = settings.Xprintpos.value || settings.Yposdebug.value + + def showNameAndPos(tree: NameTree) = showPosition(tree) + showName(tree.name) def showDefTreeName(tree: DefTree) = showName(tree.name) + def showPosition(tree: Tree) = if (printPos) tree.pos.show else "" def showFlags(tree: MemberDef) = flagsToString(tree.symbol.flags | tree.mods.flags) - def showLiteral(lit: Literal) = lit.value.escapedStringValue - def showTypeTree(tt: TypeTree) = "<tpt>" + emptyOrComment(showType(tt)) + def showLiteral(lit: Literal) = showPosition(lit) + lit.value.escapedStringValue + def showTypeTree(tt: TypeTree) = showPosition(tt) + "<tpt>" + emptyOrComment(showType(tt)) def showName(name: Name) = name match { case nme.EMPTY | tpnme.EMPTY => "<empty>" case name => "\"" + name + "\"" @@ -97,17 +101,21 @@ abstract class NodePrinters { private var level = 0 def showName(name: Name): String + def showPosition(tree: Tree): String + def showNameAndPos(tree: NameTree): String def showDefTreeName(defTree: DefTree): String def showFlags(tree: MemberDef): String def showLiteral(lit: Literal): String def showTypeTree(tt: TypeTree): String def showAttributes(tree: Tree): String // symbol and type - def showRefTreeName(tree: Tree): String = tree match { - case SelectFromTypeTree(qual, name) => showRefTreeName(qual) + "#" + showName(name) - case Select(qual, name) => showRefTreeName(qual) + "." + showName(name) - case Ident(name) => showName(name) - case _ => "" + tree + def showRefTreeName(tree: Tree): String = { + tree match { + case SelectFromTypeTree(qual, name) => showRefTreeName(qual) + "#" + showName(name) + case Select(qual, name) => showRefTreeName(qual) + "." + showName(name) + case id @ Ident(name) => showNameAndPos(id) + case _ => "" + tree + } } def showRefTree(tree: RefTree): String = { def prefix0 = showRefTreeName(tree.qualifier) @@ -116,7 +124,7 @@ abstract class NodePrinters { case Select(_, _) => prefix0 + "." case _ => "" }) - prefix + showName(tree.name) + emptyOrComment(showAttributes(tree)) + prefix + showNameAndPos(tree) + emptyOrComment(showAttributes(tree)) } def emptyOrComment(s: String) = if (s == "") "" else " // " + s @@ -191,8 +199,9 @@ abstract class NodePrinters { } } + def treePrefix(tree: Tree) = showPosition(tree) + tree.printingPrefix def printMultiline(tree: Tree)(body: => Unit) { - printMultiline(tree.printingPrefix, showAttributes(tree))(body) + printMultiline(treePrefix(tree), showAttributes(tree))(body) } def printMultiline(prefix: String, comment: String)(body: => Unit) { printLine(prefix + "(", comment) @@ -218,10 +227,12 @@ abstract class NodePrinters { } def printSingle(tree: Tree, name: Name) { - println(tree.printingPrefix + "(" + showName(name) + ")" + showAttributes(tree)) + println(treePrefix(tree) + "(" + showName(name) + ")" + showAttributes(tree)) } def traverse(tree: Tree) { + showPosition(tree) + tree match { case AppliedTypeTree(tpt, args) => applyCommon(tree, tpt, args) case ApplyDynamic(fun, args) => applyCommon(tree, fun, args) @@ -230,6 +241,19 @@ abstract class NodePrinters { case Throw(Ident(name)) => printSingle(tree, name) + case b @ Bind(name, body) => + printMultiline(tree) { + println(showDefTreeName(b)) + traverse(body) + } + + case ld @ LabelDef(name, params, rhs) => + printMultiline(tree) { + showNameAndPos(ld) + traverseList("()", "params")(params) + traverse(rhs) + } + case Function(vparams, body) => printMultiline(tree) { traverseList("()", "parameter")(vparams) @@ -309,7 +333,7 @@ abstract class NodePrinters { val ps0 = parents map { p => if (p.tpe eq null) p match { case x: RefTree => showRefTree(x) - case x => "" + x + case x => showPosition(x) + x } else showName(newTypeName(p.tpe.typeSymbol.fullName)) } @@ -353,7 +377,7 @@ abstract class NodePrinters { case _ => tree match { case t: RefTree => println(showRefTree(t)) - case t if t.productArity == 0 => println(tree.printingPrefix) + case t if t.productArity == 0 => println(treePrefix(t)) case t => printMultiline(tree)(tree.productIterator foreach traverseAny) } } diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala index d3e64811d3..978d83616b 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala @@ -177,6 +177,22 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL { def mkSysErrorCall(message: String): Tree = mkMethodCall(Sys_error, List(Literal(Constant(message)))) + /** A creator for a call to a scala.reflect.Manifest or ClassManifest factory method. + * + * @param full full or partial manifest (target will be Manifest or ClassManifest) + * @param constructor name of the factory method (e.g. "classType") + * @param tparg the type argument + * @param args value arguments + * @return the tree + */ + def mkManifestFactoryCall(full: Boolean, constructor: String, tparg: Type, args: List[Tree]): Tree = + mkMethodCall( + if (full) FullManifestModule else PartialManifestModule, + newTermName(constructor), + List(tparg), + args + ) + /** Make a synchronized block on 'monitor'. */ def mkSynchronized(monitor: Tree, body: Tree): Tree = Apply(Select(monitor, Object_synchronized), List(body)) diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala index 04452c68e5..2bd1ba3fea 100644 --- a/src/compiler/scala/tools/nsc/ast/Trees.scala +++ b/src/compiler/scala/tools/nsc/ast/Trees.scala @@ -86,13 +86,12 @@ trait Trees extends reflect.internal.Trees { self: Global => /* Add constructor to template */ // create parameters for <init> as synthetic trees. - var vparamss1 = - vparamss map (vps => vps.map { vd => - atPos(vd.pos.focus) { - ValDef( - Modifiers(vd.mods.flags & (IMPLICIT | DEFAULTPARAM | BYNAMEPARAM) | PARAM | PARAMACCESSOR) withAnnotations vd.mods.annotations, - vd.name, vd.tpt.duplicate, vd.rhs.duplicate) - }}) + var vparamss1 = mmap(vparamss) { vd => + atPos(vd.pos.focus) { + val mods = Modifiers(vd.mods.flags & (IMPLICIT | DEFAULTPARAM | BYNAMEPARAM) | PARAM | PARAMACCESSOR) + ValDef(mods withAnnotations vd.mods.annotations, vd.name, vd.tpt.duplicate, vd.rhs.duplicate) + } + } val (edefs, rest) = body span treeInfo.isEarlyDef val (evdefs, etdefs) = edefs partition treeInfo.isEarlyValDef val gvdefs = evdefs map { @@ -143,11 +142,18 @@ trait Trees extends reflect.internal.Trees { self: Global => * @param body the template statements without primary constructor * and value parameter fields. */ - def ClassDef(sym: Symbol, constrMods: Modifiers, vparamss: List[List[ValDef]], argss: List[List[Tree]], body: List[Tree], superPos: Position): ClassDef = + def ClassDef(sym: Symbol, constrMods: Modifiers, vparamss: List[List[ValDef]], argss: List[List[Tree]], body: List[Tree], superPos: Position): ClassDef = { + // "if they have symbols they should be owned by `sym`" + assert( + mforall(vparamss)(p => (p.symbol eq NoSymbol) || (p.symbol.owner == sym)), + ((mmap(vparamss)(_.symbol), sym)) + ) + ClassDef(sym, Template(sym.info.parents map TypeTree, if (sym.thisSym == sym || phase.erasedTypes) emptyValDef else ValDef(sym.thisSym), constrMods, vparamss, argss, body, superPos)) + } // --- subcomponents -------------------------------------------------- diff --git a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala index 93fa9a60f6..f702f44338 100755 --- a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala @@ -397,7 +397,7 @@ trait MarkupParsers { /** xScalaPatterns ::= patterns */ - def xScalaPatterns: List[Tree] = escapeToScala(parser.seqPatterns(), "pattern") + def xScalaPatterns: List[Tree] = escapeToScala(parser.xmlSeqPatterns(), "pattern") def reportSyntaxError(pos: Int, str: String) = parser.syntaxError(pos, str) def reportSyntaxError(str: String) { diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index eb4deeeee2..337ca7671c 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -317,7 +317,7 @@ self => * by compilationUnit(). */ def scriptBody(): Tree = { - val stmts = templateStatSeq(false)._2 + val stmts = templateStats() accept(EOF) def mainModuleName = newTermName(settings.script.value) @@ -1705,11 +1705,11 @@ self => * was threaded through methods as boolean seqOK. */ trait SeqContextSensitive extends PatternContextSensitive { - /** Returns Some(tree) if it finds a star and prematurely ends parsing. - * This is an artifact of old implementation which has proven difficult - * to cleanly extract. - */ - def interceptStarPattern(top: Tree): Option[Tree] + // is a sequence pattern _* allowed? + def isSequenceOK: Boolean + + // are we in an XML pattern? + def isXML: Boolean = false def functionArgType(): Tree = argType() def argType(): Tree = { @@ -1796,45 +1796,98 @@ self => /** {{{ * Pattern3 ::= SimplePattern * | SimplePattern {Id [nl] SimplePattern} - * SeqPattern3 ::= SeqSimplePattern [ `*' | `?' | `+' ] - * | SeqSimplePattern {Id [nl] SeqSimplePattern} * }}} */ def pattern3(): Tree = { + var top = simplePattern(badPattern3) + // after peekahead + def acceptWildStar() = atPos(top.pos.startOrPoint, in.prev.offset)(Star(stripParens(top))) + def peekahead() = { + in.prev copyFrom in + in.nextToken() + } + def pushback() = { + in.next copyFrom in + in copyFrom in.prev + } + // See SI-3189, SI-4832 for motivation. Cf SI-3480 for counter-motivation. + // TODO: dredge out the remnants of regexp patterns. + // /{/ peek for _*) or _*} (for xml escape) + if (isSequenceOK) { + top match { + case Ident(nme.WILDCARD) if (isRawStar) => + peekahead() + in.token match { + case RBRACE if (isXML) => return acceptWildStar() + case RPAREN if (!isXML) => return acceptWildStar() + case _ => pushback() + } + case _ => + } + } val base = opstack - var top = simplePattern() - interceptStarPattern(top) foreach { x => return x } - while (isIdent && in.name != raw.BAR) { - top = reduceStack( - false, base, top, precedence(in.name), treeInfo.isLeftAssoc(in.name)) + top = reduceStack(false, base, top, precedence(in.name), treeInfo.isLeftAssoc(in.name)) val op = in.name opstack = OpInfo(top, op, in.offset) :: opstack ident() - top = simplePattern() + top = simplePattern(badPattern3) } stripParens(reduceStack(false, base, top, 0, true)) } + def badPattern3(): Tree = { + def isComma = in.token == COMMA + def isAnyBrace = in.token == RPAREN || in.token == RBRACE + val badStart = "illegal start of simple pattern" + // better recovery if don't skip delims of patterns + var skip = !(isComma || isAnyBrace) + val msg = if (!opstack.isEmpty && opstack.head.operator == nme.STAR) { + opstack.head.operand match { + case Ident(nme.WILDCARD) => + if (isSequenceOK && isComma) + "bad use of _* (a sequence pattern must be the last pattern)" + else if (isSequenceOK && isAnyBrace) { + skip = true // do skip bad paren; scanner may skip bad brace already + "bad brace or paren after _*" + } else if (!isSequenceOK && isAnyBrace) + "bad use of _* (sequence pattern not allowed)" + else badStart + case _ => + if (isSequenceOK && isAnyBrace) + "use _* to match a sequence" + else if (isComma || isAnyBrace) + "trailing * is not a valid pattern" + else badStart + } + } else { + badStart + } + syntaxErrorOrIncomplete(msg, skip) + errorPatternTree + } /** {{{ * SimplePattern ::= varid * | `_' * | literal * | XmlPattern - * | StableId [TypeArgs] [`(' [SeqPatterns] `)'] + * | StableId /[TypeArgs]/ [`(' [Patterns] `)'] + * | StableId [`(' [Patterns] `)'] + * | StableId [`(' [Patterns] `,' [varid `@'] `_' `*' `)'] * | `(' [Patterns] `)' - * SimpleSeqPattern ::= varid - * | `_' - * | literal - * | XmlPattern - * | `<' xLiteralPattern - * | StableId [TypeArgs] [`(' [SeqPatterns] `)'] - * | `(' [SeqPatterns] `)' * }}} * * XXX: Hook for IDE */ def simplePattern(): Tree = { + // simple diagnostics for this entry point + def badStart(): Tree = { + syntaxErrorOrIncomplete("illegal start of simple pattern", true) + errorPatternTree + } + simplePattern(badStart) + } + def simplePattern(onError: () => Tree): Tree = { val start = in.offset in.token match { case IDENTIFIER | BACKQUOTED_IDENT | THIS => @@ -1867,8 +1920,7 @@ self => case XMLSTART => xmlLiteralPattern() case _ => - syntaxErrorOrIncomplete("illegal start of simple pattern", true) - errorPatternTree + onError() } } } @@ -1879,16 +1931,16 @@ self => } /** The implementation for parsing inside of patterns at points where sequences are allowed. */ object seqOK extends SeqContextSensitive { - // See ticket #3189 for the motivation for the null check. - // TODO: dredge out the remnants of regexp patterns. - // ... and now this is back the way it was because it caused #3480. - def interceptStarPattern(top: Tree): Option[Tree] = - if (isRawStar) Some(atPos(top.pos.startOrPoint, in.skipToken())(Star(stripParens(top)))) - else None + val isSequenceOK = true } /** The implementation for parsing inside of patterns at points where sequences are disallowed. */ object noSeq extends SeqContextSensitive { - def interceptStarPattern(top: Tree) = None + val isSequenceOK = false + } + /** For use from xml pattern, where sequence is allowed and encouraged. */ + object xmlSeqOK extends SeqContextSensitive { + val isSequenceOK = true + override val isXML = true } /** These are default entry points into the pattern context sensitive methods: * they are all initiated from non-pattern context. @@ -1902,7 +1954,8 @@ self => /** Default entry points into some pattern contexts. */ def pattern(): Tree = noSeq.pattern() def patterns(): List[Tree] = noSeq.patterns() - def seqPatterns(): List[Tree] = seqOK.patterns() // Also called from xml parser + def seqPatterns(): List[Tree] = seqOK.patterns() + def xmlSeqPatterns(): List[Tree] = xmlSeqOK.patterns() // Called from xml parser def argumentPatterns(): List[Tree] = inParens { if (in.token == RPAREN) Nil else seqPatterns() @@ -2869,6 +2922,13 @@ self => stats.toList } + /** Informal - for the repl and other direct parser accessors. + */ + def templateStats(): List[Tree] = templateStatSeq(false)._2 match { + case Nil => List(EmptyTree) + case stats => stats + } + /** {{{ * TemplateStatSeq ::= [id [`:' Type] `=>'] TemplateStat {semi TemplateStat} * TemplateStat ::= Import diff --git a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala index 0f2a3e0395..b0204c5971 100755 --- a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala @@ -30,7 +30,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) { private[parser] var isPattern: Boolean = _ - private trait XMLTypeNames extends TypeNames { + private object xmltypes extends TypeNames { val _Comment: NameType = "Comment" val _Elem: NameType = "Elem" val _EntityRef: NameType = "EntityRef" @@ -45,7 +45,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) { val _UnprefixedAttribute: NameType = "UnprefixedAttribute" } - private trait XMLTermNames extends TermNames { + private object xmlterms extends TermNames { val _Null: NameType = "Null" val __Elem: NameType = "Elem" val __Text: NameType = "Text" @@ -57,15 +57,6 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) { val _xml: NameType = "xml" } - private object xmltypes extends XMLTypeNames { - type NameType = TypeName - implicit def createNameType(name: String): TypeName = newTypeNameCached(name) - } - private object xmlterms extends XMLTermNames { - type NameType = TermName - implicit def createNameType(name: String): TermName = newTermNameCached(name) - } - import xmltypes.{_Comment, _Elem, _EntityRef, _Group, _MetaData, _NamespaceBinding, _NodeBuffer, _PrefixedAttribute, _ProcInstr, _Text, _Unparsed, _UnprefixedAttribute} diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index 3a6e26d3b5..de7e6f9c7a 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -521,11 +521,29 @@ abstract class TreeBuilder { // val/var x_1 = t$._1 // ... // val/var x_N = t$._N - val pat1 = patvarTransformer.transform(pat) + + val rhsUnchecked = gen.mkUnchecked(rhs) + + // TODO: clean this up -- there is too much information packked into makePatDef's `pat` argument + // when it's a simple identifier (case Some((name, tpt)) -- above), + // pat should have the type ascription that was specified by the user + // however, in `case None` (here), we must be careful not to generate illegal pattern trees (such as `(a, b): Tuple2[Int, String]`) + // i.e., this must hold: pat1 match { case Typed(expr, tp) => assert(expr.isInstanceOf[Ident]) case _ => } + // if we encounter such an erroneous pattern, we strip off the type ascription from pat and propagate the type information to rhs + val (pat1, rhs1) = patvarTransformer.transform(pat) match { + // move the Typed ascription to the rhs + case Typed(expr, tpt) if !expr.isInstanceOf[Ident] => + val rhsTypedUnchecked = + if (tpt.isEmpty) rhsUnchecked + else Typed(rhsUnchecked, tpt) setPos (rhs.pos union tpt.pos) + (expr, rhsTypedUnchecked) + case ok => + (ok, rhsUnchecked) + } val vars = getVariables(pat1) val matchExpr = atPos((pat1.pos union rhs.pos).makeTransparent) { Match( - gen.mkUnchecked(rhs), + rhs1, List( atPos(pat1.pos) { CaseDef(pat1, EmptyTree, makeTupleTerm(vars map (_._1) map Ident, true)) diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index ff58de5f12..5e5b09405c 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -2225,7 +2225,7 @@ abstract class GenICode extends SubComponent { * jumps to the given basic block. */ def patch(code: Code) { - val map = toPatch map (i => (i -> patch(i))) toMap; + val map = mapFrom(toPatch)(patch) code.blocks foreach (_ subst map) } diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala index f61f78ebb2..1ec2cf017a 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala @@ -420,7 +420,7 @@ trait TypeKinds { self: ICodes => // between "object PackratParsers$class" and "trait PackratParsers" if (sym.isImplClass) { // pos/spec-List.scala is the sole failure if we don't check for NoSymbol - val traitSym = sym.owner.info.decl(nme.interfaceName(sym.name)) + val traitSym = sym.owner.info.decl(tpnme.interfaceName(sym.name)) if (traitSym != NoSymbol) return REFERENCE(traitSym) } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index f7898f2aa2..aace545ea5 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -1324,7 +1324,6 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with val lastInstr = b.lastInstruction for (instr <- b) { - instr match { case THIS(clasz) => jcode.emitALOAD_0() diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala index cf51a5b926..05d8c632c0 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala @@ -135,7 +135,7 @@ abstract class Inliners extends SubComponent { /** The current iclass */ private var currentIClazz: IClass = _ - private def warn(pos: Position, msg: String) = currentIClazz.cunit.warning(pos, msg) + private def warn(pos: Position, msg: String) = currentIClazz.cunit.inlinerWarning(pos, msg) val recentTFAs = mutable.Map.empty[Symbol, Tuple2[Boolean, analysis.MethodTFA]] private def getRecentTFA(incm: IMethod): (Boolean, analysis.MethodTFA) = { @@ -759,12 +759,16 @@ abstract class Inliners extends SubComponent { private def helperIsSafeToInline(stackLength: Int): Boolean = { def makePublic(f: Symbol): Boolean = - (inc.m.sourceFile ne NoSourceFile) && (f.isSynthetic || f.isParamAccessor) && { - debuglog("Making not-private symbol out of synthetic: " + f) - - f setNotFlag Flags.PRIVATE - true - } + /* + * Completely disabling member publifying. This shouldn't have been done in the first place. :| + */ + false + // (inc.m.sourceFile ne NoSourceFile) && (f.isSynthetic || f.isParamAccessor) && { + // debuglog("Making not-private symbol out of synthetic: " + f) + + // f setNotFlag Flags.PRIVATE + // true + // } if (!inc.m.hasCode || inc.isRecursive) { return false } if (inc.m.symbol.hasFlag(Flags.SYNCHRONIZED)) { return false } diff --git a/src/compiler/scala/tools/nsc/doc/Settings.scala b/src/compiler/scala/tools/nsc/doc/Settings.scala index 17bfb7d21d..d3a1d47de8 100644 --- a/src/compiler/scala/tools/nsc/doc/Settings.scala +++ b/src/compiler/scala/tools/nsc/doc/Settings.scala @@ -150,12 +150,15 @@ class Settings(error: String => Unit) extends scala.tools.nsc.Settings(error) { * the function result should be a humanly-understandable description of the type class */ val knownTypeClasses: Map[String, String => String] = Map() + - ("<root>.scala.package.Numeric" -> ((tparam: String) => tparam + " is a numeric class, such as Int, Long, Float or Double")) + - ("<root>.scala.package.Integral" -> ((tparam: String) => tparam + " is an integral numeric class, such as Int or Long")) + - ("<root>.scala.package.Fractional" -> ((tparam: String) => tparam + " is a fractional numeric class, such as Float or Double")) + - ("<root>.scala.reflect.Manifest" -> ((tparam: String) => tparam + " is accompanied by a Manifest, which is a runtime representation of its type that survives erasure")) + - ("<root>.scala.reflect.ClassManifest" -> ((tparam: String) => tparam + " is accompanied by a ClassManifest, which is a runtime representation of its type that survives erasure")) + - ("<root>.scala.reflect.OptManifest" -> ((tparam: String) => tparam + " is accompanied by an OptManifest, which can be either a runtime representation of its type or the NoManifest, which means the runtime type is not available")) + ("<root>.scala.package.Numeric" -> ((tparam: String) => tparam + " is a numeric class, such as Int, Long, Float or Double")) + + ("<root>.scala.package.Integral" -> ((tparam: String) => tparam + " is an integral numeric class, such as Int or Long")) + + ("<root>.scala.package.Fractional" -> ((tparam: String) => tparam + " is a fractional numeric class, such as Float or Double")) + + ("<root>.scala.reflect.Manifest" -> ((tparam: String) => tparam + " is accompanied by a Manifest, which is a runtime representation of its type that survives erasure")) + + ("<root>.scala.reflect.ClassManifest" -> ((tparam: String) => tparam + " is accompanied by a ClassManifest, which is a runtime representation of its type that survives erasure")) + + ("<root>.scala.reflect.OptManifest" -> ((tparam: String) => tparam + " is accompanied by an OptManifest, which can be either a runtime representation of its type or the NoManifest, which means the runtime type is not available")) + + ("<root>.scala.reflect.ClassTag" -> ((tparam: String) => tparam + " is accompanied by a ClassTag, which is a runtime representation of its type that survives erasure")) + + ("<root>.scala.reflect.TypeTag" -> ((tparam: String) => tparam + " is accompanied by a TypeTag, which is a runtime representation of its type that survives erasure")) + + ("<root>.scala.reflect.ConcreteTypeTag" -> ((tparam: String) => tparam + " is accompanied by an ConcreteTypeTag, which is a runtime representation of a concrete type that survives erasure")) /** * Set of classes to exclude from index and diagrams diff --git a/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala b/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala index f67abc58da..3ff973ec66 100644 --- a/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala +++ b/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala @@ -41,13 +41,13 @@ private[html] object SyntaxHigh { /** Standard library classes/objects, sorted alphabetically */ val standards = Array ( "Any", "AnyRef", "AnyVal", "App", "Application", "Array", - "Boolean", "Byte", "Char", "Class", "Console", "Double", - "Enumeration", "Float", "Function", "Int", + "Boolean", "Byte", "Char", "Class", "ClassTag", "ClassManifest", "ConcreteTypeTag", + "Console", "Double", "Enumeration", "Float", "Function", "Int", "List", "Long", "Manifest", "Map", - "None", "Nothing", "Null", "Object", "Option", + "NoManifest", "None", "Nothing", "Null", "Object", "Option", "OptManifest", "Pair", "Predef", "Seq", "Set", "Short", "Some", "String", "Symbol", - "Triple", "Unit") + "Triple", "TypeTag", "Unit") def apply(data: String): NodeSeq = { val buf = data.getBytes diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala index 124a7509e8..a6728654cd 100644 --- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala @@ -42,7 +42,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { memberSym.isOmittablePrefix || (closestPackage(memberSym) == closestPackage(templateSym)) } - private lazy val noSubclassCache = Set(AnyClass, AnyRefClass, ObjectClass) + private lazy val noSubclassCache = Set[Symbol](AnyClass, AnyRefClass, ObjectClass) /** */ def makeModel: Option[Universe] = { @@ -675,7 +675,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { } /* Refined types */ case RefinedType(parents, defs) => - val ignoreParents = Set(AnyClass, ObjectClass) + val ignoreParents = Set[Symbol](AnyClass, ObjectClass) val filtParents = parents filterNot (x => ignoreParents(x.typeSymbol)) match { case Nil => parents case ps => ps diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala index 0e44933ac6..61f3670f5f 100644 --- a/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala +++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala @@ -137,7 +137,7 @@ trait ModelFactoryImplicitSupport { // Members inherited by implicit conversions cannot override actual members memberSyms = memberSyms.filterNot((sym1: Symbol) => - existingMembers.exists(sym2 => sym1.name == sym2.name && + existingMembers.exists(sym2 => sym1.name == sym2.name && !isDistinguishableFrom(toType.memberInfo(sym1), sym.info.memberInfo(sym2)))) debug(" -> full type: " + toType) @@ -199,12 +199,12 @@ trait ModelFactoryImplicitSupport { * What? in details: * - say we start from a class A[T1, T2, T3, T4] * - we have an implicit function (view) in scope: - * def pimpA[T3 <: Long, T4](a: A[Int, Foo[Bar[X]], T3, T4])(implicit ev1: Manifest[T4], ev2: Numeric[T4]): PimpedA + * def pimpA[T3 <: Long, T4](a: A[Int, Foo[Bar[X]], T3, T4])(implicit ev1: TypeTag[T4], ev2: Numeric[T4]): PimpedA * - A is converted to PimpedA ONLY if a couple of constraints are satisfied: * * T1 must be equal to Int * * T2 must be equal to Foo[Bar[X]] * * T3 must be upper bounded by Long - * * there must be evidence of Numeric[T4] and a Mainfest[T4] within scope + * * there must be evidence of Numeric[T4] and a TypeTag[T4] within scope * - the final type is PimpedA and A therefore inherits a couple of members from pimpedA * * How? @@ -246,6 +246,7 @@ trait ModelFactoryImplicitSupport { val appliedTree = new ApplyImplicitView(viewTree, List(Ident("<argument>") setType viewTree.tpe.paramTypes.head)) val appliedTreeTyped: Tree = { val newContext = context.makeImplicit(context.ambiguousErrors) + newContext.macrosEnabled = false // [Eugene] I assume you want macro signature, not macro expansion val newTyper = global.analyzer.newTyper(newContext) newTyper.silent(_.typed(appliedTree, global.analyzer.EXPRmode, WildcardType), false) match { @@ -503,14 +504,14 @@ trait ModelFactoryImplicitSupport { * class. We suppose the name of the two members coincides * * The trick here is that the resultType does not matter - the condition for removal it that paramss have the same - * structure (A => B => C may not override (A, B) => C) and that all the types involved are + * structure (A => B => C may not override (A, B) => C) and that all the types involved are * of the implcit conversion's member are subtypes of the parent members' parameters */ - def isDistinguishableFrom(t1: Type, t2: Type): Boolean = + def isDistinguishableFrom(t1: Type, t2: Type): Boolean = if (t1.paramss.map(_.length) == t2.paramss.map(_.length)) { for ((t1p, t2p) <- t1.paramss.flatten zip t2.paramss.flatten) if (!isSubType(t1 memberInfo t1p, t2 memberInfo t2p)) - return true // if on the corresponding parameter you give a type that is in t1 but not in t2 - // example: + return true // if on the corresponding parameter you give a type that is in t1 but not in t2 + // example: // def foo(a: Either[Int, Double]): Int = 3 // def foo(b: Left[T1]): Int = 6 // a.foo(Right(4.5d)) prints out 3 :) diff --git a/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala b/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala index 99541ff4b4..d6102734ab 100644 --- a/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala +++ b/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala @@ -17,15 +17,11 @@ private[tests] trait CoreTestDefs extends PresentationCompilerTestDef with AskCompletionAt { - object MemberPrinter { - def apply(member: compiler.Member): String = - "`" + (member.sym.toString() + member.tpe.toString()).trim() + "`" - } - - protected val marker = CompletionMarker + def memberPrinter(member: compiler.Member): String = + "[accessible: %5s] ".format(member.accessible) + "`" + (member.sym.toString() + member.tpe.toString()).trim() + "`" override def runTest() { - askAllSources(marker) { pos => + askAllSources(CompletionMarker) { pos => askCompletionAt(pos) } { (pos, members) => withResponseDelimiter { @@ -35,7 +31,7 @@ private[tests] trait CoreTestDefs reporter.println("retrieved %d members".format(members.size)) compiler ask { () => val filtered = members.filterNot(member => member.sym.name.toString == "getClass" || member.sym.isConstructor) - reporter.println(filtered.map(MemberPrinter(_)).sortBy(_.toString()).mkString("\n")) + reporter.println(filtered.map(memberPrinter).sortBy(_.toString()).mkString("\n")) } } } @@ -48,10 +44,8 @@ private[tests] trait CoreTestDefs extends PresentationCompilerTestDef with AskTypeAt { - protected val marker = TypeMarker - override def runTest() { - askAllSources(marker) { pos => + askAllSources(TypeMarker) { pos => askTypeAt(pos) } { (pos, tree) => withResponseDelimiter { @@ -69,10 +63,8 @@ private[tests] trait CoreTestDefs with AskTypeAt with AskCompletionAt { - protected val marker = HyperlinkMarker - override def runTest() { - askAllSources(marker) { pos => + askAllSources(HyperlinkMarker) { pos => askTypeAt(pos)(NullReporter) } { (pos, tree) => if(tree.symbol == compiler.NoSymbol) { @@ -90,8 +82,9 @@ private[tests] trait CoreTestDefs compiler.askLinkPos(tree.symbol, source, r) r.get match { case Left(pos) => + val resolvedPos = if (tree.symbol.pos.isDefined) tree.symbol.pos else pos withResponseDelimiter { - reporter.println("[response] found askHyperlinkPos for `" + tree.symbol.name + "` at " + format(pos) + " " + tree.symbol.sourceFile.name) + reporter.println("[response] found askHyperlinkPos for `" + tree.symbol.name + "` at " + format(resolvedPos) + " " + tree.symbol.sourceFile.name) } case Right(ex) => ex.printStackTrace() diff --git a/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala b/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala index 390363eca8..8b8be697cc 100644 --- a/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala +++ b/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala @@ -5,10 +5,6 @@ import scala.tools.nsc.util.Position trait PresentationCompilerTestDef { - def compiler: Global - - protected val marker: TestMarker - private[tests] def runTest(): Unit protected def withResponseDelimiter(block: => Unit)(implicit reporter: Reporter) { diff --git a/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala b/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala index 42a47896a2..453b106808 100644 --- a/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala +++ b/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala @@ -17,9 +17,7 @@ import scala.util.control.ControlThrowable trait CodeHandlers[T] { self => - // Expressions are composed of operators and operands. - def expr(code: String): T - +/* // A declaration introduces names and assigns them types. // It can form part of a class definition (§5.1) or of a refinement in a compound type (§3.2.7). // (Ed: aka abstract members.) @@ -34,6 +32,10 @@ trait CodeHandlers[T] { // ‘val’ PatDef | ‘var’ VarDef | ‘def’ FunDef | ‘type’ {nl} TypeDef | // [‘case’] ‘class’ ClassDef | [‘case’] ‘object’ ObjectDef | ‘trait’ TraitDef def defn(code: String): T +*/ + + // Expressions are composed of operators and operands. + def expr(code: String): T // An import clause has the form import p.I where p is a stable identifier (§3.1) and I is an import expression. def impt(code: String): T @@ -52,9 +54,9 @@ trait CodeHandlers[T] { case _: NoSuccess => Nil } + // def decl(code: String) = try Some(self.decl(code)) catch handler + // def defn(code: String) = try Some(self.defn(code)) catch handler def expr(code: String) = try Some(self.expr(code)) catch handler - def decl(code: String) = try Some(self.decl(code)) catch handler - def defn(code: String) = try Some(self.defn(code)) catch handler def impt(code: String) = try Some(self.impt(code)) catch handler def stmt(code: String) = try Some(self.stmt(code)) catch handler def stmts(code: String) = try (self.stmts(code) map (x => Some(x))) catch handlerSeq diff --git a/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala b/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala index a2ce8439de..0cd918b6a5 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala @@ -22,8 +22,7 @@ trait ExprTyper { object codeParser extends { val global: repl.global.type = repl.global } with CodeHandlers[Tree] { def applyRule[T](code: String, rule: UnitParser => T): T = { reporter.reset() - val unit = new CompilationUnit(new BatchSourceFile("<console>", code)) - val scanner = new UnitParser(unit) + val scanner = newUnitParser(code) val result = rule(scanner) if (!reporter.hasErrors) @@ -33,23 +32,17 @@ trait ExprTyper { } def tokens(code: String) = { reporter.reset() - val unit = new CompilationUnit(new BatchSourceFile("<tokens>", code)) - val in = new UnitScanner(unit) + val in = newUnitScanner(code) in.init() - new Tokenizer(in) tokenIterator } - def decl(code: String) = CodeHandlers.fail("todo") - def defn(code: String) = CodeHandlers.fail("todo") + def defns(code: String) = stmts(code) collect { case x: DefTree => x } def expr(code: String) = applyRule(code, _.expr()) def impt(code: String) = applyRule(code, _.importExpr()) def impts(code: String) = applyRule(code, _.importClause()) - def stmts(code: String) = applyRule(code, _.templateStatSeq(false)._2) - def stmt(code: String) = stmts(code) match { - case List(t) => t - case xs => CodeHandlers.fail("Not a single statement: " + xs.mkString(", ")) - } + def stmts(code: String) = applyRule(code, _.templateStats()) + def stmt(code: String) = stmts(code).last // guaranteed nonempty } /** Parse a line into a sequence of trees. Returns None if the input is incomplete. */ @@ -62,77 +55,69 @@ trait ExprTyper { else Some(trees) } } - def tokens(line: String) = beQuietDuring(codeParser.tokens(line)) + // def parsesAsExpr(line: String) = { + // import codeParser._ + // (opt expr line).isDefined + // } - // TODO: integrate these into a CodeHandler[Type]. + def symbolOfLine(code: String): Symbol = { + def asExpr(): Symbol = { + val name = freshInternalVarName() + // Typing it with a lazy val would give us the right type, but runs + // into compiler bugs with things like existentials, so we compile it + // behind a def and strip the NullaryMethodType which wraps the expr. + val line = "def " + name + " = {\n" + code + "\n}" + + interpretSynthetic(line) match { + case IR.Success => + val sym0 = symbolOfTerm(name) + // drop NullaryMethodType + val sym = sym0.cloneSymbol setInfo afterTyper(sym0.info.finalResultType) + if (sym.info.typeSymbol eq UnitClass) NoSymbol + else sym + case _ => NoSymbol + } + } + def asDefn(): Symbol = { + val old = repl.definedSymbolList.toSet + + interpretSynthetic(code) match { + case IR.Success => + repl.definedSymbolList filterNot old match { + case Nil => NoSymbol + case sym :: Nil => sym + case syms => NoSymbol.newOverloaded(NoPrefix, syms) + } + case _ => NoSymbol + } + } + beQuietDuring(asExpr()) orElse beQuietDuring(asDefn()) + } - // XXX literals. - // 1) Identifiers defined in the repl. - // 2) A path loadable via getModule. - // 3) Try interpreting it as an expression. private var typeOfExpressionDepth = 0 def typeOfExpression(expr: String, silent: Boolean = true): Type = { - repltrace("typeOfExpression(" + expr + ")") if (typeOfExpressionDepth > 2) { repldbg("Terminating typeOfExpression recursion for expression: " + expr) return NoType } - - def asQualifiedImport: Type = { - val name = expr.takeWhile(_ != '.') - typeOfExpression(importedTermNamed(name).fullName + expr.drop(name.length), true) - } - def asModule: Type = getModuleIfDefined(expr).tpe - def asExpr: Type = { - val lhs = freshInternalVarName() - val line = "lazy val " + lhs + " =\n" + expr - - interpret(line, true) match { - case IR.Success => typeOfExpression(lhs, true) - case _ => NoType - } - } - - def evaluate(): Type = { - typeOfExpressionDepth += 1 - try typeOfTerm(expr) orElse asModule orElse asExpr orElse asQualifiedImport - finally typeOfExpressionDepth -= 1 - } - + typeOfExpressionDepth += 1 // Don't presently have a good way to suppress undesirable success output // while letting errors through, so it is first trying it silently: if there // is an error, and errors are desired, then it re-evaluates non-silently // to induce the error message. - beSilentDuring(evaluate()) orElse beSilentDuring(typeOfDeclaration(expr)) orElse { - if (!silent) - evaluate() - - NoType + try beSilentDuring(symbolOfLine(expr).tpe) match { + case NoType if !silent => symbolOfLine(expr).tpe // generate error + case tpe => tpe } + finally typeOfExpressionDepth -= 1 } - // Since people will be giving us ":t def foo = 5" even though that is not an - // expression, we have a means of typing declarations too. - private def typeOfDeclaration(code: String): Type = { - repltrace("typeOfDeclaration(" + code + ")") - val obname = freshInternalVarName() - interpret("object " + obname + " {\n" + code + "\n}\n", true) match { - case IR.Success => - val sym = symbolOfTerm(obname) - if (sym == NoSymbol) NoType else { - // TODO: bitmap$n is not marked synthetic. - val decls = sym.tpe.decls.toList filterNot (x => x.isConstructor || x.isPrivate || (x.name.toString contains "$")) - repltrace("decls: " + decls) - if (decls.isEmpty) NoType - else cleanMemberDecl(sym, decls.last.name) - } - case _ => - NoType - } - } + def tokens(line: String) = beQuietDuring(codeParser.tokens(line)) + + // In the todo column + // // def compileAndTypeExpr(expr: String): Option[Typer] = { // class TyperRun extends Run { // override def stopPhase(name: String) = name == "superaccessors" // } - // } } diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala index bf386d8a12..297d6ad1b9 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala @@ -49,12 +49,60 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) var settings: Settings = _ var intp: IMain = _ - override def echoCommandMessage(msg: String): Unit = - intp.reporter.printMessage(msg) + /** Having inherited the difficult "var-ness" of the repl instance, + * I'm trying to work around it by moving operations into a class from + * which it will appear a stable prefix. + */ + private def onIntp[T](f: IMain => T): T = f(intp) + + class IMainOps[T <: IMain](val intp: T) { + import intp._ + import global._ + + def printAfterTyper(msg: => String) = + intp.reporter printUntruncatedMessage afterTyper(msg) + + /** Strip NullaryMethodType artifacts. */ + private def replInfo(sym: Symbol) = { + sym.info match { + case NullaryMethodType(restpe) if sym.isAccessor => restpe + case info => info + } + } + def echoTypeStructure(sym: Symbol) = + printAfterTyper("" + deconstruct.show(replInfo(sym))) + + def echoTypeSignature(sym: Symbol, verbose: Boolean) = { + if (verbose) ILoop.this.echo("// Type signature") + printAfterTyper("" + replInfo(sym)) + + if (verbose) { + ILoop.this.echo("\n// Internal Type structure") + echoTypeStructure(sym) + } + } + } + implicit def stabilizeIMain(intp: IMain) = new IMainOps[intp.type](intp) + + /** TODO - + * -n normalize + * -l label with case class parameter names + * -c complete - leave nothing out + */ + private def typeCommandInternal(expr: String, verbose: Boolean): Result = { + onIntp { intp => + val sym = intp.symbolOfLine(expr) + if (sym.exists) intp.echoTypeSignature(sym, verbose) + else "" + } + } + + override def echoCommandMessage(msg: String) { + intp.reporter printUntruncatedMessage msg + } def isAsync = !settings.Yreplsync.value lazy val power = new Power(intp, new StdReplVals(this)) - lazy val NoType = intp.global.NoType // TODO // object opt extends AestheticSettings @@ -249,7 +297,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) // nullary("reset", "reset the interpreter, forgetting session values but retaining session types", replay), shCommand, nullary("silent", "disable/enable automatic printing of results", verbosity), - cmd("type", "<expr>", "display the type of an expression without evaluating it", typeCommand), + cmd("type", "[-v] <expr>", "display the type of an expression without evaluating it", typeCommand), nullary("warnings", "show the suppressed warnings from the most recent line which had any", warningsCommand) ) @@ -322,10 +370,9 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } } - private def implicitsCommand(line: String): Result = { - val intp = ILoop.this.intp + private def implicitsCommand(line: String): Result = onIntp { intp => import intp._ - import global.{ Symbol, afterTyper } + import global._ def p(x: Any) = intp.reporter.printMessage("" + x) @@ -436,14 +483,14 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) private lazy val javap = substituteAndLog[Javap]("javap", NoJavap)(newJavap()) // Still todo: modules. - private def typeCommand(line: String): Result = { - if (line.trim == "") ":type <expression>" - else { - val tp = intp.typeOfExpression(line, false) - if (tp == NoType) "" // the error message was already printed - else intp.global.afterTyper(tp.toString) + private def typeCommand(line0: String): Result = { + line0.trim match { + case "" => ":type [-v] <expression>" + case s if s startsWith "-v " => typeCommandInternal(s stripPrefix "-v " trim, true) + case s => typeCommandInternal(s, false) } } + private def warningsCommand(): Result = { intp.lastWarnings foreach { case (pos, msg) => intp.reporter.warning(pos, msg) } } @@ -471,33 +518,34 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } private def wrapCommand(line: String): Result = { def failMsg = "Argument to :wrap must be the name of a method with signature [T](=> T): T" - val intp = ILoop.this.intp - val g: intp.global.type = intp.global - import g._ - - words(line) match { - case Nil => - intp.executionWrapper match { - case "" => "No execution wrapper is set." - case s => "Current execution wrapper: " + s - } - case "clear" :: Nil => - intp.executionWrapper match { - case "" => "No execution wrapper is set." - case s => intp.clearExecutionWrapper() ; "Cleared execution wrapper." - } - case wrapper :: Nil => - intp.typeOfExpression(wrapper) match { - case PolyType(List(targ), MethodType(List(arg), restpe)) => - intp setExecutionWrapper intp.pathToTerm(wrapper) - "Set wrapper to '" + wrapper + "'" - case tp => - failMsg + ( - if (tp == g.NoType) "\nFound: <unknown>" - else "\nFound: <unknown>" - ) - } - case _ => failMsg + onIntp { intp => + import intp._ + import global._ + + words(line) match { + case Nil => + intp.executionWrapper match { + case "" => "No execution wrapper is set." + case s => "Current execution wrapper: " + s + } + case "clear" :: Nil => + intp.executionWrapper match { + case "" => "No execution wrapper is set." + case s => intp.clearExecutionWrapper() ; "Cleared execution wrapper." + } + case wrapper :: Nil => + intp.typeOfExpression(wrapper) match { + case PolyType(List(targ), MethodType(List(arg), restpe)) => + intp setExecutionWrapper intp.pathToTerm(wrapper) + "Set wrapper to '" + wrapper + "'" + case tp => + failMsg + ( + if (tp == NoType) "\nFound: <unknown>" + else "\nFound: <unknown>" + ) + } + case _ => failMsg + } } } @@ -798,6 +846,10 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) }) } + def runCompletion = + try in.completion execute code map (intp bindSyntheticValue _) + catch { case ex: Exception => None } + /** Here we place ourselves between the user and the interpreter and examine * the input they are ostensibly submitting. We intervene in several cases: * @@ -815,30 +867,28 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) else if (Completion.looksLikeInvocation(code) && intp.mostRecentVar != "") { interpretStartingWith(intp.mostRecentVar + code) } - else { - def runCompletion = - try in.completion execute code map (intp bindValue _) - catch { case ex: Exception => None } - - /** Due to my accidentally letting file completion execution sneak ahead - * of actual parsing this now operates in such a way that the scala - * interpretation always wins. However to avoid losing useful file - * completion I let it fail and then check the others. So if you - * type /tmp it will echo a failure and then give you a Directory object. - * It's not pretty: maybe I'll implement the silence bits I need to avoid - * echoing the failure. - */ - if (intp isParseable code) { - val (code, result) = reallyInterpret - if (power != null && code == IR.Error) - runCompletion - - result - } - else runCompletion match { - case Some(_) => None // completion hit: avoid the latent error - case _ => reallyInterpret._2 // trigger the latent error - } + else if (code.trim startsWith "//") { + // line comment, do nothing + None + } + /** Due to my accidentally letting file completion execution sneak ahead + * of actual parsing this now operates in such a way that the scala + * interpretation always wins. However to avoid losing useful file + * completion I let it fail and then check the others. So if you + * type /tmp it will echo a failure and then give you a Directory object. + * It's not pretty: maybe I'll implement the silence bits I need to avoid + * echoing the failure. + */ + else if (intp isParseable code) { + val (code, result) = reallyInterpret + if (power != null && code == IR.Error) + runCompletion + + result + } + else runCompletion match { + case Some(_) => None // completion hit: avoid the latent error + case _ => reallyInterpret._2 // trigger the latent error } } @@ -1003,11 +1053,11 @@ object ILoop { // provide the enclosing type T // in order to set up the interpreter's classpath and parent class loader properly - def breakIf[T: Manifest](assertion: => Boolean, args: NamedParam*): Unit = + def breakIf[T: ClassTag](assertion: => Boolean, args: NamedParam*): Unit = if (assertion) break[T](args.toList) // start a repl, binding supplied args - def break[T: Manifest](args: List[NamedParam]): Unit = savingContextLoader { + def break[T: ClassTag](args: List[NamedParam]): Unit = savingContextLoader { val msg = if (args.isEmpty) "" else " Binding " + args.size + " value%s.".format( if (args.size == 1) "" else "s" ) diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoopInit.scala b/src/compiler/scala/tools/nsc/interpreter/ILoopInit.scala index 2f02748e8f..6a9654732b 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ILoopInit.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ILoopInit.scala @@ -100,7 +100,7 @@ trait ILoopInit { withLock { while (!initIsComplete) initLoopCondition.await() } } // private def warningsThunks = List( - // () => intp.bind("lastWarnings", "" + manifest[List[(Position, String)]], intp.lastWarnings _), + // () => intp.bind("lastWarnings", "" + typeTag[List[(Position, String)]], intp.lastWarnings _), // ) protected def postInitThunks = List[Option[() => Unit]]( diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala index 43e01bebfd..a9c2ce0d09 100644 --- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala +++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala @@ -13,7 +13,6 @@ import scala.sys.BooleanProp import io.VirtualDirectory import scala.tools.nsc.io.AbstractFile import reporters._ -import reporters.{Reporter => NscReporter} import symtab.Flags import scala.reflect.internal.Names import scala.tools.util.PathResolver @@ -24,6 +23,7 @@ import scala.collection.{ mutable, immutable } import scala.util.control.Exception.{ ultimately } import IMain._ import java.util.concurrent.Future +import typechecker.Analyzer import language.implicitConversions /** directory to save .class files to */ @@ -140,7 +140,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends lazy val formatting: Formatting = new Formatting { val prompt = Properties.shellPromptString } - lazy val reporter: ConsoleReporter = new ReplReporter(this) + lazy val reporter: ReplReporter = new ReplReporter(this) import formatting._ import reporter.{ printMessage, withoutTruncating } @@ -156,6 +156,8 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends } catch AbstractOrMissingHandler() } + private def tquoted(s: String) = "\"\"\"" + s + "\"\"\"" + // argument is a thunk to execute after init is done def initialize(postInitSignal: => Unit) { synchronized { @@ -194,8 +196,9 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends import global._ import definitions.{ - ScalaPackage, JavaLangPackage, PredefModule, RootClass, - getClassIfDefined, getModuleIfDefined, getRequiredModule, getRequiredClass + ScalaPackage, JavaLangPackage, RootClass, + getClassIfDefined, getModuleIfDefined, getRequiredModule, getRequiredClass, + termMember, typeMember } private implicit def privateTreeOps(t: Tree): List[Tree] = { @@ -226,6 +229,10 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends } import naming._ + object deconstruct extends { + val global: imain.global.type = imain.global + } with StructuredTypeStrings + // object dossiers extends { // val intp: imain.type = imain // } with Dossiers { } @@ -275,11 +282,10 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends protected def createLineManager(classLoader: ClassLoader): Line.Manager = new Line.Manager(classLoader) /** Instantiate a compiler. Overridable. */ - protected def newCompiler(settings: Settings, reporter: NscReporter) = { + protected def newCompiler(settings: Settings, reporter: Reporter): ReplGlobal = { settings.outputDirs setSingleOutput virtualDirectory settings.exposeEmptyPackage.value = true - - Global(settings, reporter) + new Global(settings, reporter) with ReplGlobal } /** Parent classloader. Overridable. */ @@ -345,7 +351,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends classLoader.setAsContext() // this is risky, but it's our only possibility to make default reflexive mirror to work with REPL - // so far we have only used the default mirror to create a few manifests for the compiler + // so far we have only used the default mirror to create a few tags for the compiler // so it shouldn't be in conflict with our classloader, especially since it respects its parent scala.reflect.mirror.classLoader = classLoader } @@ -363,7 +369,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends def flatName(id: String) = optFlatName(id) getOrElse id def optFlatName(id: String) = requestForIdent(id) map (_ fullFlatName id) - def allDefinedNames = definedNameMap.keys.toList sortBy (_.toString) + def allDefinedNames = definedNameMap.keys.toList.sorted def pathToType(id: String): String = pathToName(newTypeName(id)) def pathToTerm(id: String): String = pathToName(newTermName(id)) def pathToName(name: Name): String = { @@ -521,7 +527,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends trees.last match { case _:Assign => // we don't want to include assignments case _:TermTree | _:Ident | _:Select => // ... but do want other unnamed terms. - val varName = if (synthetic) freshInternalVarName() else ("" + freshUserTermName()) + val varName = if (synthetic) freshInternalVarName() else freshUserVarName() val rewrittenLine = ( // In theory this would come out the same without the 1-specific test, but // it's a cushion against any more sneaky parse-tree position vs. code mismatches: @@ -587,6 +593,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends * e.g. that there were no parse errors. */ def interpret(line: String): IR.Result = interpret(line, false) + def interpretSynthetic(line: String): IR.Result = interpret(line, true) def interpret(line: String, synthetic: Boolean): IR.Result = { def loadAndRunReq(req: Request) = { val (result, succeeded) = req.loadAndRun @@ -660,7 +667,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends result } def directBind(p: NamedParam): IR.Result = directBind(p.name, p.tpe, p.value) - def directBind[T: Manifest](name: String, value: T): IR.Result = directBind((name, value)) + def directBind[T: ClassTag](name: String, value: T): IR.Result = directBind((name, value)) def rebind(p: NamedParam): IR.Result = { val name = p.name @@ -676,11 +683,12 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends if (ids.isEmpty) IR.Success else interpret("import " + ids.mkString(", ")) - def quietBind(p: NamedParam): IR.Result = beQuietDuring(bind(p)) - def bind(p: NamedParam): IR.Result = bind(p.name, p.tpe, p.value) - def bind[T: Manifest](name: String, value: T): IR.Result = bind((name, value)) - def bindValue(x: Any): IR.Result = bindValue("" + freshUserTermName(), x) - def bindValue(name: String, x: Any): IR.Result = bind(name, TypeStrings.fromValue(x), x) + def quietBind(p: NamedParam): IR.Result = beQuietDuring(bind(p)) + def bind(p: NamedParam): IR.Result = bind(p.name, p.tpe, p.value) + def bind[T: TypeTag](name: String, value: T): IR.Result = bind((name, value)) + def bindSyntheticValue(x: Any): IR.Result = bindValue(freshInternalVarName(), x) + def bindValue(x: Any): IR.Result = bindValue(freshUserVarName(), x) + def bindValue(name: String, x: Any): IR.Result = bind(name, TypeStrings.fromValue(x), x) /** Reset this interpreter, forgetting all user-specified requests. */ def reset() { @@ -799,9 +807,9 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends */ def resolvePathToSymbol(accessPath: String): Symbol = { val readRoot = getRequiredModule(readPath) // the outermost wrapper - (accessPath split '.').foldLeft(readRoot) { (sym, name) => - if (name == "") sym else - afterTyper(sym.info member newTermName(name)) + (accessPath split '.').foldLeft(readRoot: Symbol) { + case (sym, "") => sym + case (sym, name) => afterTyper(termMember(sym, name)) } } /** We get a bunch of repeated warnings for reasons I haven't @@ -852,6 +860,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends /** handlers for each tree in this request */ val handlers: List[MemberHandler] = trees map (memberHandlers chooseHandler _) + def defHandlers = handlers collect { case x: MemberDefHandler => x } /** all (public) names defined by these statements */ val definedNames = handlers flatMap (_.definedNames) @@ -863,6 +872,10 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends def termNames = handlers flatMap (_.definesTerm) def typeNames = handlers flatMap (_.definesType) def definedOrImported = handlers flatMap (_.definedOrImported) + def definedSymbolList = defHandlers flatMap (_.definedSymbols) + + def definedTypeSymbol(name: String) = definedSymbols(newTypeName(name)) + def definedTermSymbol(name: String) = definedSymbols(newTermName(name)) /** Code to import bound names from previous lines - accessPath is code to * append to objectName to access anything bound by request. @@ -915,8 +928,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends val generate = (m: MemberHandler) => m extraCodeToEvaluate Request.this } - def tquoted(s: String) = "\"\"\"" + s + "\"\"\"" - private object ResultObjectSourceCode extends CodeAssembler[MemberHandler] { /** We only want to generate this code when the result * is a value which can be referred to as-is. @@ -970,6 +981,16 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends typeOf typesOfDefinedTerms + // Assign symbols to the original trees + // TODO - just use the new trees. + defHandlers foreach { dh => + val name = dh.member.name + definedSymbols get name foreach { sym => + dh.member setSymbol sym + repldbg("Set symbol of " + name + " to " + sym.defString) + } + } + // compile the result-extraction object beQuietDuring { savingSettings(_.nowarn.value = true) { @@ -986,25 +1007,23 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends def lookupTypeOf(name: Name) = typeOf.getOrElse(name, typeOf(global.encode(name.toString))) def simpleNameOfType(name: TypeName) = (compilerTypeOf get name) map (_.typeSymbol.simpleName) - private def typeMap[T](f: Type => T): Map[Name, T] = { - termNames ++ typeNames map (x => x -> f(cleanMemberDecl(resultSymbol, x))) toMap - } + private def typeMap[T](f: Type => T) = + mapFrom[Name, Name, T](termNames ++ typeNames)(x => f(cleanMemberDecl(resultSymbol, x))) /** Types of variables defined by this request. */ - lazy val compilerTypeOf = typeMap[Type](x => x) + lazy val compilerTypeOf = typeMap[Type](x => x) withDefaultValue NoType /** String representations of same. */ lazy val typeOf = typeMap[String](tp => afterTyper(tp.toString)) // lazy val definedTypes: Map[Name, Type] = { // typeNames map (x => x -> afterTyper(resultSymbol.info.nonPrivateDecl(x).tpe)) toMap // } - lazy val definedSymbols: Map[Name, Symbol] = ( + lazy val definedSymbols = ( termNames.map(x => x -> applyToResultMember(x, x => x)) ++ - typeNames.map(x => x -> compilerTypeOf.get(x).map(_.typeSymbol).getOrElse(NoSymbol)) - ).toMap + typeNames.map(x => x -> compilerTypeOf(x).typeSymbol) + ).toMap[Name, Symbol] withDefaultValue NoSymbol - lazy val typesOfDefinedTerms: Map[Name, Type] = - termNames map (x => x -> applyToResultMember(x, _.tpe)) toMap + lazy val typesOfDefinedTerms = mapFrom[Name, Name, Type](termNames)(x => applyToResultMember(x, _.tpe)) /** load and run the code using reflection */ def loadAndRun: (String, Boolean) = { @@ -1075,18 +1094,21 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends } def valueOfTerm(id: String): Option[AnyRef] = - requestForIdent(id) flatMap (_.getEval) + requestForName(newTermName(id)) flatMap (_.getEval) def classOfTerm(id: String): Option[JClass] = valueOfTerm(id) map (_.getClass) def typeOfTerm(id: String): Type = newTermName(id) match { case nme.ROOTPKG => definitions.RootClass.tpe - case name => requestForName(name) flatMap (_.compilerTypeOf get name) getOrElse NoType + case name => requestForName(name).fold(NoType: Type)(_ compilerTypeOf name) } + def symbolOfType(id: String): Symbol = + requestForName(newTypeName(id)).fold(NoSymbol: Symbol)(_ definedTypeSymbol id) + def symbolOfTerm(id: String): Symbol = - requestForIdent(id) flatMap (_.definedSymbols get newTermName(id)) getOrElse NoSymbol + requestForIdent(newTermName(id)).fold(NoSymbol: Symbol)(_ definedTermSymbol id) def runtimeClassAndTypeOfTerm(id: String): Option[(JClass, Type)] = { classOfTerm(id) flatMap { clazz => @@ -1120,11 +1142,15 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends val global: imain.global.type = imain.global } with ReplTokens { } - private object exprTyper extends { + object exprTyper extends { val repl: IMain.this.type = imain } with ExprTyper { } def parse(line: String): Option[List[Tree]] = exprTyper.parse(line) + + def symbolOfLine(code: String): Symbol = + exprTyper.symbolOfLine(code) + def typeOfExpression(expr: String, silent: Boolean = true): Type = exprTyper.typeOfExpression(expr, silent) @@ -1134,14 +1160,15 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends protected def onlyTerms(xs: List[Name]) = xs collect { case x: TermName => x } protected def onlyTypes(xs: List[Name]) = xs collect { case x: TypeName => x } - def definedTerms = onlyTerms(allDefinedNames) filterNot isInternalTermName - def definedTypes = onlyTypes(allDefinedNames) - def definedSymbols = prevRequests.toSet flatMap ((x: Request) => x.definedSymbols.values) + def definedTerms = onlyTerms(allDefinedNames) filterNot isInternalTermName + def definedTypes = onlyTypes(allDefinedNames) + def definedSymbols = prevRequestList.flatMap(_.definedSymbols.values).toSet[Symbol] + def definedSymbolList = prevRequestList flatMap (_.definedSymbolList) filterNot (s => isInternalTermName(s.name)) // Terms with user-given names (i.e. not res0 and not synthetic) def namedDefinedTerms = definedTerms filterNot (x => isUserVarName("" + x) || directlyBoundNames(x)) - private def findName(name: Name) = definedSymbols find (_.name == name) + private def findName(name: Name) = definedSymbols find (_.name == name) getOrElse NoSymbol /** Translate a repl-defined identifier into a Symbol. */ @@ -1150,15 +1177,19 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends def types(name: String): Symbol = { val tpname = newTypeName(name) - findName(tpname) getOrElse getClassIfDefined(tpname) + findName(tpname) orElse getClassIfDefined(tpname) } def terms(name: String): Symbol = { val termname = newTypeName(name) - findName(termname) getOrElse getModuleIfDefined(termname) + findName(termname) orElse getModuleIfDefined(termname) } - def types[T: ClassManifest] : Symbol = types(classManifest[T].erasure.getName) - def terms[T: ClassManifest] : Symbol = terms(classManifest[T].erasure.getName) - def apply[T: ClassManifest] : Symbol = apply(classManifest[T].erasure.getName) + // [Eugene to Paul] possibly you could make use of TypeTags here + def types[T: ClassTag] : Symbol = types(classTag[T].erasure.getName) + def terms[T: ClassTag] : Symbol = terms(classTag[T].erasure.getName) + def apply[T: ClassTag] : Symbol = apply(classTag[T].erasure.getName) + + def classSymbols = allDefSymbols collect { case x: ClassSymbol => x } + def methodSymbols = allDefSymbols collect { case x: MethodSymbol => x } /** the previous requests this interpreter has processed */ private var executingRequest: Request = _ @@ -1167,7 +1198,10 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends private val definedNameMap = mutable.Map[Name, Request]() private val directlyBoundNames = mutable.Set[Name]() - private def allHandlers = prevRequestList flatMap (_.handlers) + def allHandlers = prevRequestList flatMap (_.handlers) + def allDefHandlers = allHandlers collect { case x: MemberDefHandler => x } + def allDefSymbols = allDefHandlers map (_.symbol) filter (_ ne NoSymbol) + def lastRequest = if (prevRequests.isEmpty) null else prevRequests.last def prevRequestList = prevRequests.toList def allSeenTypes = prevRequestList flatMap (_.typeOf.values.toList) distinct diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala b/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala index a86462ad5f..795b2e3678 100644 --- a/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala +++ b/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala @@ -194,14 +194,7 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput // literal Ints, Strings, etc. object literals extends CompletionAware { - def simpleParse(code: String): Tree = { - val unit = new CompilationUnit(new util.BatchSourceFile("<console>", code)) - val scanner = new syntaxAnalyzer.UnitParser(unit) - val tss = scanner.templateStatSeq(false)._2 - - if (tss.size == 1) tss.head else EmptyTree - } - + def simpleParse(code: String): Tree = newUnitParser(code).templateStats().last def completions(verbosity: Int) = Nil override def follow(id: String) = simpleParse(id) match { diff --git a/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala b/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala index 40993eb916..a29eb3ac6d 100644 --- a/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala +++ b/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala @@ -64,6 +64,7 @@ trait MemberHandlers { } sealed abstract class MemberDefHandler(override val member: MemberDef) extends MemberHandler(member) { + def symbol = if (member.symbol eq null) NoSymbol else member.symbol def name: Name = member.name def mods: Modifiers = member.mods def keyword = member.keyword @@ -72,6 +73,7 @@ trait MemberHandlers { override def definesImplicit = member.mods.isImplicit override def definesTerm: Option[TermName] = Some(name.toTermName) filter (_ => name.isTermName) override def definesType: Option[TypeName] = Some(name.toTypeName) filter (_ => name.isTypeName) + override def definedSymbols = if (symbol eq NoSymbol) Nil else List(symbol) } /** Class to handle one member among all the members included @@ -89,6 +91,7 @@ trait MemberHandlers { def importedNames = List[Name]() def definedNames = definesTerm.toList ++ definesType.toList def definedOrImported = definedNames ++ importedNames + def definedSymbols = List[Symbol]() def extraCodeToEvaluate(req: Request): String = "" def resultExtractionCode(req: Request): String = "" @@ -121,7 +124,7 @@ trait MemberHandlers { private def vparamss = member.vparamss private def isMacro = member.mods.hasFlag(scala.reflect.internal.Flags.MACRO) // true if not a macro and 0-arity - override def definesValue = !isMacro && (vparamss.isEmpty || vparamss.head.isEmpty && vparamss.tail.isEmpty) + override def definesValue = !isMacro && flattensToEmpty(vparamss) override def resultExtractionCode(req: Request) = if (mods.isPublic) codegenln(name, ": ", req.typeOf(name)) else "" } diff --git a/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala b/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala index e2b1bf34d6..a3cbfffc3b 100644 --- a/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala +++ b/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala @@ -13,19 +13,19 @@ trait NamedParamCreator { protected def freshName: () => String def apply(name: String, tpe: String, value: Any): NamedParam = NamedParamClass(name, tpe, value) - def apply[T: Manifest](name: String, x: T): NamedParam = new Typed[T](name, x) - def apply[T: Manifest](x: T): NamedParam = apply(freshName(), x) + def apply[T: TypeTag](name: String, x: T): NamedParam = new Typed[T](name, x) + def apply[T: TypeTag](x: T): NamedParam = apply(freshName(), x) def clazz(name: String, x: Any): NamedParam = new Untyped(name, x) def clazz(x: Any): NamedParam = clazz(freshName(), x) - implicit def namedValue[T: Manifest](name: String, x: T): NamedParam = apply(name, x) - implicit def tuple[T: Manifest](pair: (String, T)): NamedParam = apply(pair._1, pair._2) + implicit def namedValue[T: TypeTag](name: String, x: T): NamedParam = apply(name, x) + implicit def tuple[T: TypeTag](pair: (String, T)): NamedParam = apply(pair._1, pair._2) } object NamedParam extends NamedParamCreator { - class Typed[T: Manifest](val name: String, val value: T) extends NamedParam { - val tpe = TypeStrings.fromManifest[T] + class Typed[T: TypeTag](val name: String, val value: T) extends NamedParam { + val tpe = TypeStrings.fromTag[T] } class Untyped(val name: String, val value: Any) extends NamedParam { val tpe = TypeStrings.fromValue(value) diff --git a/src/compiler/scala/tools/nsc/interpreter/Power.scala b/src/compiler/scala/tools/nsc/interpreter/Power.scala index ecf9dd219b..659caad1e1 100644 --- a/src/compiler/scala/tools/nsc/interpreter/Power.scala +++ b/src/compiler/scala/tools/nsc/interpreter/Power.scala @@ -42,10 +42,10 @@ Lost after 18/flatten { /** A class for methods to be injected into the intp in power mode. */ -class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: ReplValsImpl) { +class Power[ReplValsImpl <: ReplVals : TypeTag](val intp: IMain, replVals: ReplValsImpl) { import intp.{ beQuietDuring, typeOfExpression, interpret, parse } import intp.global._ - import definitions.{ manifestToType, manifestToSymbol, getClassIfDefined, getModuleIfDefined } + import definitions.{ compilerTypeFromTag, compilerSymbolFromTag, getClassIfDefined, getModuleIfDefined } abstract class SymSlurper { def isKeep(sym: Symbol): Boolean @@ -162,7 +162,7 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl } trait LowPriorityInternalInfo { - implicit def apply[T: Manifest] : InternalInfo[T] = new InternalInfo[T](None) + implicit def apply[T: TypeTag] : InternalInfo[T] = new InternalInfo[T](None) } object InternalInfo extends LowPriorityInternalInfo { } @@ -173,21 +173,21 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl * of the conveniences exist on that wrapper. */ trait LowPriorityInternalInfoWrapper { - implicit def apply[T: Manifest] : InternalInfoWrapper[T] = new InternalInfoWrapper[T](None) + implicit def apply[T: TypeTag] : InternalInfoWrapper[T] = new InternalInfoWrapper[T](None) } object InternalInfoWrapper extends LowPriorityInternalInfoWrapper { } - class InternalInfoWrapper[T: Manifest](value: Option[T] = None) { + class InternalInfoWrapper[T: TypeTag](value: Option[T] = None) { def ? : InternalInfo[T] = new InternalInfo[T](value) } /** Todos... - * translate manifest type arguments into applied types + * translate tag type arguments into applied types * customizable symbol filter (had to hardcode no-spec to reduce noise) */ - class InternalInfo[T: Manifest](value: Option[T] = None) { - private def newInfo[U: Manifest](value: U): InternalInfo[U] = new InternalInfo[U](Some(value)) + class InternalInfo[T: TypeTag](value: Option[T] = None) { + private def newInfo[U: TypeTag](value: U): InternalInfo[U] = new InternalInfo[U](Some(value)) private def isSpecialized(s: Symbol) = s.name.toString contains "$mc" private def isImplClass(s: Symbol) = s.name.toString endsWith "$class" @@ -198,8 +198,8 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl || s.isAnonOrRefinementClass || s.isAnonymousFunction ) - def symbol = manifestToSymbol(fullManifest) - def tpe = manifestToType(fullManifest) + def symbol = compilerSymbolFromTag(tag) + def tpe = compilerTypeFromTag(tag) def name = symbol.name def companion = symbol.companionSymbol def info = symbol.info @@ -226,19 +226,19 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl def pkgClasses = pkgMembers filter (s => s.isClass && s.isDefinedInPackage) def pkgSymbols = new PackageSlurper(pkgClass).slurp() filterNot excludeMember - def fullManifest = manifest[T] - def erasure = fullManifest.erasure + def tag = typeTag[T] + def erasure = tag.erasure def shortClass = erasure.getName split "[$.]" last def baseClasses = tpe.baseClasses - def baseClassDecls = baseClasses map (x => (x, x.info.decls.toList.sortBy(_.name.toString))) toMap + def baseClassDecls = mapFrom(baseClasses)(_.info.decls.toList.sortBy(_.name)) def ancestors = baseClasses drop 1 def ancestorDeclares(name: String) = ancestors filter (_.info member newTermName(name) ne NoSymbol) def baseTypes = tpe.baseTypeSeq.toList - def <:<[U: Manifest](other: U) = tpe <:< newInfo(other).tpe - def lub[U: Manifest](other: U) = intp.global.lub(List(tpe, newInfo(other).tpe)) - def glb[U: Manifest](other: U) = intp.global.glb(List(tpe, newInfo(other).tpe)) + def <:<[U: TypeTag](other: U) = tpe <:< newInfo(other).tpe + def lub[U: TypeTag](other: U) = intp.global.lub(List(tpe, newInfo(other).tpe)) + def glb[U: TypeTag](other: U) = intp.global.glb(List(tpe, newInfo(other).tpe)) override def toString = value match { case Some(x) => "%s (%s)".format(x, shortClass) @@ -362,11 +362,10 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl else if (s1 isLess s2) -1 else 1 } - implicit lazy val powerNameOrdering: Ordering[Name] = Ordering[String] on (_.toString) implicit lazy val powerSymbolOrdering: Ordering[Symbol] = Ordering[Name] on (_.name) implicit lazy val powerTypeOrdering: Ordering[Type] = Ordering[Symbol] on (_.typeSymbol) - implicit def replInternalInfo[T: Manifest](x: T): InternalInfoWrapper[T] = new InternalInfoWrapper[T](Some(x)) + implicit def replInternalInfo[T: TypeTag](x: T): InternalInfoWrapper[T] = new InternalInfoWrapper[T](Some(x)) implicit def replEnhancedStrings(s: String): RichReplString = new RichReplString(s) implicit def replMultiPrinting[T: Prettifier](xs: TraversableOnce[T]): MultiPrettifierClass[T] = new MultiPrettifierClass[T](xs.toSeq) @@ -381,10 +380,13 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl } trait ReplUtilities { - def module[T: Manifest] = getModuleIfDefined(manifest[T].erasure.getName stripSuffix nme.MODULE_SUFFIX_STRING) - def clazz[T: Manifest] = getClassIfDefined(manifest[T].erasure.getName) - def info[T: Manifest] = InternalInfo[T] - def ?[T: Manifest] = InternalInfo[T] + // [Eugene to Paul] needs review! + // def module[T: TypeTag] = getModuleIfDefined(typeTag[T].erasure.getName stripSuffix nme.MODULE_SUFFIX_STRING) + // def clazz[T: TypeTag] = getClassIfDefined(typeTag[T].erasure.getName) + def module[T: TypeTag] = typeTag[T].sym.suchThat(_.isPackage) + def clazz[T: TypeTag] = typeTag[T].sym.suchThat(_.isClass) + def info[T: TypeTag] = InternalInfo[T] + def ?[T: TypeTag] = InternalInfo[T] def url(s: String) = { try new URL(s) catch { case _: MalformedURLException => @@ -410,8 +412,8 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl lazy val phased: Phased = new { val global: intp.global.type = intp.global } with Phased { } def context(code: String) = analyzer.rootContext(unit(code)) - def source(code: String) = new BatchSourceFile("<console>", code) - def unit(code: String) = new CompilationUnit(source(code)) + def source(code: String) = newSourceFile(code) + def unit(code: String) = newCompilationUnit(code) def trees(code: String) = parse(code) getOrElse Nil def typeOf(id: String) = intp.typeOfExpression(id) diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplGlobal.scala b/src/compiler/scala/tools/nsc/interpreter/ReplGlobal.scala new file mode 100644 index 0000000000..05321dd7e6 --- /dev/null +++ b/src/compiler/scala/tools/nsc/interpreter/ReplGlobal.scala @@ -0,0 +1,57 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2011 LAMP/EPFL + * @author Paul Phillips + */ + +package scala.tools.nsc +package interpreter + +import reporters._ +import typechecker.Analyzer + +/** A layer on top of Global so I can guarantee some extra + * functionality for the repl. It doesn't do much yet. + */ +trait ReplGlobal extends Global { + // This exists mostly because using the reporter too early leads to deadlock. + private def echo(msg: String) { Console println msg } + + override def abort(msg: String): Nothing = { + echo("ReplGlobal.abort: " + msg) + super.abort(msg) + } + + override lazy val analyzer = new { + val global: ReplGlobal.this.type = ReplGlobal.this + } with Analyzer { + override def newTyper(context: Context): Typer = new Typer(context) { + override def typed(tree: Tree, mode: Int, pt: Type): Tree = { + val res = super.typed(tree, mode, pt) + tree match { + case Ident(name) if !tree.symbol.hasPackageFlag && !name.toString.startsWith("$") => + repldbg("typed %s: %s".format(name, res.tpe)) + case _ => + } + res + } + } + } + + object replPhase extends SubComponent { + val global: ReplGlobal.this.type = ReplGlobal.this + val phaseName = "repl" + val runsAfter = List[String]("typer") + val runsRightAfter = None + def newPhase(_prev: Phase): StdPhase = new StdPhase(_prev) { + def apply(unit: CompilationUnit) { + repldbg("Running replPhase on " + unit.body) + // newNamer(rootContext(unit)).enterSym(unit.body) + } + } + } + + override protected def computePhaseDescriptors: List[SubComponent] = { + addToPhasesSet(replPhase, "repl") + super.computePhaseDescriptors + } +} diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplReporter.scala b/src/compiler/scala/tools/nsc/interpreter/ReplReporter.scala index 130af990ad..fb61dfb672 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ReplReporter.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ReplReporter.scala @@ -9,7 +9,11 @@ package interpreter import reporters._ import IMain._ +/** Like ReplGlobal, a layer for ensuring extra functionality. + */ class ReplReporter(intp: IMain) extends ConsoleReporter(intp.settings, Console.in, new ReplStrippingWriter(intp)) { + def printUntruncatedMessage(msg: String) = withoutTruncating(printMessage(msg)) + override def printMessage(msg: String) { // Avoiding deadlock if the compiler starts logging before // the lazy val is complete. diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala b/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala index 8b891e0010..280247f20c 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala @@ -6,6 +6,7 @@ package scala.tools.nsc package interpreter +import scala.reflect.{mirror => rm} import language.implicitConversions /** A class which the repl utilizes to expose predefined objects. @@ -27,7 +28,8 @@ class StdReplVals(final val r: ILoop) extends ReplVals { final lazy val phased = power.phased final lazy val analyzer = global.analyzer - final lazy val treedsl = new { val global: intp.global.type = intp.global } with ast.TreeDSL { } + object treedsl extends { val global: intp.global.type = intp.global } with ast.TreeDSL { } + final lazy val typer = analyzer.newTyper( analyzer.rootContext( power.unit("").asInstanceOf[analyzer.global.CompilationUnit] @@ -35,13 +37,15 @@ class StdReplVals(final val r: ILoop) extends ReplVals { ) def lastRequest = intp.lastRequest - final lazy val replImplicits = new power.Implicits2 { + class ReplImplicits extends power.Implicits2 { import intp.global._ - private val manifestFn = ReplVals.mkManifestToType[intp.global.type](global) - implicit def mkManifestToType(sym: Symbol) = manifestFn(sym) + private val tagFn = ReplVals.mkCompilerTypeFromTag[intp.global.type](global) + implicit def mkCompilerTypeFromTag(sym: Symbol) = tagFn(sym) } + final lazy val replImplicits = new ReplImplicits + def typed[T <: analyzer.global.Tree](tree: T): T = typer.typed(tree).asInstanceOf[T] } @@ -50,29 +54,29 @@ object ReplVals { * not being seen as the same type as bar.global.Type even though * the globals are the same. Dependent method types to the rescue. */ - def mkManifestToType[T <: Global](global: T) = { + def mkCompilerTypeFromTag[T <: Global](global: T) = { import global._ import definitions._ - /** We can't use definitions.manifestToType directly because we're passing + /** We can't use definitions.compilerTypeFromTag directly because we're passing * it to map and the compiler refuses to perform eta expansion on a method * with a dependent return type. (Can this be relaxed?) To get around this * I have this forwarder which widens the type and then cast the result back * to the dependent type. */ - def manifestToType(m: Manifest[_]): Global#Type = - definitions.manifestToType(m) + def compilerTypeFromTag(t: rm.TypeTag[_]): Global#Type = + definitions.compilerTypeFromTag(t) - class AppliedTypeFromManifests(sym: Symbol) { - def apply[M](implicit m1: Manifest[M]): Type = + class AppliedTypeFromTags(sym: Symbol) { + def apply[M](implicit m1: rm.TypeTag[M]): Type = if (sym eq NoSymbol) NoType - else appliedType(sym, manifestToType(m1).asInstanceOf[Type]) + else appliedType(sym, compilerTypeFromTag(m1).asInstanceOf[Type]) - def apply[M1, M2](implicit m1: Manifest[M1], m2: Manifest[M2]): Type = + def apply[M1, M2](implicit m1: rm.TypeTag[M1], m2: rm.TypeTag[M2]): Type = if (sym eq NoSymbol) NoType - else appliedType(sym, manifestToType(m1).asInstanceOf[Type], manifestToType(m2).asInstanceOf[Type]) + else appliedType(sym, compilerTypeFromTag(m1).asInstanceOf[Type], compilerTypeFromTag(m2).asInstanceOf[Type]) } - (sym: Symbol) => new AppliedTypeFromManifests(sym) + (sym: Symbol) => new AppliedTypeFromTags(sym) } } diff --git a/src/compiler/scala/tools/nsc/interpreter/RichClass.scala b/src/compiler/scala/tools/nsc/interpreter/RichClass.scala index 59a7b9b5d2..2e735e3b9b 100644 --- a/src/compiler/scala/tools/nsc/interpreter/RichClass.scala +++ b/src/compiler/scala/tools/nsc/interpreter/RichClass.scala @@ -7,18 +7,21 @@ package scala.tools.nsc package interpreter class RichClass[T](val clazz: Class[T]) { - def toManifest: Manifest[T] = Manifest[T](ClassManifest[T](clazz).tpe) + def toTag: ClassTag[T] = ClassTag[T](clazz) def toTypeString: String = TypeStrings.fromClazz(clazz) // Sadly isAnonymousClass does not return true for scala anonymous // classes because our naming scheme is not doing well against the // jvm's many assumptions. - def isScalaAnonymous = clazz.isAnonymousClass || (clazz.getName contains "$anon$") + def isScalaAnonymous = ( + try clazz.isAnonymousClass || (clazz.getName contains "$anon$") + catch { case _: java.lang.InternalError => false } // good ol' "Malformed class name" + ) /** It's not easy... to be... me... */ - def supermans: List[Manifest[_]] = supers map (_.toManifest) - def superNames: List[String] = supers map (_.getName) - def interfaces: List[JClass] = supers filter (_.isInterface) + def supermans: List[ClassTag[_]] = supers map (_.toTag) + def superNames: List[String] = supers map (_.getName) + def interfaces: List[JClass] = supers filter (_.isInterface) def hasAncestorName(f: String => Boolean) = superNames exists f def hasAncestor(f: JClass => Boolean) = supers exists f diff --git a/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala b/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala index 872ac00bfd..5d5123811e 100644 --- a/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala +++ b/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala @@ -11,6 +11,142 @@ import r.TypeVariable import scala.reflect.NameTransformer import NameTransformer._ import scala.reflect.{mirror => rm} +import typechecker.DestructureTypes +import scala.tools.util.StringOps.ojoin + +/** A more principled system for turning types into strings. + */ +trait StructuredTypeStrings extends DestructureTypes { + val global: Global + import global._ + import definitions._ + + case class LabelAndType(label: String, typeName: String) { } + object LabelAndType { + val empty = LabelAndType("", "") + } + case class Grouping(ldelim: String, mdelim: String, rdelim: String, labels: Boolean) { + def join(elems: String*): String = ( + if (elems.isEmpty) "" + else elems.mkString(ldelim, mdelim, rdelim) + ) + } + val NoGrouping = Grouping("", "", "", false) + val ListGrouping = Grouping("(", ", ", ")", false) + val ProductGrouping = Grouping("(", ", ", ")", true) + val ParamGrouping = Grouping("(", ", ", ")", true) + val BlockGrouping = Grouping(" { ", "; ", "}", false) + + private implicit def lowerName(n: Name): String = "" + n + private def str(level: Int)(body: => String): String = " " * level + body + private def block(level: Int, grouping: Grouping)(name: String, nodes: List[TypeNode]): String = { + val l1 = str(level)(name + grouping.ldelim) + val l2 = nodes.map(_ show level + 1) + val l3 = str(level)(grouping.rdelim) + + l1 +: l2 :+ l3 mkString "\n" + } + private def maybeBlock(level: Int, grouping: Grouping)(name: String, nodes: List[TypeNode]): String = { + import grouping._ + val threshold = 70 + + val try1 = str(level)(name + grouping.join(nodes map (_.show(0, grouping.labels)): _*)) + if (try1.length < threshold) try1 + else block(level, grouping)(name, nodes) + } + private def shortClass(x: Any) = { + if (opt.debug) { + val name = (x.getClass.getName split '.').last + val isAnon = name.reverse takeWhile (_ != '$') forall (_.isDigit) + val str = if (isAnon) name else (name split '$').last + + " // " + str + } + else "" + } + + sealed abstract class TypeNode { + def grouping: Grouping + def nodes: List[TypeNode] + + def show(indent: Int, showLabel: Boolean): String = maybeBlock(indent, grouping)(mkPrefix(showLabel), nodes) + def show(indent: Int): String = show(indent, true) + def show(): String = show(0) + + def withLabel(l: String): this.type = modifyNameInfo(_.copy(label = l)) + def withType(t: String): this.type = modifyNameInfo(_.copy(typeName = t)) + + def label = nameInfo.label + def typeName = nameInfo.typeName + + protected def mkPrefix(showLabel: Boolean) = { + val pre = if (showLabel && label != "") label + " = " else "" + pre + typeName + } + override def toString = show() // + "(toString)" + private var nameInfo: LabelAndType = LabelAndType.empty + private def modifyNameInfo(f: LabelAndType => LabelAndType): this.type = { + nameInfo = f(nameInfo) + this + } + } + case class TypeAtom[T](atom: T) extends TypeNode { + def grouping = NoGrouping + def nodes = Nil + override protected def mkPrefix(showLabel: Boolean) = + super.mkPrefix(showLabel) + atom + shortClass(atom) + } + case class TypeProduct(nodes: List[TypeNode]) extends TypeNode { + def grouping: Grouping = ProductGrouping + def emptyTypeName = "" + override def typeName = if (nodes.isEmpty) emptyTypeName else super.typeName + } + + /** For a NullaryMethod, in = TypeEmpty; for MethodType(Nil, _) in = TypeNil */ + class NullaryFunction(out: TypeNode) extends TypeProduct(List(out)) { + override def typeName = "NullaryMethodType" + } + class MonoFunction(in: TypeNode, out: TypeNode) extends TypeProduct(List(in, out)) { + override def typeName = "MethodType" + } + class PolyFunction(in: TypeNode, out: TypeNode) extends TypeProduct(List(in, out)) { + override def typeName = "PolyType" + } + + class TypeList(nodes: List[TypeNode]) extends TypeProduct(nodes) { + override def grouping = ListGrouping + override def emptyTypeName = "Nil" + override def typeName = "List" + } + class TypeScope(nodes: List[TypeNode]) extends TypeProduct(nodes) { + override def grouping = BlockGrouping + override def typeName = "Scope" + override def emptyTypeName = "EmptyScope" + } + + object TypeEmpty extends TypeNode { + override def grouping = NoGrouping + override def nodes = Nil + override def label = "" + override def typeName = "" + override def show(indent: Int, showLabel: Boolean) = "" + } + + object intoNodes extends DestructureType[TypeNode] { + def withLabel(node: TypeNode, label: String): TypeNode = node withLabel label + def withType(node: TypeNode, typeName: String): TypeNode = node withType typeName + + def wrapEmpty = TypeEmpty + def wrapSequence(nodes: List[TypeNode]) = new TypeList(nodes) + def wrapProduct(nodes: List[TypeNode]) = new TypeProduct(nodes) + def wrapPoly(in: TypeNode, out: TypeNode) = new PolyFunction(in, out) + def wrapMono(in: TypeNode, out: TypeNode) = if (in == wrapEmpty) new NullaryFunction(out) else new MonoFunction(in, out) + def wrapAtom[U](value: U) = new TypeAtom(value) + } + + def show(tp: Type): String = intoNodes(tp).show +} + /** Logic for turning a type into a String. The goal is to be * able to take some arbitrary object 'x' and obtain the most precise @@ -56,8 +192,8 @@ trait TypeStrings { else enclClass.getName + "." + (name stripPrefix enclPre) ) } - def scalaName(m: ClassManifest[_]): String = scalaName(m.erasure) - def anyClass(x: Any): JClass = if (x == null) null else x.getClass + def scalaName(m: ClassTag[_]): String = scalaName(m.erasure) + def anyClass(x: Any): JClass = if (x == null) null else x.getClass private def brackets(tps: String*): String = if (tps.isEmpty) "" @@ -73,25 +209,25 @@ trait TypeStrings { brackets(clazz.getTypeParameters map tvarString: _*) } - private def tparamString[T: Manifest] : String = { + private def tparamString[T: TypeTag] : String = { // [Eugene to Paul] needs review!! - def typeArguments: List[rm.Type] = manifest[T].tpe.typeArguments + def typeArguments: List[rm.Type] = typeTag[T].tpe.typeArguments def typeVariables: List[java.lang.Class[_]] = typeArguments map (targ => rm.typeToClass(targ)) brackets(typeArguments map (jc => tvarString(List(jc))): _*) } /** Going for an overabundance of caution right now. Later these types - * can be a lot more precise, but right now the manifests have a habit of + * can be a lot more precise, but right now the tags have a habit of * introducing material which is not syntactically valid as scala source. * When this happens it breaks the repl. It would be nice if we mandated - * that manifest toString methods (or some other method, since it's bad + * that tag toString methods (or some other method, since it's bad * practice to rely on toString for correctness) generated the VALID string * representation of the type. */ - def fromTypedValue[T: Manifest](x: T): String = fromManifest[T] - def fromValue(value: Any): String = if (value == null) "Null" else fromClazz(anyClass(value)) - def fromClazz(clazz: JClass): String = scalaName(clazz) + tparamString(clazz) - def fromManifest[T: Manifest] : String = scalaName(manifest[T].erasure) + tparamString[T] + def fromTypedValue[T: TypeTag](x: T): String = fromTag[T] + def fromValue(value: Any): String = if (value == null) "Null" else fromClazz(anyClass(value)) + def fromClazz(clazz: JClass): String = scalaName(clazz) + tparamString(clazz) + def fromTag[T: TypeTag] : String = scalaName(typeTag[T].erasure) + tparamString[T] /** Reducing fully qualified noise for some common packages. */ diff --git a/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala b/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala index d0a0b17494..c9ed535841 100644 --- a/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala +++ b/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala @@ -13,9 +13,9 @@ import collection.JavaConverters._ /** A convenience class for finding the jar with the bytecode for * a given Class object and similar common tasks. */ -class ClassAndJarInfo[T: ClassManifest] { - val man = classManifest[T] - def clazz = man.erasure +class ClassAndJarInfo[T: ClassTag] { + val tag = classTag[T] + def clazz = tag.erasure def internalName = clazz.getName.replace('.', '/') def resourceURL = new URLClassLoader(Array[URL]()) getResource internalName + ".class" diff --git a/src/compiler/scala/tools/nsc/io/Pickler.scala b/src/compiler/scala/tools/nsc/io/Pickler.scala index 86c7ca7b9a..416b84eec6 100644 --- a/src/compiler/scala/tools/nsc/io/Pickler.scala +++ b/src/compiler/scala/tools/nsc/io/Pickler.scala @@ -416,7 +416,7 @@ object Pickler { iterPickler[T] .wrapped { Vector() ++ _ } { _.iterator } .labelled ("scala.Vector") /** A pickler for array values */ - implicit def array[T : ClassManifest : Pickler]: Pickler[Array[T]] = + implicit def array[T : ClassTag : Pickler]: Pickler[Array[T]] = iterPickler[T] .wrapped { _.toArray} { _.iterator } .labelled ("scala.Array") } diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala index ca3f3ff635..5c413243e8 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala @@ -789,23 +789,24 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners { val idefs = members.toList ::: (sdefs flatMap forwarders) (sdefs, idefs) } - + def annotationParents = List( + gen.scalaAnnotationDot(tpnme.Annotation), + Select(javaLangDot(nme.annotation), tpnme.Annotation), + gen.scalaAnnotationDot(tpnme.ClassfileAnnotation) + ) def annotationDecl(mods: Modifiers): List[Tree] = { accept(AT) accept(INTERFACE) val pos = in.currentPos val name = identForType() - val parents = List(scalaDot(tpnme.Annotation), - Select(javaLangDot(nme.annotation), tpnme.Annotation), - scalaDot(tpnme.ClassfileAnnotation)) val (statics, body) = typeBody(AT, name) def getValueMethodType(tree: Tree) = tree match { case DefDef(_, nme.value, _, _, tpt, _) => Some(tpt.duplicate) case _ => None } - var templ = makeTemplate(parents, body) + var templ = makeTemplate(annotationParents, body) for (stat <- templ.body; tpt <- getValueMethodType(stat)) - templ = makeTemplate(parents, makeConstructor(List(tpt)) :: templ.body) + templ = makeTemplate(annotationParents, makeConstructor(List(tpt)) :: templ.body) addCompanionObject(statics, atPos(pos) { ClassDef(mods, name, List(), templ) }) diff --git a/src/compiler/scala/tools/nsc/matching/MatchSupport.scala b/src/compiler/scala/tools/nsc/matching/MatchSupport.scala index 249f754e8f..72e6f32af1 100644 --- a/src/compiler/scala/tools/nsc/matching/MatchSupport.scala +++ b/src/compiler/scala/tools/nsc/matching/MatchSupport.scala @@ -31,7 +31,7 @@ trait MatchSupport extends ast.TreeDSL { self: ParallelMatching => object Types { import definitions._ - val subrangeTypes = Set(ByteClass, ShortClass, CharClass, IntClass) + val subrangeTypes = Set[Symbol](ByteClass, ShortClass, CharClass, IntClass) implicit class RichType(undecodedTpe: Type) { def tpe = decodedEqualsType(undecodedTpe) diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index a52e3b8bbe..c4dd9a2a36 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -183,8 +183,8 @@ class MutableSettings(val errorFn: String => Unit) * The class loader defining `T` should provide resources `app.class.path` * and `boot.class.path`. These resources should contain the application * and boot classpaths in the same form as would be passed on the command line.*/ - def embeddedDefaults[T: Manifest]: Unit = - embeddedDefaults(implicitly[Manifest[T]].erasure.getClassLoader) + def embeddedDefaults[T: ClassTag]: Unit = + embeddedDefaults(classTag[T].erasure.getClassLoader) /** Initializes these settings for embedded use by a class from the given class loader. * The class loader for `T` should provide resources `app.class.path` diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index d4c2ffa832..0a9d25af7e 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -41,11 +41,11 @@ trait ScalaSettings extends AbsScalaSettings protected def optimiseSettings = List[BooleanSetting](inline, inlineHandlers, Xcloselim, Xdce) /** Internal use - syntax enhancements. */ - private class EnableSettings[T <: Setting](val s: T) { - def enabling(toEnable: List[BooleanSetting]): s.type = s withPostSetHook (_ => toEnable foreach (_.value = true)) + private class EnableSettings[T <: BooleanSetting](val s: T) { + def enabling(toEnable: List[BooleanSetting]): s.type = s withPostSetHook (_ => toEnable foreach (_.value = s.value)) def andThen(f: s.T => Unit): s.type = s withPostSetHook (setting => f(setting.value)) } - private implicit def installEnableSettings[T <: Setting](s: T) = new EnableSettings(s) + private implicit def installEnableSettings[T <: BooleanSetting](s: T) = new EnableSettings(s) /** Disable a setting */ def disable(s: Setting) = allSettings -= s @@ -138,6 +138,7 @@ trait ScalaSettings extends AbsScalaSettings val termConflict = ChoiceSetting ("-Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error") val inline = BooleanSetting ("-Yinline", "Perform inlining when possible.") val inlineHandlers = BooleanSetting ("-Yinline-handlers", "Perform exception handler inlining when possible.") + val YinlinerWarnings= BooleanSetting ("-Yinline-warnings", "Emit inlining warnings. (Normally surpressed due to high volume)") val Xlinearizer = ChoiceSetting ("-Ylinearizer", "which", "Linearizer to use", List("normal", "dfs", "rpo", "dump"), "rpo") val log = PhasesSetting ("-Ylog", "Log operations during") val Ylogcp = BooleanSetting ("-Ylog-classpath", "Output information about what classpath is being applied.") @@ -171,7 +172,6 @@ trait ScalaSettings extends AbsScalaSettings val YrichExes = BooleanSetting ("-Yrich-exceptions", "Fancier exceptions. Set source search path with -D" + sys.SystemProperties.traceSourcePath.key) val Ybuilderdebug = ChoiceSetting ("-Ybuilder-debug", "manager", "Compile using the specified build manager.", List("none", "refined", "simple"), "none") val Yreifycopypaste = BooleanSetting ("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.") - val Ymacrocopypaste = BooleanSetting ("-Ymacro-copypaste", "Dump macro expansions in copypasteable representation.") val Yreplsync = BooleanSetting ("-Yrepl-sync", "Do not use asynchronous code for repl startup") val Ynotnull = BooleanSetting ("-Ynotnull", "Enable (experimental and incomplete) scala.NotNull.") val YmethodInfer = BooleanSetting ("-Yinfer-argument-types", "Infer types for arguments of overriden methods.") @@ -192,7 +192,8 @@ trait ScalaSettings extends AbsScalaSettings val Yidedebug = BooleanSetting("-Yide-debug", "Generate, validate and output trees using the interactive compiler.") val Yinferdebug = BooleanSetting("-Yinfer-debug", "Trace type inference and implicit search.") val Yissuedebug = BooleanSetting("-Yissue-debug", "Print stack traces when a context issues an error.") - val Ymacrodebug = BooleanSetting("-Ymacro-debug", "Trace macro-related activities: compilation, generation of synthetics, classloading, expansion, exceptions.") + val YmacrodebugLite = BooleanSetting("-Ymacro-debug-lite", "Trace essential macro-related activities.") + val YmacrodebugVerbose = BooleanSetting("-Ymacro-debug-verbose", "Trace all macro-related activities: compilation, generation of synthetics, classloading, expansion, exceptions.") val Ypmatdebug = BooleanSetting("-Ypmat-debug", "Trace all pattern matcher activity.") val Yposdebug = BooleanSetting("-Ypos-debug", "Trace position validation.") val Yreifydebug = BooleanSetting("-Yreify-debug", "Trace reification.") diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala b/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala index fb85ebeeb0..75b486ca7d 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala @@ -6,7 +6,4 @@ package scala.tools.nsc package symtab -import ast.{Trees, TreePrinters, DocComments} -import util._ - abstract class SymbolTable extends reflect.internal.SymbolTable
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala index 775a7a9d38..862a3ffdc7 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala @@ -165,7 +165,7 @@ abstract class ICodeReader extends ClassfileParser { else if (name == fulltpnme.RuntimeNull) definitions.NullClass else if (nme.isImplClassName(name)) { - val iface = definitions.getClass(nme.interfaceName(name)) + val iface = definitions.getClass(tpnme.interfaceName(name)) log("forcing " + iface.owner + " at phase: " + phase + " impl: " + iface.implClass) iface.owner.info // force the mixin type-transformer definitions.getClass(name) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 52648380ec..192cc94b90 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -62,9 +62,16 @@ abstract class Pickler extends SubComponent { // when we pickle it: so let's report an error instead. We know next // to nothing about what happened, but our supposition is a lot better // than "bad type: <error>" in terms of explanatory power. - for (t <- unit.body ; if t.isErroneous) { - unit.error(t.pos, "erroneous or inaccessible type") - return + for (t <- unit.body) { + if (t.isErroneous) { + unit.error(t.pos, "erroneous or inaccessible type") + return + } + + if (!t.isDef && t.hasSymbol && t.symbol.isTermMacro) { + unit.error(t.pos, "macro has not been expanded") + return + } } pickle(unit.body) diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala index 5a11926048..3581f1b923 100644 --- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala +++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala @@ -66,7 +66,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure => private def newImplClass(iface: Symbol): Symbol = { val inClass = iface.owner.isClass - val implName = nme.implClassName(iface.name) + val implName = tpnme.implClassName(iface.name) val implFlags = (iface.flags & ~(INTERFACE | lateINTERFACE)) | IMPLCLASS val impl0 = ( diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index fd15d92e37..bf01e142c9 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -611,7 +611,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { val ntree = typedWithPos(tree.pos)(safeREF(staticFieldSym)) super.transform(ntree) - // This transform replaces Array(Predef.wrapArray(Array(...)), <manifest>) + // This transform replaces Array(Predef.wrapArray(Array(...)), <tag>) // with just Array(...) case Apply(appMeth, List(Apply(wrapRefArrayMeth, List(array)), _)) if (wrapRefArrayMeth.symbol == Predef_wrapRefArray && diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index 5e61359a25..338c39dc5f 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -617,8 +617,12 @@ abstract class Erasure extends AddInterfaces // See SI-4731 for one example of how this occurs. log("Attempted to cast to Unit: " + tree) tree.duplicate setType pt - } - else gen.mkAttributedCast(tree, pt) + } else if (tree.tpe != null && tree.tpe.typeSymbol == ArrayClass && pt.typeSymbol == ArrayClass) { + // See SI-2386 for one example of when this might be necessary. + val needsExtraCast = isScalaValueType(tree.tpe.typeArgs.head) && !isScalaValueType(pt.typeArgs.head) + val tree1 = if (needsExtraCast) gen.mkRuntimeCall(nme.toObjectArray, List(tree)) else tree + gen.mkAttributedCast(tree1, pt) + } else gen.mkAttributedCast(tree, pt) } /** Adapt `tree` to expected type `pt`. @@ -664,6 +668,7 @@ abstract class Erasure extends AddInterfaces */ private def adaptMember(tree: Tree): Tree = { //Console.println("adaptMember: " + tree); + val x = 2 + 2 tree match { case Apply(TypeApply(sel @ Select(qual, name), List(targ)), List()) if tree.symbol == Any_asInstanceOf => @@ -992,7 +997,7 @@ abstract class Erasure extends AddInterfaces } // Rewrite 5.getClass to ScalaRunTime.anyValClass(5) else if (isPrimitiveValueClass(qual.tpe.typeSymbol)) - global.typer.typed(gen.mkRuntimeCall(nme.anyValClass, List(qual))) + global.typer.typed(gen.mkRuntimeCall(nme.anyValClass, List(qual, typer.resolveErasureTag(tree.pos, qual.tpe.widen, true)))) else tree diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala index 6bddfe8d57..618a1cbba4 100644 --- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala +++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala @@ -159,7 +159,7 @@ abstract class LambdaLift extends InfoTransform { // for that failure. There should be exactly one method for any given // entity which always gives the right answer. if (sym.isImplClass) - localImplClasses((sym.owner, nme.interfaceName(sym.name))) = sym + localImplClasses((sym.owner, tpnme.interfaceName(sym.name))) = sym else { renamable addEntry sym if (sym.isTrait) @@ -229,7 +229,7 @@ abstract class LambdaLift extends InfoTransform { def renameTrait(traitSym: Symbol, implSym: Symbol) { val originalImplName = implSym.name renameSym(traitSym) - implSym setName nme.implClassName(traitSym.name) + implSym setName tpnme.implClassName(traitSym.name) debuglog("renaming impl class in step with %s: %s => %s".format(traitSym, originalImplName, implSym.name)) } diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index ff671088ac..f6296acdca 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -68,7 +68,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { import definitions.{ RootClass, BooleanClass, UnitClass, ArrayClass, ScalaValueClasses, isPrimitiveValueClass, isScalaValueType, - SpecializedClass, AnyRefClass, ObjectClass, AnyRefModule, + SpecializedClass, UnspecializedClass, AnyRefClass, ObjectClass, AnyRefModule, GroupOfSpecializable, uncheckedVarianceClass, ScalaInlineClass } @@ -374,12 +374,17 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { * - members with specialized type parameters found in the given environment * - constructors of specialized classes * - normalized members whose type bounds appear in the environment + * But suppressed for: + * - any member with the @unspecialized annotation, or which has an + * enclosing member with the annotation. */ - private def needsSpecialization(env: TypeEnv, sym: Symbol): Boolean = { - specializedTypeVars(sym).intersect(env.keySet).diff(wasSpecializedForTypeVars(sym)).nonEmpty || - (sym.isClassConstructor && (sym.enclClass.typeParams exists (_.isSpecialized))) || - (isNormalizedMember(sym) && info(sym).typeBoundsIn(env)) - } + private def needsSpecialization(env: TypeEnv, sym: Symbol): Boolean = ( + !sym.ownerChain.exists(_ hasAnnotation UnspecializedClass) && ( + specializedTypeVars(sym).intersect(env.keySet).diff(wasSpecializedForTypeVars(sym)).nonEmpty + || sym.isClassConstructor && (sym.enclClass.typeParams exists (_.isSpecialized)) + || isNormalizedMember(sym) && info(sym).typeBoundsIn(env) + ) + ) def isNormalizedMember(m: Symbol) = m.isSpecialized && (info get m exists { case NormalizedMember(_) => true @@ -820,7 +825,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { // concise printing of type env private def pp(env: TypeEnv): String = { - env.toList.sortBy(_._1.name.toString) map { + env.toList.sortBy(_._1.name) map { case (k, v) => val vsym = v.typeSymbol if (k == vsym) "" + k.name diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index 57cd51ad35..35e26b39b5 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -446,8 +446,10 @@ abstract class UnCurry extends InfoTransform } val members = - if (isPartial) List(applyOrElseMethodDef, isDefinedAtMethodDef) - else List(applyMethodDef) + if (isPartial) { + assert(!opt.virtPatmat, "PartialFunction should have been synthesized during typer "+ fun); + List(applyOrElseMethodDef, isDefinedAtMethodDef) + } else List(applyMethodDef) // println("MEMBERS "+ members) val res = localTyper.typedPos(fun.pos) { @@ -484,7 +486,7 @@ abstract class UnCurry extends InfoTransform val toArraySym = tree.tpe member nme.toArray assert(toArraySym != NoSymbol) def getClassTag(tp: Type): Tree = { - val tag = localTyper.resolveClassTag(tree, tp) + val tag = localTyper.resolveArrayTag(tree.pos, tp) // Don't want bottom types getting any further than this (SI-4024) if (tp.typeSymbol.isBottomClass) getClassTag(AnyClass.tpe) else if (!tag.isEmpty) tag diff --git a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala index 18c7635b1e..a77df71312 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala @@ -24,6 +24,7 @@ trait Analyzer extends AnyRef with NamesDefaults with TypeDiagnostics with ContextErrors + with StdAttachments { val global : Global import global._ diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index e9c3bef737..2d1369b11d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -129,11 +129,11 @@ trait ContextErrors { val retyped = typed (tree.duplicate setType null) val foundDecls = retyped.tpe.decls filter (sym => !sym.isConstructor && !sym.isSynthetic) - if (foundDecls.isEmpty) found + if (foundDecls.isEmpty || (found.typeSymbol eq NoSymbol)) found else { // The members arrive marked private, presumably because there was no // expected type and so they're considered members of an anon class. - foundDecls foreach (_ resetFlag (PRIVATE | PROTECTED)) + foundDecls foreach (_.makePublic) // TODO: if any of the found parents match up with required parents after normalization, // print the error so that they match. The major beneficiary there would be // java.lang.Object vs. AnyRef. @@ -343,6 +343,11 @@ trait ContextErrors { issueNormalTypeError(tree, "macros cannot be eta-expanded") setError(tree) } + + def MacroPartialApplicationError(tree: Tree) = { + issueNormalTypeError(tree, "macros cannot be partially applied") + setError(tree) + } //typedReturn def ReturnOutsideOfDefError(tree: Tree) = { @@ -861,7 +866,7 @@ trait ContextErrors { // (note that this is not a compilation error, it's an artifact of implicit search algorithm) // normally, such "errors" are discarded by `isCyclicOrErroneous` in Implicits.scala // but in our case this won't work, because isCyclicOrErroneous catches CyclicReference exceptions - // while our error will manifest itself as a "recursive method needs a return type" + // while our error will present itself as a "recursive method needs a return type" // // hence we (together with reportTypeError in TypeDiagnostics) make sure that this CyclicReference // evades all the handlers on its way and successfully reaches `isCyclicOrErroneous` in Implicits diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index e2d4efab83..0924789948 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -354,32 +354,30 @@ trait Contexts { self: Analyzer => private def unitError(pos: Position, msg: String) = unit.error(pos, if (checking) "\n**** ERROR DURING INTERNAL CHECKING ****\n" + msg else msg) - - def issue(err: AbsTypeError) { + + @inline private def issueCommon(err: AbsTypeError)(pf: PartialFunction[AbsTypeError, Unit]) { debugwarn("issue error: " + err.errMsg) if (settings.Yissuedebug.value) (new Exception).printStackTrace() - if (reportErrors) unitError(err.errPos, addDiagString(err.errMsg)) + if (pf isDefinedAt err) pf(err) else if (bufferErrors) { buffer += err } else throw new TypeError(err.errPos, err.errMsg) } + def issue(err: AbsTypeError) { + issueCommon(err) { case _ if reportErrors => + unitError(err.errPos, addDiagString(err.errMsg)) + } + } + def issueAmbiguousError(pre: Type, sym1: Symbol, sym2: Symbol, err: AbsTypeError) { - debugwarn("issue ambiguous error: " + err.errMsg) - if (settings.Yissuedebug.value) (new Exception).printStackTrace() - if (ambiguousErrors) { + issueCommon(err) { case _ if ambiguousErrors => if (!pre.isErroneous && !sym1.isErroneous && !sym2.isErroneous) unitError(err.errPos, err.errMsg) - } else if (bufferErrors) { buffer += err } - else throw new TypeError(err.errPos, err.errMsg) + } } def issueAmbiguousError(err: AbsTypeError) { - debugwarn("issue ambiguous error: " + err.errMsg) - if (settings.Yissuedebug.value) (new Exception).printStackTrace() - if (ambiguousErrors) - unitError(err.errPos, addDiagString(err.errMsg)) - else if (bufferErrors) { buffer += err } - else throw new TypeError(err.errPos, err.errMsg) + issueCommon(err) { case _ if ambiguousErrors => unitError(err.errPos, addDiagString(err.errMsg)) } } // TODO remove @@ -405,6 +403,17 @@ trait Contexts { self: Analyzer => case _ => outer.isLocal() } + /** Fast path for some slow checks (ambiguous assignment in Refchecks, and + * existence of __match for MatchTranslation in virtpatmat.) This logic probably + * needs improvement. + */ + def isNameInScope(name: Name) = ( + enclosingContextChain exists (ctx => + (ctx.scope.lookupEntry(name) != null) + || (ctx.owner.rawInfo.member(name) != NoSymbol) + ) + ) + // nextOuter determines which context is searched next for implicits // (after `this`, which contributes `newImplicits` below.) In // most cases, it is simply the outer context: if we're owned by diff --git a/src/compiler/scala/tools/nsc/typechecker/DestructureTypes.scala b/src/compiler/scala/tools/nsc/typechecker/DestructureTypes.scala new file mode 100644 index 0000000000..0b414801d6 --- /dev/null +++ b/src/compiler/scala/tools/nsc/typechecker/DestructureTypes.scala @@ -0,0 +1,206 @@ +/* NSC -- new Scala compiler +* Copyright 2005-2012 LAMP/EPFL +* @author Paul Phillips +*/ + +package scala.tools.nsc +package typechecker + +/** A generic means of breaking down types into their subcomponents. + * Types are decomposed top down, and recognizable substructure is + * dispatched via self-apparently named methods. Those methods can + * be overridden for custom behavior, but only the abstract methods + * require implementations, each of which must create some unknown + * "Node" type from its inputs. + * + * - wrapProduct create Node from a product of Nodes + * - wrapSequence create Node from a sequence of Nodes + * - wrapAtom create Node from an arbitrary value + * + * This is a work in progress. + */ +trait DestructureTypes { + val global: Global + import global._ + import definitions.{ NothingClass, AnyClass } + + trait DestructureType[Node] extends (Type => Node) { + def withLabel(node: Node, label: String): Node + def withType(node: Node, typeName: String): Node + + def wrapEmpty: Node + def wrapPoly(in: Node, out: Node): Node + def wrapMono(in: Node, out: Node): Node + def wrapProduct(nodes: List[Node]): Node + def wrapSequence(nodes: List[Node]): Node + def wrapAtom[U](value: U): Node + + private implicit def liftToTerm(name: String): TermName = newTermName(name) + + private val openSymbols = collection.mutable.Set[Symbol]() + + private def nodeList[T](elems: List[T], mkNode: T => Node): Node = + if (elems.isEmpty) wrapEmpty else list(elems map mkNode) + + private def scopeMemberList(elems: List[Symbol]): Node = nodeList(elems, wrapAtom) + private def typeList(elems: List[Type]): Node = nodeList(elems, this) + private def symbolList(elems: List[Symbol]): Node = nodeList(elems, wrapSymbolInfo) + private def treeList(elems: List[Tree]): Node = nodeList(elems, wrapTree) + private def annotationList(annots: List[AnnotationInfo]): Node = nodeList(annots, annotation) + + private def assocsNode(ann: AnnotationInfo): Node = { + val (names, args) = ann.assocs.toIndexedSeq.unzip + if (names.isEmpty) wrapEmpty + else node("assocs", nodeList(names.indices.toList, (i: Int) => atom(names(i).toString, args(i)))) + } + private def typeTypeName(tp: Type) = tp match { + case mt @ MethodType(_, _) if mt.isImplicit => "ImplicitMethodType" + case TypeRef(_, sym, _) => typeRefType(sym) + case _ => tp.kind + } + + def wrapTree(tree: Tree): Node = withType( + tree match { + case x: NameTree => atom(x.name.toString, x) + case _ => wrapAtom(tree) + }, + tree.printingPrefix + ) + def wrapSymbol(label: String, sym: Symbol): Node = { + if (sym eq NoSymbol) wrapEmpty + else atom(label, sym) + } + def wrapInfo(sym: Symbol) = sym.info match { + case TypeBounds(lo, hi) => typeBounds(lo, hi) + case PolyType(tparams, restpe) => polyFunction(tparams, restpe) + case _ => wrapEmpty + } + def wrapSymbolInfo(sym: Symbol): Node = { + if ((sym eq NoSymbol) || openSymbols(sym)) wrapEmpty + else { + openSymbols += sym + try product(symbolType(sym), wrapAtom(sym.defString)) + finally openSymbols -= sym + } + } + + def list(nodes: List[Node]): Node = wrapSequence(nodes) + def product(tp: Type, nodes: Node*): Node = product(typeTypeName(tp), nodes: _*) + def product(typeName: String, nodes: Node*): Node = ( + nodes.toList filterNot (_ == wrapEmpty) match { + case Nil => wrapEmpty + case xs => withType(wrapProduct(xs), typeName) + } + ) + + def atom[U](label: String, value: U): Node = node(label, wrapAtom(value)) + def constant(label: String, const: Constant): Node = atom(label, const) + + def scope(decls: Scope): Node = node("decls", scopeMemberList(decls.toList)) + def const[T](named: (String, T)): Node = constant(named._1, Constant(named._2)) + + def resultType(restpe: Type): Node = this("resultType", restpe) + def typeParams(tps: List[Symbol]): Node = node("typeParams", symbolList(tps)) + def valueParams(params: List[Symbol]): Node = node("params", symbolList(params)) + def typeArgs(tps: List[Type]): Node = node("args", typeList(tps)) + def parentList(tps: List[Type]): Node = node("parents", typeList(tps)) + + def polyFunction(tparams: List[Symbol], restpe: Type): Node = wrapPoly(typeParams(tparams), resultType(restpe)) + def monoFunction(params: List[Symbol], restpe: Type): Node = wrapMono(valueParams(params), resultType(restpe)) + def nullaryFunction(restpe: Type): Node = wrapMono(wrapEmpty, this(restpe)) + + def prefix(pre: Type): Node = pre match { + case NoPrefix => wrapEmpty + case _ => this("pre", pre) + } + def typeBounds(lo0: Type, hi0: Type): Node = { + val lo = if ((lo0 eq WildcardType) || (lo0.typeSymbol eq NothingClass)) wrapEmpty else this("lo", lo0) + val hi = if ((hi0 eq WildcardType) || (hi0.typeSymbol eq AnyClass)) wrapEmpty else this("hi", hi0) + + product("TypeBounds", lo, hi) + } + + def annotation(ann: AnnotationInfo): Node = product( + "AnnotationInfo", + this("atp", ann.atp), + node("args", treeList(ann.args)), + assocsNode(ann) + ) + def typeConstraint(constr: TypeConstraint): Node = product( + "TypeConstraint", + node("lo", typeList(constr.loBounds)), + node("hi", typeList(constr.hiBounds)), + this("inst", constr.inst) + ) + def annotatedType(annotations: List[AnnotationInfo], underlying: Type) = product( + "AnnotatedType", + node("annotations", annotationList(annotations)), + this("underlying", underlying) + ) + + /** This imposes additional structure beyond that which is visible in + * the case class hierarchy. In particular, (too) many different constructs + * are encoded in TypeRefs; here they are partitioned somewhat before + * being dispatched. + * + * For example, a typical type parameter is encoded as TypeRef(NoPrefix, sym, Nil) + * with its upper and lower bounds stored in the info of the symbol. Viewing the + * TypeRef naively we are treated to both too much information (useless prefix, usually + * empty args) and too little (bounds hidden behind indirection.) So drop the prefix + * and promote the bounds. + */ + def typeRef(tp: TypeRef) = { + val TypeRef(pre, sym, args) = tp + // Filtered down to elements with "interesting" content + product( + tp, + if (sym.isDefinedInPackage) wrapEmpty else prefix(pre), + wrapSymbolInfo(sym), + typeArgs(args), + if (tp ne tp.normalize) this("normalize", tp.normalize) else wrapEmpty + ) + } + + def symbolType(sym: Symbol) = ( + if (sym.isRefinementClass) "Refinement" + else if (sym.isAliasType) "Alias" + else if (sym.isTypeSkolem) "TypeSkolem" + else if (sym.isTypeParameter) "TypeParam" + else if (sym.isAbstractType) "AbstractType" + else if (sym.isType) "TypeSymbol" + else "TermSymbol" + ) + def typeRefType(sym: Symbol) = ( + if (sym.isRefinementClass) "RefinementTypeRef" + else if (sym.isAliasType) "AliasTypeRef" + else if (sym.isTypeSkolem) "SkolemTypeRef" + else if (sym.isTypeParameter) "TypeParamTypeRef" + else if (sym.isAbstractType) "AbstractTypeRef" + else "TypeRef" + ) + ( if (sym.isFBounded) "(F-Bounded)" else "" ) + + def node(label: String, node: Node): Node = withLabel(node, label) + def apply(label: String, tp: Type): Node = withLabel(this(tp), label) + + def apply(tp: Type): Node = tp match { + case AntiPolyType(pre, targs) => product(tp, prefix(pre), typeArgs(targs)) + case ClassInfoType(parents, decls, clazz) => product(tp, parentList(parents), scope(decls), wrapAtom(clazz)) + case ConstantType(const) => product(tp, constant("value", const)) + case DeBruijnIndex(level, index, args) => product(tp, const("level" -> level), const("index" -> index), typeArgs(args)) + case OverloadedType(pre, alts) => product(tp, prefix(pre), node("alts", typeList(alts map pre.memberType))) + case RefinedType(parents, decls) => product(tp, parentList(parents), scope(decls)) + case SingleType(pre, sym) => product(tp, prefix(pre), wrapAtom(sym)) + case SuperType(thistp, supertp) => product(tp, this("this", thistp), this("super", supertp)) + case ThisType(clazz) => product(tp, wrapAtom(clazz)) + case TypeVar(inst, constr) => product(tp, this("inst", inst), typeConstraint(constr)) + case AnnotatedType(annotations, underlying, _) => annotatedType(annotations, underlying) + case ExistentialType(tparams, underlying) => polyFunction(tparams, underlying) + case PolyType(tparams, restpe) => polyFunction(tparams, restpe) + case MethodType(params, restpe) => monoFunction(params, restpe) + case NullaryMethodType(restpe) => nullaryFunction(restpe) + case TypeBounds(lo, hi) => typeBounds(lo, hi) + case tr @ TypeRef(pre, sym, args) => typeRef(tr) + case _ => wrapAtom(tp) // XXX see what this is + } + } +} diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala index f6d1e42c32..2574a1d241 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala @@ -186,7 +186,7 @@ abstract class Duplicators extends Analyzer { oldClassOwner = oldThis newClassOwner = newThis invalidate(ddef.tparams) - for (vdef <- ddef.vparamss.flatten) { + mforeach(ddef.vparamss) { vdef => invalidate(vdef) vdef.tpe = null } diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 4fb9362ccc..0d7ef71193 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -32,10 +32,10 @@ trait Implicits { import global.typer.{ printTyping, deindentTyping, indentTyping, printInference } def inferImplicit(tree: Tree, pt: Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult = - inferImplicit(tree, pt, reportAmbiguous, isView, context, true, NoPosition) + inferImplicit(tree, pt, reportAmbiguous, isView, context, true, tree.pos) def inferImplicit(tree: Tree, pt: Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult = - inferImplicit(tree, pt, reportAmbiguous, isView, context, saveAmbiguousDivergent, NoPosition) + inferImplicit(tree, pt, reportAmbiguous, isView, context, saveAmbiguousDivergent, tree.pos) /** Search for an implicit value. See the comment on `result` at the end of class `ImplicitSearch` * for more info how the search is conducted. @@ -633,6 +633,7 @@ trait Implicits { else { val subst = new TreeTypeSubstituter(okParams, okArgs) subst traverse itree2 + notifyUndetparamsInferred(okParams, okArgs) subst } @@ -830,7 +831,7 @@ trait Implicits { /** Returns all eligible ImplicitInfos and their SearchResults in a map. */ - def findAll() = (eligible map (info => (info, typedImplicit(info, false)))).toMap + def findAll() = mapFrom(eligible)(typedImplicit(_, false)) /** Returns the SearchResult of the best match. */ @@ -1119,15 +1120,19 @@ trait Implicits { implicitInfoss1 } - // these should be lazy, otherwise we wouldn't be able to compile scala-library with starr - private val TagSymbols = Set(ClassTagClass, TypeTagClass, ConcreteTypeTagClass) - private val TagMaterializers = Map( - ClassTagClass -> MacroInternal_materializeClassTag, - TypeTagClass -> MacroInternal_materializeTypeTag, + private def TagSymbols = TagMaterializers.keySet + private val TagMaterializers = Map[Symbol, Symbol]( + ArrayTagClass -> MacroInternal_materializeArrayTag, + ErasureTagClass -> MacroInternal_materializeErasureTag, + ClassTagClass -> MacroInternal_materializeClassTag, + TypeTagClass -> MacroInternal_materializeTypeTag, ConcreteTypeTagClass -> MacroInternal_materializeConcreteTypeTag ) - def tagOfType(pre: Type, tp: Type, tagClass: Symbol): SearchResult = { + /** Creates a tree will produce a tag of the requested flavor. + * An EmptyTree is returned if materialization fails. + */ + private def tagOfType(pre: Type, tp: Type, tagClass: Symbol): SearchResult = { def success(arg: Tree) = try { val tree1 = typed(atPos(pos.focus)(arg)) @@ -1139,48 +1144,164 @@ trait Implicits { failure(arg, "failed to typecheck the materialized typetag: %n%s".format(ex.msg), ex.pos) } - val prefix = (tagClass, pre) match { - // ClassTags only exist for scala.reflect.mirror, so their materializer doesn't care about prefixes - case (ClassTagClass, _) => - gen.mkAttributedRef(Reflect_mirror) setType singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror) - // [Eugene to Martin] this is the crux of the interaction between implicits and reifiers - // here we need to turn a (supposedly path-dependent) type into a tree that will be used as a prefix - // I'm not sure if I've done this right - please, review - case (_, SingleType(prePre, preSym)) => - gen.mkAttributedRef(prePre, preSym) setType pre - // necessary only to compile typetags used inside the Universe cake - case (_, ThisType(thisSym)) => - gen.mkAttributedThis(thisSym) - case _ => - // if ``pre'' is not a PDT, e.g. if someone wrote - // implicitly[scala.reflect.makro.Context#TypeTag[Int]] - // then we need to fail, because we don't know the prefix to use during type reification - return failure(tp, "tag error: unsupported prefix type %s (%s)".format(pre, pre.kind)) - } - + val prefix = ( + // ClassTags only exist for scala.reflect.mirror, so their materializer + // doesn't care about prefixes + if ((tagClass eq ArrayTagClass) || (tagClass eq ErasureTagClass) || (tagClass eq ClassTagClass)) ReflectMirrorPrefix + else pre match { + // [Eugene to Martin] this is the crux of the interaction between + // implicits and reifiers here we need to turn a (supposedly + // path-dependent) type into a tree that will be used as a prefix I'm + // not sure if I've done this right - please, review + case SingleType(prePre, preSym) => + gen.mkAttributedRef(prePre, preSym) setType pre + // necessary only to compile typetags used inside the Universe cake + case ThisType(thisSym) => + gen.mkAttributedThis(thisSym) + case _ => + // if ``pre'' is not a PDT, e.g. if someone wrote + // implicitly[scala.reflect.makro.Context#TypeTag[Int]] + // then we need to fail, because we don't know the prefix to use during type reification + return failure(tp, "tag error: unsupported prefix type %s (%s)".format(pre, pre.kind)) + } + ) // todo. migrate hardcoded materialization in Implicits to corresponding implicit macros - var materializer = atPos(pos.focus)(Apply(TypeApply(Ident(TagMaterializers(tagClass)), List(TypeTree(tp))), List(prefix))) + var materializer = atPos(pos.focus)( + gen.mkMethodCall(TagMaterializers(tagClass), List(tp), List(prefix)) + ) if (settings.XlogImplicits.value) println("materializing requested %s.%s[%s] using %s".format(pre, tagClass.name, tp, materializer)) - success(materializer) + if (context.macrosEnabled) success(materializer) + else failure(materializer, "macros are disabled") } - /** The manifest corresponding to type `pt`, provided `pt` is an instance of Manifest. + private val ManifestSymbols = Set[Symbol](PartialManifestClass, FullManifestClass, OptManifestClass) + + /** Creates a tree that calls the relevant factory method in object + * reflect.Manifest for type 'tp'. An EmptyTree is returned if + * no manifest is found. todo: make this instantiate take type params as well? + */ + private def manifestOfType(tp: Type, full: Boolean): SearchResult = { + + /** Creates a tree that calls the factory method called constructor in object reflect.Manifest */ + def manifestFactoryCall(constructor: String, tparg: Type, args: Tree*): Tree = + if (args contains EmptyTree) EmptyTree + else typedPos(tree.pos.focus) { + val mani = gen.mkManifestFactoryCall(full, constructor, tparg, args.toList) + if (settings.debug.value) println("generated manifest: "+mani) // DEBUG + mani + } + + /** Creates a tree representing one of the singleton manifests.*/ + def findSingletonManifest(name: String) = typedPos(tree.pos.focus) { + Select(gen.mkAttributedRef(FullManifestModule), name) + } + + /** Re-wraps a type in a manifest before calling inferImplicit on the result */ + def findManifest(tp: Type, manifestClass: Symbol = if (full) FullManifestClass else PartialManifestClass) = + inferImplicit(tree, appliedType(manifestClass, tp), true, false, context).tree + + def findSubManifest(tp: Type) = findManifest(tp, if (full) FullManifestClass else OptManifestClass) + def mot(tp0: Type, from: List[Symbol], to: List[Type]): SearchResult = { + implicit def wrapResult(tree: Tree): SearchResult = + if (tree == EmptyTree) SearchFailure else new SearchResult(tree, if (from.isEmpty) EmptyTreeTypeSubstituter else new TreeTypeSubstituter(from, to)) + + val tp1 = tp0.normalize + tp1 match { + case ThisType(_) | SingleType(_, _) => + // can't generate a reference to a value that's abstracted over by an existential + if (containsExistential(tp1)) EmptyTree + else manifestFactoryCall("singleType", tp, gen.mkAttributedQualifier(tp1)) + case ConstantType(value) => + manifestOfType(tp1.deconst, full) + case TypeRef(pre, sym, args) => + if (isPrimitiveValueClass(sym) || isPhantomClass(sym)) { + findSingletonManifest(sym.name.toString) + } else if (sym == ObjectClass || sym == AnyRefClass) { + findSingletonManifest("Object") + } else if (sym == RepeatedParamClass || sym == ByNameParamClass) { + EmptyTree + } else if (sym == ArrayClass && args.length == 1) { + manifestFactoryCall("arrayType", args.head, findManifest(args.head)) + } else if (sym.isClass) { + val classarg0 = gen.mkClassOf(tp1) + val classarg = tp match { + case _: ExistentialType => gen.mkCast(classarg0, ClassType(tp)) + case _ => classarg0 + } + val suffix = classarg :: (args map findSubManifest) + manifestFactoryCall( + "classType", tp, + (if ((pre eq NoPrefix) || pre.typeSymbol.isStaticOwner) suffix + else findSubManifest(pre) :: suffix): _*) + } else if (sym.isExistentiallyBound && full) { + manifestFactoryCall("wildcardType", tp, + findManifest(tp.bounds.lo), findManifest(tp.bounds.hi)) + } + // looking for a manifest of a type parameter that hasn't been inferred by now, + // can't do much, but let's not fail + else if (undetParams contains sym) { + // #3859: need to include the mapping from sym -> NothingClass.tpe in the SearchResult + mot(NothingClass.tpe, sym :: from, NothingClass.tpe :: to) + } else { + // a manifest should have been found by normal searchImplicit + EmptyTree + } + case RefinedType(parents, decls) => // !!! not yet: if !full || decls.isEmpty => + // refinement is not generated yet + if (hasLength(parents, 1)) findManifest(parents.head) + else if (full) manifestFactoryCall("intersectionType", tp, parents map findSubManifest: _*) + else mot(erasure.intersectionDominator(parents), from, to) + case ExistentialType(tparams, result) => + mot(tp1.skolemizeExistential, from, to) + case _ => + EmptyTree +/* !!! the following is almost right, but we have to splice nested manifest + * !!! types into this type. This requires a substantial extension of + * !!! reifiers. + val reifier = new Reifier() + val rtree = reifier.reifyTopLevel(tp1) + manifestFactoryCall("apply", tp, rtree) +*/ + } + } + + val tagInScope = + if (full) context.withMacrosDisabled(resolveTypeTag(pos, ReflectMirrorPrefix.tpe, tp, true)) + else context.withMacrosDisabled(resolveArrayTag(pos, tp)) + if (tagInScope.isEmpty) mot(tp, Nil, Nil) + else { + val interop = + if (full) gen.mkMethodCall(ReflectPackage, nme.concreteTypeTagToManifest, List(tp), List(tagInScope)) + else gen.mkMethodCall(ReflectPackage, nme.arrayTagToClassManifest, List(tp), List(tagInScope)) + wrapResult(interop) + } + } + + def wrapResult(tree: Tree): SearchResult = + if (tree == EmptyTree) SearchFailure else new SearchResult(tree, EmptyTreeTypeSubstituter) + + /** The tag corresponding to type `pt`, provided `pt` is a flavor of a tag. */ private def implicitTagOrOfExpectedType(pt: Type): SearchResult = pt.dealias match { - case TypeRef(pre, sym, args) if TagSymbols(sym) => - tagOfType(pre, args.head, sym) + case TypeRef(pre, sym, arg :: Nil) if ManifestSymbols(sym) => + manifestOfType(arg, sym == FullManifestClass) match { + case SearchFailure if sym == OptManifestClass => wrapResult(gen.mkAttributedRef(NoManifest)) + case result => result + } + case TypeRef(pre, sym, arg :: Nil) if TagSymbols(sym) => + tagOfType(pre, arg, sym) case tp@TypeRef(_, sym, _) if sym.isAbstractType => implicitTagOrOfExpectedType(tp.bounds.lo) // #3977: use tp (==pt.dealias), not pt (if pt is a type alias, pt.bounds.lo == pt) case _ => searchImplicit(implicitsOfExpectedType, false) // shouldn't we pass `pt` to `implicitsOfExpectedType`, or is the recursive case - // for an abstract type really only meant for manifests? + // for an abstract type really only meant for tags? } /** The result of the implicit search: * First search implicits visible in current context. * If that fails, search implicits in expected type `pt`. - * // [Eugene] the following two lines should be deleted after we migrate delegate manifest materialization to implicit macros + * // [Eugene] the following two lines should be deleted after we migrate delegate tag materialization to implicit macros * If that fails, and `pt` is an instance of a ClassTag, try to construct a class tag. * If that fails, and `pt` is an instance of a TypeTag, try to construct a type tag. * If all fails return SearchFailure diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index 62a0e08aad..353514c397 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -10,6 +10,7 @@ import scala.compat.Platform.EOL import scala.reflect.makro.runtime.{Context => MacroContext} import scala.reflect.runtime.Mirror import util.Statistics._ +import scala.reflect.makro.util._ /** * Code to deal with macros, namely with: @@ -36,13 +37,12 @@ import util.Statistics._ * (Expr(elems)) * (TypeTag(Int)) */ -trait Macros { self: Analyzer => +trait Macros extends Traces { + self: Analyzer => + import global._ import definitions._ - - val macroDebug = settings.Ymacrodebug.value - val macroCopypaste = settings.Ymacrocopypaste.value - val macroTrace = scala.tools.nsc.util.trace when macroDebug + def globalSettings = global.settings val globalMacroCache = collection.mutable.Map[Any, Any]() val perRunMacroCache = perRunCaches.newMap[Symbol, collection.mutable.Map[Any, Any]] @@ -76,7 +76,7 @@ trait Macros { self: Analyzer => case ThisType(sym) if sym == macroDef.owner => SingleType(SingleType(SingleType(NoPrefix, paramsCtx(0)), MacroContextPrefix), ExprValue) case SingleType(NoPrefix, sym) => - vparamss.flatten.find(_.symbol == sym) match { + mfind(vparamss)(_.symbol == sym) match { case Some(macroDefParam) => SingleType(SingleType(NoPrefix, param(macroDefParam)), ExprValue) case _ => @@ -121,7 +121,7 @@ trait Macros { self: Analyzer => val paramsCtx = List(ctxParam) val paramsThis = List(makeParam(nme.macroThis, macroDef.pos, implType(false, ownerTpe), SYNTHETIC)) val paramsTparams = tparams map param - val paramssParams = vparamss map (_ map param) + val paramssParams = mmap(vparamss)(param) var paramsss = List[List[List[Symbol]]]() // tparams are no longer part of a signature, they get into macro implementations via context bounds @@ -136,11 +136,11 @@ trait Macros { self: Analyzer => } import SigGenerator._ - macroTrace("generating macroImplSigs for: ")(macroDef) - macroTrace("tparams are: ")(tparams) - macroTrace("vparamss are: ")(vparamss) - macroTrace("retTpe is: ")(retTpe) - macroTrace("macroImplSigs are: ")(paramsss, implRetTpe) + macroTraceVerbose("generating macroImplSigs for: ")(macroDef) + macroTraceVerbose("tparams are: ")(tparams) + macroTraceVerbose("vparamss are: ")(vparamss) + macroTraceVerbose("retTpe is: ")(retTpe) + macroTraceVerbose("macroImplSigs are: ")(paramsss, implRetTpe) } private def transformTypeTagEvidenceParams(paramss: List[List[Symbol]], transform: (Symbol, Symbol) => Option[Symbol]): List[List[Symbol]] = { @@ -155,7 +155,7 @@ trait Macros { self: Analyzer => case TypeRef(SingleType(NoPrefix, contextParam), sym, List(tparam)) => var wannabe = sym while (wannabe.isAliasType) wannabe = wannabe.info.typeSymbol - if (wannabe != definitions.TypeTagClass) + if (wannabe != definitions.TypeTagClass && wannabe != definitions.ConcreteTypeTagClass) List(param) else transform(param, tparam.typeSymbol) map (_ :: Nil) getOrElse Nil @@ -183,7 +183,7 @@ trait Macros { self: Analyzer => */ def typedMacroBody(typer: Typer, ddef: DefDef): Tree = { import typer.context - if (macroDebug) println("typechecking macro def %s at %s".format(ddef.symbol, ddef.pos)) + macroLogVerbose("typechecking macro def %s at %s".format(ddef.symbol, ddef.pos)) if (!typer.checkFeature(ddef.pos, MacrosFeature, immediate = true)) { ddef.symbol setFlag IS_ERROR @@ -267,7 +267,7 @@ trait Macros { self: Analyzer => val rhs = ddef.rhs validatePreTyper(rhs) - if (hasErrors) macroTrace("macro def failed to satisfy trivial preconditions: ")(macroDef) + if (hasErrors) macroTraceVerbose("macro def failed to satisfy trivial preconditions: ")(macroDef) // we use typed1 instead of typed, because otherwise adapt is going to mess us up // if adapt sees <qualifier>.<method>, it will want to perform eta-expansion and will fail @@ -284,12 +284,7 @@ trait Macros { self: Analyzer => case Success(expanded) => try { val typechecked = typer.typed1(expanded, EXPRmode, WildcardType) - if (macroDebug) { - println("typechecked1:") - println(typechecked) - println(showRaw(typechecked)) - } - + macroLogVerbose("typechecked1:%n%s%n%s".format(typechecked, showRaw(typechecked))) typechecked } finally { openMacros = openMacros.tail @@ -312,7 +307,7 @@ trait Macros { self: Analyzer => var rhs1 = typecheckRhs(rhs) def typecheckedWithErrors = (rhs1 exists (_.isErroneous)) || reporter.ERROR.count != prevNumErrors hasErrors = hasErrors || typecheckedWithErrors - if (typecheckedWithErrors) macroTrace("body of a macro def failed to typecheck: ")(ddef) + if (typecheckedWithErrors) macroTraceVerbose("body of a macro def failed to typecheck: ")(ddef) val macroImpl = rhs1.symbol macroDef withAnnotation AnnotationInfo(MacroImplAnnotation.tpe, List(rhs1), Nil) @@ -330,7 +325,7 @@ trait Macros { self: Analyzer => validatePostTyper(rhs1) } if (hasErrors) - macroTrace("macro def failed to satisfy trivial preconditions: ")(macroDef) + macroTraceVerbose("macro def failed to satisfy trivial preconditions: ")(macroDef) } if (!hasErrors) { @@ -351,6 +346,16 @@ trait Macros { self: Analyzer => if (actparamss.length != reqparamss.length) compatibilityError("number of parameter sections differ") + def checkSubType(slot: String, reqtpe: Type, acttpe: Type): Unit = { + val ok = if (macroDebugVerbose) { + if (reqtpe eq acttpe) println(reqtpe + " <: " + acttpe + "?" + EOL + "true") + withTypesExplained(reqtpe <:< acttpe) + } else reqtpe <:< acttpe + if (!ok) { + compatibilityError("type mismatch for %s: %s does not conform to %s".format(slot, reqtpe.toString.abbreviateCoreAliases, acttpe.toString.abbreviateCoreAliases)) + } + } + if (!hasErrors) { try { for ((rparams, aparams) <- reqparamss zip actparamss) { @@ -376,27 +381,20 @@ trait Macros { self: Analyzer => compatibilityError("types incompatible for parameter "+aparam.name+": corresponding is not a vararg parameter") if (!hasErrors) { var atpe = aparam.tpe.substSym(flatactparams, flatreqparams).instantiateTypeParams(tparams, tvars) - + atpe = atpe.dealias // SI-5706 // strip the { type PrefixType = ... } refinement off the Context or otherwise we get compatibility errors atpe = atpe match { case RefinedType(List(tpe), Scope(sym)) if tpe == MacroContextClass.tpe && sym.allOverriddenSymbols.contains(MacroContextPrefixType) => tpe case _ => atpe } - - val ok = if (macroDebug) withTypesExplained(rparam.tpe <:< atpe) else rparam.tpe <:< atpe - if (!ok) { - compatibilityError("type mismatch for parameter "+rparam.name+": "+rparam.tpe.toString.abbreviateCoreAliases+" does not conform to "+atpe) - } + checkSubType("parameter " + rparam.name, rparam.tpe, atpe) } } } } if (!hasErrors) { val atpe = actres.substSym(flatactparams, flatreqparams).instantiateTypeParams(tparams, tvars) - val ok = if (macroDebug) withTypesExplained(atpe <:< reqres) else atpe <:< reqres - if (!ok) { - compatibilityError("type mismatch for return type : "+reqres.toString.abbreviateCoreAliases+" does not conform to "+(if (ddef.tpt.tpe != null) atpe.toString else atpe.toString.abbreviateCoreAliases)) - } + checkSubType("return type", atpe, reqres) } if (!hasErrors) { val targs = solvedTypes(tvars, tparams, tparams map varianceInType(actres), false, @@ -425,7 +423,7 @@ trait Macros { self: Analyzer => var actparamss = macroImpl.paramss actparamss = transformTypeTagEvidenceParams(actparamss, (param, tparam) => None) - val rettpe = if (ddef.tpt.tpe != null) ddef.tpt.tpe else computeMacroDefTypeFromMacroImpl(ddef, macroDef, macroImpl) + val rettpe = if (!ddef.tpt.isEmpty) typer.typedType(ddef.tpt).tpe else computeMacroDefTypeFromMacroImpl(ddef, macroDef, macroImpl) val (reqparamsss0, reqres0) = macroImplSigs(macroDef, ddef.tparams, ddef.vparamss, rettpe) var reqparamsss = reqparamsss0 @@ -434,7 +432,7 @@ trait Macros { self: Analyzer => val implicitParams = actparamss.flatten filter (_.isImplicit) if (implicitParams.length > 0) { reportError(implicitParams.head.pos, "macro implementations cannot have implicit parameters other than TypeTag evidences") - macroTrace("macro def failed to satisfy trivial preconditions: ")(macroDef) + macroTraceVerbose("macro def failed to satisfy trivial preconditions: ")(macroDef) } if (!hasErrors) { @@ -455,9 +453,9 @@ trait Macros { self: Analyzer => "\n found : "+showMeth(actparamss, actres, false)+ "\n"+addendum) - macroTrace("considering " + reqparamsss.length + " possibilities of compatible macro impl signatures for macro def: ")(ddef.name) + macroTraceVerbose("considering " + reqparamsss.length + " possibilities of compatible macro impl signatures for macro def: ")(ddef.name) val results = reqparamsss map (checkCompatibility(_, actparamss, reqres, actres)) - if (macroDebug) (reqparamsss zip results) foreach { case (reqparamss, result) => + if (macroDebugVerbose) (reqparamsss zip results) foreach { case (reqparamss, result) => println("%s %s".format(if (result.isEmpty) "[ OK ]" else "[FAILED]", reqparamss)) result foreach (errorMsg => println(" " + errorMsg)) } @@ -469,7 +467,7 @@ trait Macros { self: Analyzer => compatibilityError(mostRelevantMessage) } else { assert((results filter (_.isEmpty)).length == 1, results) - if (macroDebug) (reqparamsss zip results) filter (_._2.isEmpty) foreach { case (reqparamss, result) => + if (macroDebugVerbose) (reqparamsss zip results) filter (_._2.isEmpty) foreach { case (reqparamss, result) => println("typechecked macro impl as: " + reqparamss) } } @@ -542,7 +540,7 @@ trait Macros { self: Analyzer => def unsigma(tpe: Type): Type = { // unfortunately, we cannot dereference ``paramss'', because we're in the middle of inferring a type for ``macroDef'' // val defParamss = macroDef.paramss - val defParamss = macroDdef.vparamss map (_ map (_.symbol)) + val defParamss = mmap(macroDdef.vparamss)(_.symbol) var implParamss = macroImpl.paramss implParamss = transformTypeTagEvidenceParams(implParamss, (param, tparam) => None) @@ -593,11 +591,11 @@ trait Macros { self: Analyzer => val libraryClassLoader = { if (settings.XmacroPrimaryClasspath.value != "") { - if (macroDebug) println("primary macro mirror: initializing from -Xmacro-primary-classpath: %s".format(settings.XmacroPrimaryClasspath.value)) + macroLogVerbose("primary macro mirror: initializing from -Xmacro-primary-classpath: %s".format(settings.XmacroPrimaryClasspath.value)) val classpath = toURLs(settings.XmacroFallbackClasspath.value) ScalaClassLoader.fromURLs(classpath, self.getClass.getClassLoader) } else { - if (macroDebug) println("primary macro mirror: initializing from -cp: %s".format(global.classPath.asURLs)) + macroLogVerbose("primary macro mirror: initializing from -cp: %s".format(global.classPath.asURLs)) val classpath = global.classPath.asURLs var loader: ClassLoader = ScalaClassLoader.fromURLs(classpath, self.getClass.getClassLoader) @@ -623,7 +621,7 @@ trait Macros { self: Analyzer => throw new UnsupportedOperationException("Scala reflection not available on this platform") val fallbackClassLoader = { - if (macroDebug) println("fallback macro mirror: initializing from -Xmacro-fallback-classpath: %s".format(settings.XmacroFallbackClasspath.value)) + macroLogVerbose("fallback macro mirror: initializing from -Xmacro-fallback-classpath: %s".format(settings.XmacroFallbackClasspath.value)) val classpath = toURLs(settings.XmacroFallbackClasspath.value) ScalaClassLoader.fromURLs(classpath, self.getClass.getClassLoader) } @@ -641,139 +639,145 @@ trait Macros { self: Analyzer => * @return Some(runtime) if macro implementation can be loaded successfully from either of the mirrors, * None otherwise. */ - private def macroRuntime(macroDef: Symbol): Option[List[Any] => Any] = { - macroTrace("looking for macro implementation: ")(macroDef) - macroTrace("macroDef is annotated with: ")(macroDef.annotations) - - val ann = macroDef.getAnnotation(MacroImplAnnotation) - if (ann == None) { - macroTrace("@macroImpl annotation is missing (this means that macro definition failed to typecheck)")(macroDef) - return None - } - - val macroImpl = ann.get.args(0).symbol - if (macroImpl == NoSymbol) { - macroTrace("@macroImpl annotation is malformed (this means that macro definition failed to typecheck)")(macroDef) - return None - } - - if (macroDebug) println("resolved implementation %s at %s".format(macroImpl, macroImpl.pos)) - if (macroImpl.isErroneous) { - macroTrace("macro implementation is erroneous (this means that either macro body or macro implementation signature failed to typecheck)")(macroDef) - return None - } - - def loadMacroImpl(macroMirror: Mirror): Option[(Object, macroMirror.Symbol)] = { - try { - // this logic relies on the assumptions that were valid for the old macro prototype - // namely that macro implementations can only be defined in top-level classes and modules - // with the new prototype that materialized in a SIP, macros need to be statically accessible, which is different - // for example, a macro def could be defined in a trait that is implemented by an object - // there are some more clever cases when seemingly non-static method ends up being statically accessible - // however, the code below doesn't account for these guys, because it'd take a look of time to get it right - // for now I leave it as a todo and move along to more the important stuff - - macroTrace("loading implementation class from %s: ".format(macroMirror))(macroImpl.owner.fullName) - macroTrace("classloader is: ")("%s of type %s".format(macroMirror.classLoader, if (macroMirror.classLoader != null) macroMirror.classLoader.getClass.toString else "primordial classloader")) - def inferClasspath(cl: ClassLoader) = cl match { - case cl: java.net.URLClassLoader => "[" + (cl.getURLs mkString ",") + "]" - case null => "[" + scala.tools.util.PathResolver.Environment.javaBootClassPath + "]" - case _ => "<unknown>" + private type MacroRuntime = List[Any] => Any + private val macroRuntimesCache = perRunCaches.newWeakMap[Symbol, Option[MacroRuntime]] + private def macroRuntime(macroDef: Symbol): Option[MacroRuntime] = + macroRuntimesCache.getOrElseUpdate(macroDef, { + val runtime = { + macroTraceVerbose("looking for macro implementation: ")(macroDef) + macroTraceVerbose("macroDef is annotated with: ")(macroDef.annotations) + + val ann = macroDef.getAnnotation(MacroImplAnnotation) + if (ann == None) { + macroTraceVerbose("@macroImpl annotation is missing (this means that macro definition failed to typecheck)")(macroDef) + return None } - macroTrace("classpath is: ")(inferClasspath(macroMirror.classLoader)) - - // [Eugene] relies on the fact that macro implementations can only be defined in static classes - // [Martin to Eugene] There's similar logic buried in Symbol#flatname. Maybe we can refactor? - def classfile(sym: Symbol): String = { - def recur(sym: Symbol): String = sym match { - case sym if sym.owner.isPackageClass => - val suffix = if (sym.isModuleClass) "$" else "" - sym.fullName + suffix - case sym => - val separator = if (sym.owner.isModuleClass) "" else "$" - recur(sym.owner) + separator + sym.javaSimpleName.toString - } - if (sym.isClass || sym.isModule) recur(sym) - else recur(sym.enclClass) + val macroImpl = ann.get.args(0).symbol + if (macroImpl == NoSymbol) { + macroTraceVerbose("@macroImpl annotation is malformed (this means that macro definition failed to typecheck)")(macroDef) + return None } - // [Eugene] this doesn't work for inner classes - // neither does macroImpl.owner.javaClassName, so I had to roll my own implementation - //val receiverName = macroImpl.owner.fullName - val implClassName = classfile(macroImpl.owner) - val implClassSymbol: macroMirror.Symbol = macroMirror.symbolForName(implClassName) + macroLogVerbose("resolved implementation %s at %s".format(macroImpl, macroImpl.pos)) + if (macroImpl.isErroneous) { + macroTraceVerbose("macro implementation is erroneous (this means that either macro body or macro implementation signature failed to typecheck)")(macroDef) + return None + } - if (macroDebug) { - println("implClassSymbol is: " + implClassSymbol.fullNameString) + def loadMacroImpl(macroMirror: Mirror): Option[(Object, macroMirror.Symbol)] = { + try { + // this logic relies on the assumptions that were valid for the old macro prototype + // namely that macro implementations can only be defined in top-level classes and modules + // with the new prototype that materialized in a SIP, macros need to be statically accessible, which is different + // for example, a macro def could be defined in a trait that is implemented by an object + // there are some more clever cases when seemingly non-static method ends up being statically accessible + // however, the code below doesn't account for these guys, because it'd take a look of time to get it right + // for now I leave it as a todo and move along to more the important stuff + + macroTraceVerbose("loading implementation class from %s: ".format(macroMirror))(macroImpl.owner.fullName) + macroTraceVerbose("classloader is: ")("%s of type %s".format(macroMirror.classLoader, if (macroMirror.classLoader != null) macroMirror.classLoader.getClass.toString else "primordial classloader")) + def inferClasspath(cl: ClassLoader) = cl match { + case cl: java.net.URLClassLoader => "[" + (cl.getURLs mkString ",") + "]" + case null => "[" + scala.tools.util.PathResolver.Environment.javaBootClassPath + "]" + case _ => "<unknown>" + } + macroTraceVerbose("classpath is: ")(inferClasspath(macroMirror.classLoader)) + + // [Eugene] relies on the fact that macro implementations can only be defined in static classes + // [Martin to Eugene] There's similar logic buried in Symbol#flatname. Maybe we can refactor? + def classfile(sym: Symbol): String = { + def recur(sym: Symbol): String = sym match { + case sym if sym.owner.isPackageClass => + val suffix = if (sym.isModuleClass) "$" else "" + sym.fullName + suffix + case sym => + val separator = if (sym.owner.isModuleClass) "" else "$" + recur(sym.owner) + separator + sym.javaSimpleName.toString + } - if (implClassSymbol != macroMirror.NoSymbol) { - val implClass = macroMirror.classToJava(implClassSymbol) - val implSource = implClass.getProtectionDomain.getCodeSource - println("implClass is %s from %s".format(implClass, implSource)) - println("implClassLoader is %s with classpath %s".format(implClass.getClassLoader, inferClasspath(implClass.getClassLoader))) - } - } + if (sym.isClass || sym.isModule) recur(sym) + else recur(sym.enclClass) + } - val implObjSymbol = implClassSymbol.companionModule - macroTrace("implObjSymbol is: ")(implObjSymbol.fullNameString) + // [Eugene] this doesn't work for inner classes + // neither does macroImpl.owner.javaClassName, so I had to roll my own implementation + //val receiverName = macroImpl.owner.fullName + val implClassName = classfile(macroImpl.owner) + val implClassSymbol: macroMirror.Symbol = macroMirror.symbolForName(implClassName) - if (implObjSymbol == macroMirror.NoSymbol) None - else { - // yet another reflection method that doesn't work for inner classes - //val receiver = macroMirror.companionInstance(receiverClass) - val implObj = try { - val implObjClass = java.lang.Class.forName(implClassName, true, macroMirror.classLoader) - implObjClass getField "MODULE$" get null - } catch { - case ex: NoSuchFieldException => macroTrace("exception when loading implObj: ")(ex); null - case ex: NoClassDefFoundError => macroTrace("exception when loading implObj: ")(ex); null - case ex: ClassNotFoundException => macroTrace("exception when loading implObj: ")(ex); null - } + if (macroDebugVerbose) { + println("implClassSymbol is: " + implClassSymbol.fullNameString) - if (implObj == null) None - else { - val implMethSymbol = implObjSymbol.info.member(macroMirror.newTermName(macroImpl.name.toString)) - if (macroDebug) { - println("implMethSymbol is: " + implMethSymbol.fullNameString) - println("jimplMethSymbol is: " + macroMirror.methodToJava(implMethSymbol)) + if (implClassSymbol != macroMirror.NoSymbol) { + val implClass = macroMirror.classToJava(implClassSymbol) + val implSource = implClass.getProtectionDomain.getCodeSource + println("implClass is %s from %s".format(implClass, implSource)) + println("implClassLoader is %s with classpath %s".format(implClass.getClassLoader, inferClasspath(implClass.getClassLoader))) + } } - if (implMethSymbol == macroMirror.NoSymbol) None + val implObjSymbol = implClassSymbol.companionModule + macroTraceVerbose("implObjSymbol is: ")(implObjSymbol.fullNameString) + + if (implObjSymbol == macroMirror.NoSymbol) None else { - if (macroDebug) println("successfully loaded macro impl as (%s, %s)".format(implObj, implMethSymbol)) - Some((implObj, implMethSymbol)) + // yet another reflection method that doesn't work for inner classes + //val receiver = macroMirror.companionInstance(receiverClass) + val implObj = try { + val implObjClass = java.lang.Class.forName(implClassName, true, macroMirror.classLoader) + implObjClass getField "MODULE$" get null + } catch { + case ex: NoSuchFieldException => macroTraceVerbose("exception when loading implObj: ")(ex); null + case ex: NoClassDefFoundError => macroTraceVerbose("exception when loading implObj: ")(ex); null + case ex: ClassNotFoundException => macroTraceVerbose("exception when loading implObj: ")(ex); null + } + + if (implObj == null) None + else { + val implMethSymbol = implObjSymbol.info.member(macroMirror.newTermName(macroImpl.name.toString)) + macroLogVerbose("implMethSymbol is: " + implMethSymbol.fullNameString) + macroLogVerbose("jimplMethSymbol is: " + macroMirror.methodToJava(implMethSymbol)) + + if (implMethSymbol == macroMirror.NoSymbol) None + else { + macroLogVerbose("successfully loaded macro impl as (%s, %s)".format(implObj, implMethSymbol)) + Some((implObj, implMethSymbol)) + } + } } + } catch { + case ex: ClassNotFoundException => + macroTraceVerbose("implementation class failed to load: ")(ex.toString) + None } } - } catch { - case ex: ClassNotFoundException => - macroTrace("implementation class failed to load: ")(ex.toString) - None - } - } - val primary = loadMacroImpl(primaryMirror) - primary match { - case Some((implObj, implMethSymbol)) => - def runtime(args: List[Any]) = primaryMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any] - Some(runtime) - case None => - if (settings.XmacroFallbackClasspath.value != "") { - if (macroDebug) println("trying to load macro implementation from the fallback mirror: %s".format(settings.XmacroFallbackClasspath.value)) - val fallback = loadMacroImpl(fallbackMirror) - fallback match { - case Some((implObj, implMethSymbol)) => - def runtime(args: List[Any]) = fallbackMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any] - Some(runtime) - case None => + val primary = loadMacroImpl(primaryMirror) + primary match { + case Some((implObj, implMethSymbol)) => + def runtime(args: List[Any]) = primaryMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any] + Some(runtime _) + case None => + if (settings.XmacroFallbackClasspath.value != "") { + macroLogVerbose("trying to load macro implementation from the fallback mirror: %s".format(settings.XmacroFallbackClasspath.value)) + val fallback = loadMacroImpl(fallbackMirror) + fallback match { + case Some((implObj, implMethSymbol)) => + def runtime(args: List[Any]) = fallbackMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any] + Some(runtime _) + case None => + None + } + } else { None - } - } else { - None + } } - } - } + } + + if (runtime == None) macroDef setFlag IS_ERROR + runtime + }) /** Should become private again once we're done with migrating typetag generation from implicits */ def macroContext(typer: Typer, prefixTree: Tree, expandeeTree: Tree): MacroContext { val mirror: global.type } = @@ -784,7 +788,7 @@ trait Macros { self: Analyzer => val prefix = Expr(prefixTree)(TypeTag.Nothing) val expandee = expandeeTree } with MacroContext { - override def toString = "MacroContext(%s@%s +%d)".format(expandee.symbol.name, expandee.pos, openMacros.length - 1 /* exclude myself */) + override def toString = "MacroContext(%s@%s +%d)".format(expandee.symbol.name, expandee.pos, enclosingMacros.length - 1 /* exclude myself */) } /** Calculate the arguments to pass to a macro implementation when expanding the provided tree. @@ -795,9 +799,12 @@ trait Macros { self: Analyzer => * @return list of runtime objects to pass to the implementation obtained by ``macroRuntime'' */ private def macroArgs(typer: Typer, expandee: Tree): Option[List[Any]] = { + val macroDef = expandee.symbol + val runtime = macroRuntime(macroDef) orElse { return None } var prefixTree: Tree = EmptyTree - var typeArgs = List[Tree]() - val exprArgs = new ListBuffer[List[Expr[_]]] + var typeArgs = List[Tree]() + val exprArgs = ListBuffer[List[Expr[_]]]() + def collectMacroArgs(tree: Tree): Unit = tree match { case Apply(fn, args) => // todo. infer precise typetag for this Expr, namely the declared type of the corresponding macro impl argument @@ -811,16 +818,15 @@ trait Macros { self: Analyzer => case _ => } collectMacroArgs(expandee) - val context = macroContext(typer, prefixTree, expandee) + val context = expandee.attachmentOpt[MacroAttachment].flatMap(_.macroContext).getOrElse(macroContext(typer, prefixTree, expandee)) var argss: List[List[Any]] = List(context) :: exprArgs.toList - macroTrace("argss: ")(argss) + macroTraceVerbose("argss: ")(argss) - val macroDef = expandee.symbol val ann = macroDef.getAnnotation(MacroImplAnnotation).getOrElse(throw new Error("assertion failed. %s: %s".format(macroDef, macroDef.annotations))) val macroImpl = ann.args(0).symbol var paramss = macroImpl.paramss val tparams = macroImpl.typeParams - macroTrace("paramss: ")(paramss) + macroTraceVerbose("paramss: ")(paramss) // we need to take care of all possible combos of nullary/empty-paramlist macro defs vs nullary/empty-arglist invocations // nullary def + nullary invocation => paramss and argss match, everything is okay @@ -829,10 +835,10 @@ trait Macros { self: Analyzer => // empty-paramlist def + empty-arglist invocation => paramss and argss match, everything is okay // that's almost it, but we need to account for the fact that paramss might have context bounds that mask the empty last paramlist val paramss_without_evidences = transformTypeTagEvidenceParams(paramss, (param, tparam) => None) - val isEmptyParamlistDef = paramss_without_evidences.length != 0 && paramss_without_evidences.last.isEmpty - val isEmptyArglistInvocation = argss.length != 0 && argss.last.isEmpty + val isEmptyParamlistDef = paramss_without_evidences.nonEmpty && paramss_without_evidences.last.isEmpty + val isEmptyArglistInvocation = argss.nonEmpty && argss.last.isEmpty if (isEmptyParamlistDef && !isEmptyArglistInvocation) { - if (macroDebug) println("isEmptyParamlistDef && !isEmptyArglistInvocation: appending a List() to argss") + macroLogVerbose("isEmptyParamlistDef && !isEmptyArglistInvocation: appending a List() to argss") argss = argss :+ Nil } @@ -840,7 +846,7 @@ trait Macros { self: Analyzer => val numParamLists = paramss_without_evidences.length val numArgLists = argss.length if (numParamLists != numArgLists) { - typer.context.error(expandee.pos, "macros cannot be partially applied") + typer.TyperErrorGen.MacroPartialApplicationError(expandee) return None } @@ -860,9 +866,8 @@ trait Macros { self: Analyzer => // then T and U need to be inferred from the lexical scope of the call using ``asSeenFrom'' // whereas V won't be resolved by asSeenFrom and need to be loaded directly from ``expandee'' which needs to contain a TypeApply node // also, macro implementation reference may contain a regular type as a type argument, then we pass it verbatim - paramss = transformTypeTagEvidenceParams(paramss, (param, tparam) => Some(tparam)) - if (paramss.lastOption map (params => !params.isEmpty && params.forall(_.isType)) getOrElse false) argss = argss :+ Nil - val evidences = paramss.last takeWhile (_.isType) map (tparam => { + val resolved = collection.mutable.Map[Symbol, Type]() + paramss = transformTypeTagEvidenceParams(paramss, (param, tparam) => { val TypeApply(_, implRefTargs) = ann.args(0) var implRefTarg = implRefTargs(tparam.paramPos).tpe.typeSymbol val tpe = if (implRefTarg.isTypeParameterOrSkolem) { @@ -878,13 +883,28 @@ trait Macros { self: Analyzer => macroDef.owner) } else implRefTarg.tpe - if (macroDebug) println("resolved tparam %s as %s".format(tparam, tpe)) - tpe - }) map (tpe => { - val ttag = TypeTag(tpe) + macroLogVerbose("resolved tparam %s as %s".format(tparam, tpe)) + resolved(tparam) = tpe + param.tpe.typeSymbol match { + case definitions.TypeTagClass => + // do nothing + case definitions.ConcreteTypeTagClass => + if (!tpe.isConcrete) context.abort(context.enclosingPosition, "cannot create ConcreteTypeTag from a type %s having unresolved type parameters".format(tpe)) + // otherwise do nothing + case _ => + throw new Error("unsupported tpe: " + tpe) + } + Some(tparam) + }) + val tags = paramss.last takeWhile (_.isType) map (resolved(_)) map (tpe => { + // generally speaking, it's impossible to calculate erasure from a tpe here + // the tpe might be compiled by this run, so its jClass might not exist yet + // hence I just pass `null` instead and leave this puzzle to macro programmers + val ttag = TypeTag(tpe, null) if (ttag.isConcrete) ttag.toConcrete else ttag }) - argss = argss.dropRight(1) :+ (evidences ++ argss.last) + if (paramss.lastOption map (params => !params.isEmpty && params.forall(_.isType)) getOrElse false) argss = argss :+ Nil + argss = argss.dropRight(1) :+ (tags ++ argss.last) // todo. add support for context bounds in argss assert(argss.length == paramss.length, "argss: %s, paramss: %s".format(argss, paramss)) val rawArgss = for ((as, ps) <- argss zip paramss) yield { @@ -892,7 +912,7 @@ trait Macros { self: Analyzer => else as } val rawArgs = rawArgss.flatten - macroTrace("rawArgs: ")(rawArgs) + macroTraceVerbose("rawArgs: ")(rawArgs) Some(rawArgs) } @@ -900,6 +920,7 @@ trait Macros { self: Analyzer => * See more informations in comments to ``openMacros'' in ``scala.reflect.makro.Context''. */ var openMacros = List[MacroContext]() + def enclosingMacroPosition = openMacros map (_.macroApplication.pos) find (_ ne NoPosition) getOrElse NoPosition /** Performs macro expansion: * 1) Checks whether the expansion needs to be delayed (see ``mustDelayMacroExpansion'') @@ -908,13 +929,13 @@ trait Macros { self: Analyzer => * 4) Checks that the result is a tree bound to this universe * 5) Typechecks the result against the return type of the macro definition * - * If -Ymacro-debug is enabled, you will get detailed log of how exactly this function + * If -Ymacro-debug-lite is enabled, you will get basic notifications about macro expansion + * along with macro expansions logged in the form that can be copy/pasted verbatim into REPL. + * + * If -Ymacro-debug-verbose is enabled, you will get detailed log of how exactly this function * performs class loading and method resolution in order to load the macro implementation. * The log will also include other non-trivial steps of macro expansion. * - * If -Ymacro-copypaste is enabled along with -Ymacro-debug, you will get macro expansions - * logged in the form that can be copy/pasted verbatim into REPL (useful for debugging!). - * * @return * the expansion result if the expansion has been successful, * the fallback method invocation if the expansion has been unsuccessful, but there is a fallback, @@ -923,64 +944,74 @@ trait Macros { self: Analyzer => * the expandee with an error marker set if the expansion has been cancelled due malformed arguments or implementation * the expandee with an error marker set if there has been an error */ - def macroExpand(typer: Typer, expandee: Tree, pt: Type): Tree = - macroExpand1(typer, expandee) match { - case Success(expanded) => - try { - var expectedTpe = expandee.tpe - - // [Eugene] weird situation. what's the conventional way to deal with it? - val isNullaryInvocation = expandee match { - case TypeApply(Select(_, _), _) => true - case Select(_, _) => true - case _ => false - } - if (isNullaryInvocation) expectedTpe match { - case MethodType(Nil, restpe) => - macroTrace("nullary invocation of a method with an empty parameter list. unwrapping expectedTpe from " + expectedTpe + " to:")(restpe) - expectedTpe = restpe - case _ => ; - } + def macroExpand(typer: Typer, expandee: Tree, mode: Int = EXPRmode, pt: Type = WildcardType): Tree = { + def fail(what: String, tree: Tree): Tree = { + val err = typer.context.errBuffer.head + this.fail(typer, tree, "failed to %s: %s at %s".format(what, err.errMsg, err.errPos)) + return expandee + } + val start = startTimer(macroExpandNanos) + incCounter(macroExpandCount) + try { + macroExpand1(typer, expandee) match { + case Success(expanded) => + try { + var expectedTpe = expandee.tpe + + // [Eugene] weird situation. what's the conventional way to deal with it? + val isNullaryInvocation = expandee match { + case TypeApply(Select(_, _), _) => true + case TypeApply(Ident(_), _) => true + case Select(_, _) => true + case Ident(_) => true + case _ => false + } + if (isNullaryInvocation) expectedTpe match { + case NullaryMethodType(restpe) => + macroTraceVerbose("nullary invocation of a nullary method. unwrapping expectedTpe from " + expectedTpe + " to: ")(restpe) + expectedTpe = restpe + case MethodType(Nil, restpe) => + macroTraceVerbose("nullary invocation of a method with an empty parameter list. unwrapping expectedTpe from " + expectedTpe + " to: ")(restpe) + expectedTpe = restpe + case _ => ; + } - var typechecked = typer.context.withImplicitsEnabled(typer.typed(expanded, EXPRmode, expectedTpe)) - if (macroDebug) { - println("typechecked1:") - println(typechecked) - println(showRaw(typechecked)) - } + macroLogVerbose("typechecking1 against %s: %s".format(expectedTpe, expanded)) + var typechecked = typer.context.withImplicitsEnabled(typer.typed(expanded, EXPRmode, expectedTpe)) + if (typer.context.hasErrors) fail("typecheck against macro def return type", expanded) + macroLogVerbose("typechecked1:%n%s%n%s".format(typechecked, showRaw(typechecked))) - typechecked = typer.context.withImplicitsEnabled(typer.typed(typechecked, EXPRmode, pt)) - if (macroDebug) { - println("typechecked2:") - println(typechecked) - println(showRaw(typechecked)) - } + macroLogVerbose("typechecking2 against %s: %s".format(pt, expanded)) + typechecked = typer.context.withImplicitsEnabled(typer.typed(typechecked, EXPRmode, pt)) + if (typer.context.hasErrors) fail("typecheck against expected type", expanded) + macroLogVerbose("typechecked2:%n%s%n%s".format(typechecked, showRaw(typechecked))) - typechecked - } finally { - openMacros = openMacros.tail - } - case Fallback(fallback) => - typer.context.withImplicitsEnabled(typer.typed(fallback, EXPRmode, pt)) - case Other(result) => - result + typechecked + } finally { + openMacros = openMacros.tail + } + case Fallback(fallback) => + typer.context.withImplicitsEnabled(typer.typed(fallback, EXPRmode, pt)) + case Other(result) => + result + } + } finally { + stopTimer(macroExpandNanos, start) } + } private sealed abstract class MacroExpansionResult extends Product with Serializable private case class Success(expanded: Tree) extends MacroExpansionResult private case class Fallback(fallback: Tree) extends MacroExpansionResult private case class Other(result: Tree) extends MacroExpansionResult - private def Delay(expandee: Tree) = Other(expandee) + private def Delay(expanded: Tree) = Other(expanded) private def Skip(expanded: Tree) = Other(expanded) private def Cancel(expandee: Tree) = Other(expandee) private def Failure(expandee: Tree) = Other(expandee) private def fail(typer: Typer, expandee: Tree, msg: String = null) = { - if (macroDebug || macroCopypaste) { - var msg1 = if (msg contains "exception during macro expansion") msg.split(EOL).drop(1).headOption.getOrElse("?") else msg - if (macroDebug) msg1 = msg - println("macro expansion has failed: %s".format(msg1)) - } - val pos = if (expandee.pos != NoPosition) expandee.pos else openMacros.find(c => c.expandee.pos != NoPosition).map(_.expandee.pos).getOrElse(NoPosition) + def msgForLog = if (msg != null && (msg contains "exception during macro expansion")) msg.split(EOL).drop(1).headOption.getOrElse("?") else msg + macroLogLite("macro expansion has failed: %s".format(msgForLog)) + val pos = if (expandee.pos != NoPosition) expandee.pos else enclosingMacroPosition if (msg != null) typer.context.error(pos, msg) typer.infer.setError(expandee) Failure(expandee) @@ -989,191 +1020,204 @@ trait Macros { self: Analyzer => /** Does the same as ``macroExpand'', but without typechecking the expansion * Meant for internal use within the macro infrastructure, don't use it elsewhere. */ - private def macroExpand1(typer: Typer, expandee: Tree): MacroExpansionResult = { - // if a macro implementation is incompatible or any of the arguments are erroneous - // there is no sense to expand the macro itself => it will only make matters worse - if (expandee.symbol.isErroneous || (expandee exists (_.isErroneous))) { - val reason = if (expandee.symbol.isErroneous) "incompatible macro implementation" else "erroneous arguments" - macroTrace("cancelled macro expansion because of %s: ".format(reason))(expandee) - return Cancel(typer.infer.setError(expandee)) - } + private def macroExpand1(typer: Typer, expandee: Tree): MacroExpansionResult = + // InfoLevel.Verbose examines and prints out infos of symbols + // by the means of this'es these symbols can climb up the lexical scope + // when these symbols will be examined by a node printer + // they will enumerate and analyze their children (ask for infos and tpes) + // if one of those children involves macro expansion, things might get nasty + // that's why I'm temporarily turning this behavior off + withInfoLevel(nodePrinters.InfoLevel.Quiet) { + // if a macro implementation is incompatible or any of the arguments are erroneous + // there is no sense to expand the macro itself => it will only make matters worse + if (expandee.symbol.isErroneous || (expandee exists (_.isErroneous))) { + val reason = if (expandee.symbol.isErroneous) "incompatible macro implementation" else "erroneous arguments" + macroTraceVerbose("cancelled macro expansion because of %s: ".format(reason))(expandee) + return Cancel(typer.infer.setError(expandee)) + } - if (!isDelayed(expandee)) { - if (macroDebug || macroCopypaste) println("typechecking macro expansion %s at %s".format(expandee, expandee.pos)) + macroRuntime(expandee.symbol) match { + case Some(runtime) => + macroExpandWithRuntime(typer, expandee, runtime) + case None => + macroExpandWithoutRuntime(typer, expandee) + } + } + /** Expands a macro when a runtime (i.e. the macro implementation) can be successfully loaded + * Meant for internal use within the macro infrastructure, don't use it elsewhere. + */ + private def macroExpandWithRuntime(typer: Typer, expandee: Tree, runtime: MacroRuntime): MacroExpansionResult = { + def issueFreeError(sym: FreeSymbol) = { + val template = ( + "Macro expansion contains free @kind@ variable %s. Have you forgotten to use %s? " + + "If you have troubles tracking free @kind@ variables, consider using -Xlog-free-@kind@s" + ) + val forgotten = ( + if (sym.isTerm) "eval when splicing this variable into a reifee" + else "c.TypeTag annotation for this type parameter" + ) + typer.context.error(expandee.pos, + template.replaceAllLiterally("@kind@", sym.name.nameKind).format( + sym.name + " " + sym.origin, forgotten) + ) + } + def macroExpandInternal = { + val wasDelayed = isDelayed(expandee) val undetparams = calculateUndetparams(expandee) - if (undetparams.size != 0) { - macroTrace("macro expansion is delayed: ")(expandee) - delayed += expandee -> (typer.context, undetparams) - Delay(expandee) - } else { - val start = startTimer(macroExpandNanos) - incCounter(macroExpandCount) - try { - val macroDef = expandee.symbol - macroRuntime(macroDef) match { - case Some(runtime) => - val savedInfolevel = nodePrinters.infolevel - try { - // InfoLevel.Verbose examines and prints out infos of symbols - // by the means of this'es these symbols can climb up the lexical scope - // when these symbols will be examined by a node printer - // they will enumerate and analyze their children (ask for infos and tpes) - // if one of those children involves macro expansion, things might get nasty - // that's why I'm temporarily turning this behavior off - nodePrinters.infolevel = nodePrinters.InfoLevel.Quiet - val args = macroArgs(typer, expandee) - args match { - case Some(args) => - // adding stuff to openMacros is easy, but removing it is a nightmare - // it needs to be sprinkled over several different code locations - val (context: MacroContext) :: _ = args - openMacros = context :: openMacros - val expanded: MacroExpansionResult = try { - val prevNumErrors = reporter.ERROR.count - val expanded = runtime(args) - val currNumErrors = reporter.ERROR.count - if (currNumErrors != prevNumErrors) { - fail(typer, expandee) // errors have been reported by the macro itself - } else { - expanded match { - case expanded: Expr[_] => - if (macroDebug || macroCopypaste) { - if (macroDebug) println("original:") - println(expanded.tree) - println(showRaw(expanded.tree)) - } - - freeTerms(expanded.tree) foreach (fte => typer.context.error(expandee.pos, - ("macro expansion contains free term variable %s %s. "+ - "have you forgot to use eval when splicing this variable into a reifee? " + - "if you have troubles tracking free term variables, consider using -Xlog-free-terms").format(fte.name, fte.origin))) - freeTypes(expanded.tree) foreach (fty => typer.context.error(expandee.pos, - ("macro expansion contains free type variable %s %s. "+ - "have you forgot to use c.TypeTag annotation for this type parameter? " + - "if you have troubles tracking free type variables, consider using -Xlog-free-types").format(fty.name, fty.origin))) - - val currNumErrors = reporter.ERROR.count - if (currNumErrors != prevNumErrors) { - fail(typer, expandee) - } else { - // inherit the position from the first position-ful expandee in macro callstack - // this is essential for sane error messages - var tree = expanded.tree - var position = openMacros.find(c => c.expandee.pos != NoPosition).map(_.expandee.pos).getOrElse(NoPosition) - tree = atPos(position.focus)(tree) - - // now macro expansion gets typechecked against the macro definition return type - // however, this happens in macroExpand, not here in macroExpand1 - Success(tree) - } - case expanded if expanded.isInstanceOf[Expr[_]] => - val msg = "macro must return a compiler-specific expr; returned value is Expr, but it doesn't belong to this compiler's universe" - fail(typer, expandee, msg) - case expanded => - val msg = "macro must return a compiler-specific expr; returned value is of class: %s".format(expanded.getClass) - fail(typer, expandee, msg) - } - } - } catch { - case ex: Throwable => - openMacros = openMacros.tail - throw ex - } - if (!expanded.isInstanceOf[Success]) openMacros = openMacros.tail - expanded - case None => - fail(typer, expandee) // error has been reported by macroArgs - } - } catch { - case ex => - // [Eugene] any ideas about how to improve this one? - val realex = ReflectionUtils.unwrapThrowable(ex) - realex match { - case realex: reflect.makro.runtime.AbortMacroException => - if (macroDebug || macroCopypaste) println("macro expansion has failed: %s".format(realex.msg)) - fail(typer, expandee) // error has been reported by abort - case _ => - val message = { - try { - // the most reliable way of obtaining currently executing method - // http://stackoverflow.com/questions/442747/getting-the-name-of-the-current-executing-method - val currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName - val relevancyThreshold = realex.getStackTrace().indexWhere(este => este.getMethodName == currentMethodName) - if (relevancyThreshold == -1) None - else { - var relevantElements = realex.getStackTrace().take(relevancyThreshold + 1) - var framesTillReflectiveInvocationOfMacroImpl = relevantElements.reverse.indexWhere(_.isNativeMethod) + 1 - relevantElements = relevantElements dropRight framesTillReflectiveInvocationOfMacroImpl - - realex.setStackTrace(relevantElements) - val message = new java.io.StringWriter() - realex.printStackTrace(new java.io.PrintWriter(message)) - Some(EOL + message) - } - } catch { - // if the magic above goes boom, just fall back to uninformative, but better than nothing, getMessage - case ex: Throwable => - None - } - } getOrElse realex.getMessage - fail(typer, expandee, "exception during macro expansion: " + message) - } - } finally { - nodePrinters.infolevel = savedInfolevel - } - case None => - def notFound() = { - typer.context.error(expandee.pos, "macro implementation not found: " + macroDef.name + " " + - "(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)\n" + - "if you do need to define macro implementations along with the rest of your program, consider two-phase compilation with -Xmacro-fallback-classpath " + - "in the second phase pointing to the output of the first phase") - None - } - def fallBackToOverridden(tree: Tree): Option[Tree] = { - tree match { - case Select(qual, name) if (macroDef.isTermMacro) => - macroDef.allOverriddenSymbols match { - case first :: _ => - Some(Select(qual, name) setPos tree.pos setSymbol first) - case _ => - macroTrace("macro is not overridden: ")(tree) - notFound() - } - case Apply(fn, args) => - fallBackToOverridden(fn) match { - case Some(fn1) => Some(Apply(fn1, args) setPos tree.pos) - case _ => None - } - case TypeApply(fn, args) => - fallBackToOverridden(fn) match { - case Some(fn1) => Some(TypeApply(fn1, args) setPos tree.pos) - case _ => None - } - case _ => - macroTrace("unexpected tree in fallback: ")(tree) - notFound() - } + val nowDelayed = !typer.context.macrosEnabled || undetparams.nonEmpty + + def failExpansion(msg: String = null) = fail(typer, expandee, msg) + def performExpansion(args: List[Any]): MacroExpansionResult = { + val numErrors = reporter.ERROR.count + def hasNewErrors = reporter.ERROR.count > numErrors + + val expanded = runtime(args) + + if (hasNewErrors) + failExpansion() // errors have been reported by the macro itself + else expanded match { + case expanded: Expr[_] => + macroLogVerbose("original:") + macroLogLite("" + expanded.tree + "\n" + showRaw(expanded.tree)) + + freeTerms(expanded.tree) foreach issueFreeError + freeTypes(expanded.tree) foreach issueFreeError + if (hasNewErrors) failExpansion() + + // inherit the position from the first position-ful expandee in macro callstack + // this is essential for sane error messages + // now macro expansion gets typechecked against the macro definition return type + // however, this happens in macroExpand, not here in macroExpand1 + else Success(atPos(enclosingMacroPosition.focus)(expanded.tree)) + case _ => + failExpansion( + "macro must return a compiler-specific expr; returned value is " + ( + if (expanded.isInstanceOf[Expr[_]]) " Expr, but it doesn't belong to this compiler's universe" + else " of " + expanded.getClass + ) + ) + } + } + + if (wasDelayed) { + if (nowDelayed) Delay(expandee) + else Skip(macroExpandAll(typer, expandee)) + } + else { + macroLogLite("typechecking macro expansion %s at %s".format(expandee, expandee.pos)) + macroArgs(typer, expandee).fold(failExpansion(): MacroExpansionResult) { + case args @ ((context: MacroContext) :: _) => + if (nowDelayed) { + macroLogLite("macro expansion is delayed: %s".format(expandee)) + delayed += expandee -> undetparams + // need to save typer context for `macroExpandAll` + // need to save macro context to preserve enclosures + expandee attach MacroAttachment(delayed = true, typerContext = typer.context, macroContext = Some(context)) + Delay(expandee) + } + else { + // adding stuff to openMacros is easy, but removing it is a nightmare + // it needs to be sprinkled over several different code locations + // why? https://github.com/scala/scala/commit/bd3eacbae21f39b1ac7fe8ade4ed71fa98e1a28d#L2R1137 + // todo. will be improved + openMacros ::= context + var isSuccess = false + try performExpansion(args) match { + case x: Success => isSuccess = true ; x + case x => x } - fallBackToOverridden(expandee) match { - case Some(tree1) => - macroTrace("falling back to ")(tree1) - currentRun.macroExpansionFailed = true - Fallback(tree1) - case None => - fail(typer, expandee) + finally { + expandee.detach(classOf[MacroAttachment]) + if (!isSuccess) openMacros = openMacros.tail } - } - } finally { - stopTimer(macroExpandNanos, start) + } } } - } else { - val undetparams = calculateUndetparams(expandee) - if (undetparams.size != 0) - Delay(expandee) - else - Skip(macroExpandAll(typer, expandee)) + } + + try macroExpandInternal + catch { case ex => handleMacroExpansionException(typer, expandee, ex) } + } + + private def macroExpandWithoutRuntime(typer: Typer, expandee: Tree): MacroExpansionResult = { + val macroDef = expandee.symbol + def notFound() = { + typer.context.error(expandee.pos, "macro implementation not found: " + macroDef.name + " " + + "(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)\n" + + "if you do need to define macro implementations along with the rest of your program, consider two-phase compilation with -Xmacro-fallback-classpath " + + "in the second phase pointing to the output of the first phase") + None + } + def fallBackToOverridden(tree: Tree): Option[Tree] = { + tree match { + case Select(qual, name) if (macroDef.isTermMacro) => + macroDef.allOverriddenSymbols match { + case first :: _ => + Some(Select(qual, name) setPos tree.pos setSymbol first) + case _ => + macroTraceVerbose("macro is not overridden: ")(tree) + notFound() + } + case Apply(fn, args) => + fallBackToOverridden(fn) match { + case Some(fn1) => Some(Apply(fn1, args) setPos tree.pos) + case _ => None + } + case TypeApply(fn, args) => + fallBackToOverridden(fn) match { + case Some(fn1) => Some(TypeApply(fn1, args) setPos tree.pos) + case _ => None + } + case _ => + macroTraceVerbose("unexpected tree in fallback: ")(tree) + notFound() + } + } + fallBackToOverridden(expandee) match { + case Some(tree1) => + macroTraceLite("falling back to: ")(tree1) + currentRun.macroExpansionFailed = true + Fallback(tree1) + case None => + fail(typer, expandee) + } + } + + private def handleMacroExpansionException(typer: Typer, expandee: Tree, ex: Throwable): MacroExpansionResult = { + // [Eugene] any ideas about how to improve this one? + val realex = ReflectionUtils.unwrapThrowable(ex) + realex match { + case realex: reflect.makro.runtime.AbortMacroException => + macroLogVerbose("macro expansion has failed: %s".format(realex.msg)) + fail(typer, expandee) // error has been reported by abort + case err: TypeError => + macroLogLite("macro expansion has failed: %s at %s".format(err.msg, err.pos)) + throw err // error should be propagated, don't report + case _ => + val message = { + try { + // [Eugene] is there a better way? + // [Paul] See Exceptional.scala and Origins.scala. + val relevancyThreshold = realex.getStackTrace().indexWhere(este => este.getMethodName == "macroExpand1") + if (relevancyThreshold == -1) None + else { + var relevantElements = realex.getStackTrace().take(relevancyThreshold + 1) + var framesTillReflectiveInvocationOfMacroImpl = relevantElements.reverse.indexWhere(_.isNativeMethod) + 1 + relevantElements = relevantElements dropRight framesTillReflectiveInvocationOfMacroImpl + + realex.setStackTrace(relevantElements) + val message = new java.io.StringWriter() + realex.printStackTrace(new java.io.PrintWriter(message)) + Some(EOL + message) + } + } catch { + // if the magic above goes boom, just fall back to uninformative, but better than nothing, getMessage + case ex: Throwable => + None + } + } getOrElse realex.getMessage + fail(typer, expandee, "exception during macro expansion: " + message) } } @@ -1190,29 +1234,34 @@ trait Macros { self: Analyzer => * 2) undetparams (sym.isTypeParameter && !sym.isSkolem) */ var hasPendingMacroExpansions = false - private val delayed = perRunCaches.newWeakMap[Tree, (Context, collection.mutable.Set[Int])] + private val delayed = perRunCaches.newWeakMap[Tree, collection.mutable.Set[Int]] private def isDelayed(expandee: Tree) = delayed contains expandee private def calculateUndetparams(expandee: Tree): collection.mutable.Set[Int] = - delayed.get(expandee).map(_._2).getOrElse { - val calculated = collection.mutable.Set[Int]() + delayed.get(expandee).getOrElse { + val calculated = collection.mutable.Set[Symbol]() expandee foreach (sub => { - def traverse(sym: Symbol) = if (sym != null && (undetparams contains sym.id)) calculated += sym.id + def traverse(sym: Symbol) = if (sym != null && (undetparams contains sym.id)) calculated += sym if (sub.symbol != null) traverse(sub.symbol) if (sub.tpe != null) sub.tpe foreach (sub => traverse(sub.typeSymbol)) }) - calculated + macroLogVerbose("calculateUndetparams: %s".format(calculated)) + calculated map (_.id) } private val undetparams = perRunCaches.newSet[Int] - def notifyUndetparamsAdded(newUndets: List[Symbol]): Unit = undetparams ++= newUndets map (_.id) + def notifyUndetparamsAdded(newUndets: List[Symbol]): Unit = { + undetparams ++= newUndets map (_.id) + if (macroDebugVerbose) newUndets foreach (sym => println("undetParam added: %s".format(sym))) + } def notifyUndetparamsInferred(undetNoMore: List[Symbol], inferreds: List[Type]): Unit = { undetparams --= undetNoMore map (_.id) + if (macroDebugVerbose) (undetNoMore zip inferreds) foreach { case (sym, tpe) => println("undetParam inferred: %s as %s".format(sym, tpe))} if (!delayed.isEmpty) delayed.toList foreach { - case (expandee, (_, undetparams)) if !undetparams.isEmpty => + case (expandee, undetparams) if !undetparams.isEmpty => undetparams --= undetNoMore map (_.id) if (undetparams.isEmpty) { hasPendingMacroExpansions = true - macroTrace("macro expansion is pending: ")(expandee) + macroTraceVerbose("macro expansion is pending: ")(expandee) } case _ => // do nothing @@ -1228,9 +1277,12 @@ trait Macros { self: Analyzer => override def transform(tree: Tree) = super.transform(tree match { // todo. expansion should work from the inside out case wannabe if (delayed contains wannabe) && calculateUndetparams(wannabe).isEmpty => - val (context, _) = delayed(wannabe) + val context = wannabe.attachment[MacroAttachment].typerContext delayed -= wannabe - macroExpand(newTyper(context), wannabe, WildcardType) + context.implicitsEnabled = typer.context.implicitsEnabled + context.enrichmentEnabled = typer.context.enrichmentEnabled + context.macrosEnabled = typer.context.macrosEnabled + macroExpand(newTyper(context), wannabe, EXPRmode, WildcardType) case _ => tree }) diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala index 9e06cbe0d3..4c71772929 100644 --- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala +++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala @@ -8,6 +8,7 @@ package typechecker import symtab.Flags._ import scala.collection.{ mutable, immutable } import scala.tools.util.StringOps.{ ojoin } +import scala.reflect.{ mirror => rm } import language.higherKinds /** Logic related to method synthesis which involves cooperation between @@ -21,50 +22,51 @@ trait MethodSynthesis { import CODE._ object synthesisUtil { - type M[T] = Manifest[T] - type CM[T] = ClassManifest[T] + type CTT[T] = rm.ConcreteTypeTag[T] + type CT[T] = ClassTag[T] def ValOrDefDef(sym: Symbol, body: Tree) = if (sym.isLazy) ValDef(sym, body) else DefDef(sym, body) - def applyTypeInternal(manifests: List[M[_]]): Type = { + def applyTypeInternal(tags: List[CTT[_]]): Type = { // [Eugene to Paul] needs review!! - val symbols = manifests map manifestToSymbol + val symbols = tags map compilerSymbolFromTag val container :: args = symbols val tparams = container.typeConstructor.typeParams // Conservative at present - if manifests were more usable this could do a lot more. - require(symbols forall (_ ne NoSymbol), "Must find all manifests: " + symbols) + // [Eugene to Paul] all right, they are now. what do you have in mind? + require(symbols forall (_ ne NoSymbol), "Must find all tags: " + symbols) require(container.owner.isPackageClass, "Container must be a top-level class in a package: " + container) require(tparams.size == args.size, "Arguments must match type constructor arity: " + tparams + ", " + args) appliedType(container, args map (_.tpe): _*) } - def companionType[T](implicit m: M[T]) = + def companionType[T](implicit m: CTT[T]) = getRequiredModule(m.erasure.getName).tpe // Use these like `applyType[List, Int]` or `applyType[Map, Int, String]` - def applyType[CC](implicit m1: M[CC]): Type = + def applyType[CC](implicit m1: CTT[CC]): Type = applyTypeInternal(List(m1)) - def applyType[CC[X1], X1](implicit m1: M[CC[_]], m2: M[X1]): Type = + def applyType[CC[X1], X1](implicit m1: CTT[CC[_]], m2: CTT[X1]): Type = applyTypeInternal(List(m1, m2)) - def applyType[CC[X1, X2], X1, X2](implicit m1: M[CC[_,_]], m2: M[X1], m3: M[X2]): Type = + def applyType[CC[X1, X2], X1, X2](implicit m1: CTT[CC[_,_]], m2: CTT[X1], m3: CTT[X2]): Type = applyTypeInternal(List(m1, m2, m3)) - def applyType[CC[X1, X2, X3], X1, X2, X3](implicit m1: M[CC[_,_,_]], m2: M[X1], m3: M[X2], m4: M[X3]): Type = + def applyType[CC[X1, X2, X3], X1, X2, X3](implicit m1: CTT[CC[_,_,_]], m2: CTT[X1], m3: CTT[X2], m4: CTT[X3]): Type = applyTypeInternal(List(m1, m2, m3, m4)) - def newMethodType[F](owner: Symbol)(implicit m: Manifest[F]): Type = { - val fnSymbol = manifestToSymbol(m) - assert(fnSymbol isSubClass FunctionClass(m.tpe.typeArguments.size - 1), (owner, m)) + def newMethodType[F](owner: Symbol)(implicit t: CTT[F]): Type = { + val fnSymbol = compilerSymbolFromTag(t) + assert(fnSymbol isSubClass FunctionClass(t.tpe.typeArguments.size - 1), (owner, t)) // [Eugene to Paul] needs review!! // val symbols = m.typeArguments map (m => manifestToSymbol(m)) // val formals = symbols.init map (_.typeConstructor) - val formals = manifestToType(m).typeArguments + val formals = compilerTypeFromTag(t).typeArguments val params = owner newSyntheticValueParams formals MethodType(params, formals.last) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Modes.scala b/src/compiler/scala/tools/nsc/typechecker/Modes.scala index 48068b58d4..3eff5ef024 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Modes.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Modes.scala @@ -105,7 +105,7 @@ trait Modes { final def inFunMode(mode: Int) = (mode & FUNmode) != 0 final def inPolyMode(mode: Int) = (mode & POLYmode) != 0 final def inPatternMode(mode: Int) = (mode & PATTERNmode) != 0 - + final def inExprModeOr(mode: Int, others: Int) = (mode & (EXPRmode | others)) != 0 final def inExprModeButNot(mode: Int, prohibited: Int) = (mode & (EXPRmode | prohibited)) == EXPRmode diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index ffd00751e0..45f7d7e618 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -139,16 +139,9 @@ trait Namers extends MethodSynthesis { || vd.symbol.isLazy ) - def setPrivateWithin[Sym <: Symbol](tree: Tree, sym: Sym, mods: Modifiers): Sym = + def setPrivateWithin[T <: Symbol](tree: Tree, sym: T, mods: Modifiers): T = if (sym.isPrivateLocal || !mods.hasAccessBoundary) sym - else sym setPrivateWithin ( - typer.qualifyingClass(tree, mods.privateWithin, true) match { - case None => - NoSymbol - case Some(sym) => - sym - } - ) + else sym setPrivateWithin typer.qualifyingClass(tree, mods.privateWithin, packageOK = true) def setPrivateWithin(tree: MemberDef, sym: Symbol): Symbol = setPrivateWithin(tree, sym, tree.mods) @@ -160,24 +153,14 @@ trait Namers extends MethodSynthesis { def moduleClassFlags(moduleFlags: Long) = (moduleFlags & ModuleToClassFlags) | inConstructorFlag - private def resetKeepingFlags(sym: Symbol, keeping: Long): Symbol = { - val keep = sym.flags & keeping - sym reset NoType - sym setFlag keep - } - def updatePosFlags(sym: Symbol, pos: Position, flags: Long): Symbol = { debuglog("[overwrite] " + sym) - resetKeepingFlags(sym, LOCKED) - sym setFlag flags - sym setPos pos - - if (sym.isModule && sym.moduleClass != NoSymbol) - updatePosFlags(sym.moduleClass, pos, moduleClassFlags(flags)) + val newFlags = (sym.flags & LOCKED) | flags + sym reset NoType setFlag newFlags setPos pos + sym.moduleClass andAlso (updatePosFlags(_, pos, moduleClassFlags(flags))) if (sym.owner.isPackageClass) { - val companion = companionSymbolOf(sym, context) - if (companion != NoSymbol) { + companionSymbolOf(sym, context) andAlso { companion => val assignNoType = companion.rawInfo match { case _: SymLoader => true case tp => tp.isComplete && (runId(sym.validTo) != currentRunId) @@ -400,9 +383,7 @@ trait Namers extends MethodSynthesis { if (m.isModule && !m.isPackage && inCurrentScope(m) && (currentRun.canRedefine(m) || m.isSynthetic)) { updatePosFlags(m, tree.pos, moduleFlags) setPrivateWithin(tree, m) - if (m.moduleClass != NoSymbol) - setPrivateWithin(tree, m.moduleClass) - + m.moduleClass andAlso (setPrivateWithin(tree, _)) context.unit.synthetics -= m tree.symbol = m } @@ -475,8 +456,7 @@ trait Namers extends MethodSynthesis { val defSym = context.prefix.member(to) filter ( sym => sym.exists && context.isAccessible(sym, context.prefix, false)) - if (defSym != NoSymbol) - typer.permanentlyHiddenWarning(pos, to0, defSym) + defSym andAlso (typer.permanentlyHiddenWarning(pos, to0, _)) } } if (!tree.symbol.isSynthetic && expr.symbol != null && !expr.symbol.isInterpreterWrapper) { @@ -669,10 +649,9 @@ trait Namers extends MethodSynthesis { protected def enterExistingSym(sym: Symbol): Context = { if (forInteractive && sym != null && sym.owner.isTerm) { enterIfNotThere(sym) - if (sym.isLazy) { - val acc = sym.lazyAccessor - if (acc != NoSymbol) enterIfNotThere(acc) - } + if (sym.isLazy) + sym.lazyAccessor andAlso enterIfNotThere + defaultParametersOfMethod(sym) foreach { symRef => enterIfNotThere(symRef()) } } this.context @@ -1547,13 +1526,13 @@ trait Namers extends MethodSynthesis { * call this method? */ def companionSymbolOf(original: Symbol, ctx: Context): Symbol = { - try original.companionSymbol match { - case NoSymbol => + try { + original.companionSymbol orElse { ctx.lookup(original.name.companionName, original.owner).suchThat(sym => (original.isTerm || sym.hasModuleFlag) && (sym isCoDefinedWith original) ) - case sym => sym + } } catch { case e: InvalidCompanions => diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index be269cf4b2..898a9fee9f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -39,14 +39,14 @@ trait NamesDefaults { self: Analyzer => def isNamed(arg: Tree) = nameOf(arg).isDefined /** @param pos maps indices from old to new */ - def reorderArgs[T: ClassManifest](args: List[T], pos: Int => Int): List[T] = { + def reorderArgs[T: ArrayTag](args: List[T], pos: Int => Int): List[T] = { val res = new Array[T](args.length) foreachWithIndex(args)((arg, index) => res(pos(index)) = arg) res.toList } /** @param pos maps indices from new to old (!) */ - def reorderArgsInv[T: ClassManifest](args: List[T], pos: Int => Int): List[T] = { + def reorderArgsInv[T: ArrayTag](args: List[T], pos: Int => Int): List[T] = { val argsArray = args.toArray (argsArray.indices map (i => argsArray(pos(i)))).toList } @@ -444,21 +444,12 @@ trait NamesDefaults { self: Analyzer => } } - /** Fast path for ambiguous assignment check. - */ - private def isNameInScope(context: Context, name: Name) = ( - context.enclosingContextChain exists (ctx => - (ctx.scope.lookupEntry(name) != null) - || (ctx.owner.rawInfo.member(name) != NoSymbol) - ) - ) - /** A full type check is very expensive; let's make sure there's a name * somewhere which could potentially be ambiguous before we go that route. */ private def isAmbiguousAssignment(typer: Typer, param: Symbol, arg: Tree) = { import typer.context - isNameInScope(context, param.name) && { + (context isNameInScope param.name) && { // for named arguments, check whether the assignment expression would // typecheck. if it does, report an ambiguous error. val paramtpe = param.tpe.cloneInfo(param) diff --git a/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala b/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala index 1fd9f6fc13..e5b5746e8d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala +++ b/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala @@ -46,7 +46,7 @@ trait PatMatVirtualiser extends ast.TreeDSL { self: Analyzer => val outer = newTermName("<outer>") val runOrElse = newTermName("runOrElse") val zero = newTermName("zero") - val _match = newTermName("__match") // don't call it __match, since that will trigger virtual pattern matching... + val _match = newTermName("__match") // don't call the val __match, since that will trigger virtual pattern matching... def counted(str: String, i: Int) = newTermName(str+i) } @@ -55,10 +55,15 @@ trait PatMatVirtualiser extends ast.TreeDSL { self: Analyzer => def apply(typer: Typer): MatchTranslation with CodegenCore = { import typer._ // typing `_match` to decide which MatchTranslator to create adds 4% to quick.comp.timer - newTyper(context.makeImplicit(reportAmbiguousErrors = false)).silent(_.typed(Ident(vpmName._match), EXPRmode, WildcardType), reportAmbiguousErrors = false) match { - case SilentResultValue(ms) => new PureMatchTranslator(typer, ms) - case _ => new OptimizingMatchTranslator(typer) + val matchStrategy: Tree = ( + if (!context.isNameInScope(vpmName._match)) null // fast path, avoiding the next line if there's no __match to be seen + else newTyper(context.makeImplicit(reportAmbiguousErrors = false)).silent(_.typed(Ident(vpmName._match), EXPRmode, WildcardType), reportAmbiguousErrors = false) match { + case SilentResultValue(ms) => ms + case _ => null } + ) + if (matchStrategy eq null) new OptimizingMatchTranslator(typer) + else new PureMatchTranslator(typer, matchStrategy) } } @@ -135,8 +140,8 @@ trait PatMatVirtualiser extends ast.TreeDSL { self: Analyzer => // we don't transform after uncurry // (that would require more sophistication when generating trees, // and the only place that emits Matches after typers is for exception handling anyway) - assert(phase.id < currentRun.uncurryPhase.id, phase) - + if(phase.id >= currentRun.uncurryPhase.id) debugwarn("running translateMatch at "+ phase +" on "+ scrut +" match "+ cases) + // println("translating "+ cases.mkString("{", "\n", "}")) val scrutSym = freshSym(scrut.pos, pureType(scrutType)) setFlag SYNTH_CASE // pt = Any* occurs when compiling test/files/pos/annotDepMethType.scala with -Xexperimental combineCases(scrut, scrutSym, cases map translateCase(scrutSym, pt), pt, matchOwner, matchFailGenOverride) @@ -260,10 +265,11 @@ trait PatMatVirtualiser extends ast.TreeDSL { self: Analyzer => * @arg patBinder symbol used to refer to the result of the previous pattern's extractor (will later be replaced by the outer tree with the correct tree to refer to that patterns result) */ def unapply(tree: Tree): Option[(Symbol, Type)] = tree match { - case Bound(subpatBinder, typed@Typed(expr, tpt)) if typed.tpe ne null => Some((subpatBinder, typed.tpe)) - case Bind(_, typed@Typed(expr, tpt)) if typed.tpe ne null => Some((patBinder, typed.tpe)) - case Typed(expr, tpt) if tree.tpe ne null => Some((patBinder, tree.tpe)) - case _ => None + // the Ident subpattern can be ignored, subpatBinder or patBinder tell us all we need to know about it + case Bound(subpatBinder, typed@Typed(Ident(_), tpt)) if typed.tpe ne null => Some((subpatBinder, typed.tpe)) + case Bind(_, typed@Typed(Ident(_), tpt)) if typed.tpe ne null => Some((patBinder, typed.tpe)) + case Typed(Ident(_), tpt) if tree.tpe ne null => Some((patBinder, tree.tpe)) + case _ => None } } @@ -828,6 +834,7 @@ class Foo(x: Other) { x._1 } // no error in this order private def typeTest(binderToTest: Symbol, expectedTp: Type, disableOuterCheck: Boolean = false, dynamic: Boolean = false): Tree = { import CODE._ // def coreTest = if (disableOuterCheck) codegen._isInstanceOf(binderToTest, expectedTp) else maybeWithOuterCheck(binderToTest, expectedTp)(codegen._isInstanceOf(binderToTest, expectedTp)) + // [Eugene to Adriaan] use `resolveErasureTag` instead of `findManifest`. please, provide a meaningful position // if (opt.experimental && containsUnchecked(expectedTp)) { // if (dynamic) { // val expectedTpTagTree = findManifest(expectedTp, true) @@ -985,6 +992,7 @@ class Foo(x: Other) { x._1 } // no error in this order fixerUpper(owner, scrut.pos){ val ptDefined = if (isFullyDefined(pt)) pt else NoType def matchFailGen = (matchFailGenOverride orElse Some(CODE.MATCHERROR(_: Tree))) + // println("combining cases: "+ (casesNoSubstOnly.map(_.mkString(" >> ")).mkString("{", "\n", "}"))) emitSwitch(scrut, scrutSym, casesNoSubstOnly, pt, matchFailGenOverride).getOrElse{ if (casesNoSubstOnly nonEmpty) { @@ -1064,7 +1072,7 @@ class Foo(x: Other) { x._1 } // no error in this order // assert(owner ne null); assert(owner ne NoSymbol) def freshSym(pos: Position, tp: Type = NoType, prefix: String = "x") = - NoSymbol.newTermSymbol(freshName(prefix), pos) setInfo /*repackExistential*/(tp) + NoSymbol.newTermSymbol(freshName(prefix), pos) setInfo tp // codegen relevant to the structure of the translation (how extractors are combined) trait AbsCodegen { @@ -1107,7 +1115,9 @@ class Foo(x: Other) { x._1 } // no error in this order // drop annotations generated by CPS plugin etc, since its annotationchecker rejects T @cps[U] <: Any // let's assume for now annotations don't affect casts, drop them there, and bring them back using the outer Typed tree - private def mkCast(t: Tree, tp: Type) = Typed(gen.mkAsInstanceOf(t, tp.withoutAnnotations, true, false), TypeTree() setType tp) + private def mkCast(t: Tree, tp: Type) = + Typed(gen.mkAsInstanceOf(t, tp.withoutAnnotations, true, false), TypeTree() setType tp) + // the force is needed mainly to deal with the GADT typing hack (we can't detect it otherwise as tp nor pt need contain an abstract type, we're just casting wildly) def _asInstanceOf(t: Tree, tp: Type, force: Boolean = false): Tree = if (!force && (t.tpe ne NoType) && t.isTyped && typesConform(t.tpe, tp)) t else mkCast(t, tp) def _asInstanceOf(b: Symbol, tp: Type): Tree = if (typesConform(b.info, tp)) REF(b) else mkCast(REF(b), tp) @@ -1136,7 +1146,7 @@ class Foo(x: Other) { x._1 } // no error in this order val matchStrategy: Tree def inMatchMonad(tp: Type): Type = appliedType(oneSig, List(tp)).finalResultType - def pureType(tp: Type): Type = appliedType(oneSig, List(tp)).paramTypes.head + def pureType(tp: Type): Type = appliedType(oneSig, List(tp)).paramTypes.headOption getOrElse NoType // fail gracefully (otherwise we get crashes) protected def matchMonadSym = oneSig.finalResultType.typeSymbol import CODE._ @@ -1568,7 +1578,7 @@ class Foo(x: Other) { x._1 } // no error in this order // TODO: if patterns allow switch but the type of the scrutinee doesn't, cast (type-test) the scrutinee to the corresponding switchable type and switch on the result if (regularSwitchMaker.switchableTpe(scrutSym.tpe)) { val caseDefsWithDefault = regularSwitchMaker(cases map {c => (scrutSym, c)}, pt) - if (caseDefsWithDefault isEmpty) None + if (caseDefsWithDefault.length <= 2) None // not worth emitting a switch... also, the optimizer has trouble digesting tiny switches, apparently, so let's be nice and not generate them else { // match on scrutSym -- converted to an int if necessary -- not on scrut directly (to avoid duplicating scrut) val scrutToInt: Tree = diff --git a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala new file mode 100644 index 0000000000..329a247106 --- /dev/null +++ b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala @@ -0,0 +1,10 @@ +package scala.tools.nsc +package typechecker + +import scala.reflect.makro.runtime.{Context => MacroContext} + +trait StdAttachments { + self: Analyzer => + + case class MacroAttachment(delayed: Boolean, typerContext: Context, macroContext: Option[MacroContext]) +}
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 43cbea83ff..d327d9c397 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -134,7 +134,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT // otherwise lead to either a compiler crash or runtime failure. private lazy val isDisallowed = { import definitions._ - Set(Any_isInstanceOf, Object_isInstanceOf, Any_asInstanceOf, Object_asInstanceOf, Object_==, Object_!=, Object_##) + Set[Symbol](Any_isInstanceOf, Object_isInstanceOf, Any_asInstanceOf, Object_asInstanceOf, Object_==, Object_!=, Object_##) } override def transform(tree: Tree): Tree = { diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 868c236ee9..31d064c824 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -74,7 +74,7 @@ trait SyntheticMethods extends ast.TreeDSL { // Option[Int] { def productIterator: Iterator[String] } // // appearing legitimately, but this breaks invariant places - // like Manifests and Arrays which are not robust and infer things + // like Tags and Arrays which are not robust and infer things // which they shouldn't. val accessorLub = ( if (opt.experimental) { diff --git a/src/compiler/scala/tools/nsc/typechecker/Taggings.scala b/src/compiler/scala/tools/nsc/typechecker/Taggings.scala new file mode 100644 index 0000000000..d276b39f16 --- /dev/null +++ b/src/compiler/scala/tools/nsc/typechecker/Taggings.scala @@ -0,0 +1,71 @@ +package scala.tools.nsc +package typechecker + +trait Taggings { + self: Analyzer => + + import global._ + import definitions._ + + trait Tagging { + self: Typer => + + private def resolveTag(pos: Position, taggedTp: Type) = beforeTyper { + inferImplicit( + EmptyTree, + taggedTp, + /*reportAmbiguous =*/ true, + /*isView =*/ false, + /*context =*/ context, + /*saveAmbiguousDivergent =*/ true, + /*pos =*/ pos + ).tree + } + + /** Finds in scope or materializes an ArrayTag. + * Should be used instead of ClassTag or ClassManifest every time compiler needs to create an array. + * + * @param pos Position for error reporting. Please, provide meaningful value. + * @param tp Type we're looking an ArrayTag for, e.g. resolveArrayTag(pos, IntClass.tpe) will look for ArrayTag[Int]. + * + * @returns Tree that represents an `scala.reflect.ArrayTag` for `tp` if everything is okay. + * EmptyTree if the result contains unresolved (i.e. not spliced) type parameters and abstract type members. + */ + def resolveArrayTag(pos: Position, tp: Type): Tree = { + val taggedTp = appliedType(ArrayTagClass.typeConstructor, List(tp)) + resolveTag(pos, taggedTp) + } + + /** Finds in scope or materializes an ErasureTag (if `concrete` is false) or a ClassTag (if `concrete` is true). + * Should be used instead of ClassTag or ClassManifest every time compiler needs to persist an erasure. + * + * @param pos Position for error reporting. Please, provide meaningful value. + * @param tp Type we're looking an ErasureTag for, e.g. resolveErasureTag(pos, IntClass.tpe, true) will look for ClassTag[Int]. + * @param concrete If true then the result must not contain unresolved (i.e. not spliced) type parameters and abstract type members. + * If false then the function will always succeed (abstract types will be erased to their upper bounds). + * + * @returns Tree that represents an `scala.reflect.ErasureTag` for `tp` if everything is okay. + * EmptyTree if `concrete` is true and the result contains unresolved (i.e. not spliced) type parameters and abstract type members. + */ + def resolveErasureTag(pos: Position, tp: Type, concrete: Boolean): Tree = { + val taggedTp = appliedType(if (concrete) ClassTagClass.typeConstructor else ErasureTagClass.typeConstructor, List(tp)) + resolveTag(pos, taggedTp) + } + + /** Finds in scope or materializes a TypeTag (if `concrete` is false) or a ConcreteTypeTag (if `concrete` is true). + * + * @param pos Position for error reporting. Please, provide meaningful value. + * @param pre Prefix that represents a universe this type tag will be bound to. + * @param tp Type we're looking a TypeTag for, e.g. resolveTypeTag(pos, reflectMirrorPrefix, IntClass.tpe, false) will look for scala.reflect.mirror.TypeTag[Int]. + * @param concrete If true then the result must not contain unresolved (i.e. not spliced) type parameters and abstract type members. + * If false then the function will always succeed (abstract types will be reified as free types). + * + * @returns Tree that represents a `scala.reflect.TypeTag` for `tp` if everything is okay. + * EmptyTree if `concrete` is true and the result contains unresolved (i.e. not spliced) type parameters and abstract type members. + */ + def resolveTypeTag(pos: Position, pre: Type, tp: Type, concrete: Boolean): Tree = { + val taggedTp = appliedType(singleType(pre, pre member (if (concrete) ConcreteTypeTagClass else TypeTagClass).name), List(tp)) + resolveTag(pos, taggedTp) + } + } +}
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala index 4319dd10c7..a6a8d6009f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala @@ -57,7 +57,7 @@ abstract class TreeCheckers extends Analyzer { def prev = maps.init.last._2 def latest = maps.last._2 - def sortedNewSyms = newSyms.toList.distinct sortBy (_.name.toString) + def sortedNewSyms = newSyms.toList.distinct sortBy (_.name) def inPrev(sym: Symbol) = { (maps.size >= 2) && (prev contains sym) diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 043e826d32..89c30590c9 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -26,7 +26,7 @@ import util.Statistics._ * @author Martin Odersky * @version 1.0 */ -trait Typers extends Modes with Adaptations with PatMatVirtualiser { +trait Typers extends Modes with Adaptations with Taggings with PatMatVirtualiser { self: Analyzer => import global._ @@ -83,7 +83,10 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { private def isPastTyper = phase.id > currentRun.typerPhase.id - abstract class Typer(context0: Context) extends TyperDiagnostics with Adaptation with TyperContextErrors { + // don't translate matches in presentation compiler: it loses vital symbols that are needed to do hyperlinking + @inline private def doMatchTranslation = !forInteractive && opt.virtPatmat && (phase.id < currentRun.uncurryPhase.id) + + abstract class Typer(context0: Context) extends TyperDiagnostics with Adaptation with Tagging with TyperContextErrors { import context0.unit import typeDebug.{ ptTree, ptBlock, ptLine } import TyperErrorGen._ @@ -455,13 +458,10 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { * of a this or super with prefix <code>qual</code>. * packageOk is equal false when qualifying class symbol */ - def qualifyingClass(tree: Tree, qual: Name, packageOK: Boolean = false): Option[Symbol] = + def qualifyingClass(tree: Tree, qual: Name, packageOK: Boolean) = context.enclClass.owner.ownerChain.find(o => qual.isEmpty || o.isClass && o.name == qual) match { - case Some(c) if packageOK || !c.isPackageClass => - Some(c) - case _ => - QualifyingClassError(tree, qual) - None + case Some(c) if packageOK || !c.isPackageClass => c + case _ => QualifyingClassError(tree, qual) ; NoSymbol } /** The typer for an expression, depending on where we are. If we are before a superclass @@ -830,11 +830,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { context.undetparams = inferExprInstance(tree, context.extractUndetparams(), pt, // approximate types that depend on arguments since dependency on implicit argument is like dependency on type parameter mt.approximate, - // if we are looking for a manifest, instantiate type to Nothing anyway, - // as we would get ambiguity errors otherwise. Example - // Looking for a manifest of Nil: This has many potential types, - // so we need to instantiate to minimal type List[Nothing]. - keepNothings = false, // retract Nothing's that indicate failure, ambiguities in manifests are dealt with in manifestOfType + keepNothings = false, useWeaklyCompatible = true) // #3808 } @@ -1082,10 +1078,10 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { } if (tree.isType) adaptType() - else if (context.macrosEnabled && // when macros are enabled - inExprModeButNot(mode, FUNmode) && !tree.isDef && // and typechecking application - tree.symbol != null && tree.symbol.isTermMacro) // of a term macro - macroExpand(this, tree, pt) + else if ( + inExprModeButNot(mode, FUNmode) && !tree.isDef && // typechecking application + tree.symbol != null && tree.symbol.isTermMacro) // of a macro + macroExpand(this, tree, mode, pt) else if ((mode & (PATTERNmode | FUNmode)) == (PATTERNmode | FUNmode)) adaptConstrPattern() else if (inAllModes(mode, EXPRmode | FUNmode) && @@ -2212,6 +2208,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { def adaptCase(cdef: CaseDef, mode: Int, tpe: Type): CaseDef = deriveCaseDef(cdef)(adapt(_, mode, tpe)) + // takes untyped sub-trees of a match and type checks them def typedMatch(selector0: Tree, cases: List[CaseDef], mode: Int, resTp: Type) = { val (selector, doTranslation) = selector0 match { case Annotated(Ident(nme.synthSwitch), selector) => (selector, false) @@ -2229,6 +2226,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { (selector1, selectorTp, casesAdapted, ownType, doTranslation) } + // match has been typed, now translate it def translatedMatch(selector1: Tree, selectorTp: Type, casesAdapted: List[CaseDef], ownType: Type, doTranslation: Boolean, matchFailGen: Option[Tree => Tree] = None) = { def repeatedToSeq(tp: Type): Type = (tp baseType RepeatedParamClass) match { case TypeRef(_, RepeatedParamClass, arg :: Nil) => seqType(arg) @@ -2248,54 +2246,49 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { } } - def typedMatchAnonFun(tree: Tree, cases: List[CaseDef], mode: Int, pt0: Type, selOverride: Option[(List[ValDef], Tree)] = None) = { - val pt = deskolemizeGADTSkolems(pt0) - val targs = pt.normalize.typeArgs - val arity = if (isFunctionType(pt)) targs.length - 1 else 1 // TODO pt should always be a (Partial)Function, right? - val ptRes = if (targs.isEmpty) WildcardType else targs.last // may not be fully defined + // synthesize and type check a (Partial)Function implementation based on a match specified by `cases` + // Match(EmptyTree, cases) ==> new <Partial>Function { def apply<OrElse>(params) = `translateMatch('`(param1,...,paramN)` match { cases }')` } + // for fresh params, the selector of the match we'll translated simply gathers those in a tuple + class MatchFunTyper(tree: Tree, cases: List[CaseDef], mode: Int, pt0: Type) { + private val pt = deskolemizeGADTSkolems(pt0) + private val targs = pt.normalize.typeArgs + private val arity = if (isFunctionType(pt)) targs.length - 1 else 1 // TODO pt should always be a (Partial)Function, right? + private val ptRes = if (targs.isEmpty) WildcardType else targs.last // may not be fully defined - val isPartial = pt.typeSymbol == PartialFunctionClass - val anonClass = context.owner.newAnonymousFunctionClass(tree.pos) - val funThis = This(anonClass) - val serialVersionUIDAnnotation = AnnotationInfo(SerialVersionUIDAttr.tpe, List(Literal(Constant(0))), List()) + private val isPartial = pt.typeSymbol == PartialFunctionClass + private val anonClass = context.owner.newAnonymousFunctionClass(tree.pos) + private val funThis = This(anonClass) - anonClass addAnnotation serialVersionUIDAnnotation + anonClass addAnnotation AnnotationInfo(SerialVersionUIDAttr.tpe, List(Literal(Constant(0))), List()) def deriveFormals = - selOverride match { - case None if targs.isEmpty => Nil - case None => targs.init // is there anything we can do if targs.isEmpty?? - case Some((vparams, _)) => - vparams map {p => if(p.tpt.tpe == null) typedType(p.tpt).tpe else p.tpt.tpe} - } + if (targs.isEmpty) Nil + else targs.init - def mkParams(methodSym: Symbol, formals: List[Type] = deriveFormals) = { - selOverride match { - case None if targs.isEmpty => MissingParameterTypeAnonMatchError(tree, pt); (Nil, EmptyTree) - case None => - val ps = methodSym newSyntheticValueParams formals // is there anything we can do if targs.isEmpty?? - val ids = ps map (p => Ident(p.name)) - val sel = atPos(tree.pos.focusStart) { if (arity == 1) ids.head else gen.mkTuple(ids) } - (ps, sel) - case Some((vparams, sel)) => - val newParamSyms = (vparams, formals).zipped map {(p, tp) => - methodSym.newValueParameter(p.name, p.pos.focus, SYNTHETIC) setInfo tp - } + def mkParams(methodSym: Symbol, formals: List[Type] = deriveFormals) = + if (formals.isEmpty) { MissingParameterTypeAnonMatchError(tree, pt); Nil } + else methodSym newSyntheticValueParams formals - (newParamSyms, sel.duplicate) + def mkSel(params: List[Symbol]) = + if (params.isEmpty) EmptyTree + else { + val ids = params map (p => Ident(p.name)) + atPos(tree.pos.focusStart) { if (arity == 1) ids.head else gen.mkTuple(ids) } } - } import CODE._ // need to duplicate the cases before typing them to generate the apply method, or the symbols will be all messed up val casesTrue = if (isPartial) cases map (c => deriveCaseDef(c)(x => TRUE_typed).duplicate) else Nil + // println("casesTrue "+ casesTrue) + def parentsPartial(targs: List[Type]) = List(appliedType(AbstractPartialFunctionClass.typeConstructor, targs), SerializableClass.tpe) def applyMethod = { // rig the show so we can get started typing the method body -- later we'll correct the infos... anonClass setInfo ClassInfoType(List(ObjectClass.tpe, pt, SerializableClass.tpe), newScope, anonClass) - val methodSym = anonClass.newMethod(nme.apply, tree.pos, FINAL) - val (paramSyms, selector) = mkParams(methodSym) + val methodSym = anonClass.newMethod(nme.apply, tree.pos, if(isPartial) (FINAL | OVERRIDE) else FINAL) + val paramSyms = mkParams(methodSym) + val selector = mkSel(paramSyms) if (selector eq EmptyTree) EmptyTree else { @@ -2307,7 +2300,9 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.typedMatch(selector, cases, mode, ptRes) val methFormals = paramSyms map (_.tpe) - val parents = List(abstractFunctionType(methFormals, resTp), SerializableClass.tpe) + val parents = + if (isPartial) parentsPartial(List(methFormals.head, resTp)) + else List(abstractFunctionType(methFormals, resTp), SerializableClass.tpe) anonClass setInfo ClassInfoType(parents, newScope, anonClass) methodSym setInfoAndEnter MethodType(paramSyms, resTp) @@ -2320,15 +2315,14 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { def applyOrElseMethodDef = { // rig the show so we can get started typing the method body -- later we'll correct the infos... // targs were type arguments for PartialFunction, so we know they will work for AbstractPartialFunction as well - def parents(targs: List[Type]) = List(appliedType(AbstractPartialFunctionClass.typeConstructor, targs), SerializableClass.tpe) - - anonClass setInfo ClassInfoType(parents(targs), newScope, anonClass) + anonClass setInfo ClassInfoType(parentsPartial(targs), newScope, anonClass) val methodSym = anonClass.newMethod(nme.applyOrElse, tree.pos, FINAL | OVERRIDE) // create the parameter that corresponds to the function's parameter - val List(argTp) = deriveFormals - val A1 = methodSym newTypeParameter(newTypeName("A1")) setInfo TypeBounds.upper(argTp) - val (List(x), selector) = mkParams(methodSym, List(A1.tpe)) + val List(argTp) = deriveFormals + val A1 = methodSym newTypeParameter(newTypeName("A1")) setInfo TypeBounds.upper(argTp) + val paramSyms@List(x) = mkParams(methodSym, List(A1.tpe)) + val selector = mkSel(paramSyms) if (selector eq EmptyTree) EmptyTree else { @@ -2344,7 +2338,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.typedMatch(selector, cases, mode, ptRes) - anonClass setInfo ClassInfoType(parents(List(argTp, resTp)), newScope, anonClass) + anonClass setInfo ClassInfoType(parentsPartial(List(argTp, resTp)), newScope, anonClass) B1 setInfo TypeBounds.lower(resTp) anonClass.info.decls enter methodSym // methodSym's info need not change (B1's bound has been updated instead) @@ -2359,7 +2353,9 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { def isDefinedAtMethod = { val methodSym = anonClass.newMethod(nme.isDefinedAt, tree.pos, FINAL) - val (paramSyms, selector) = mkParams(methodSym) + val paramSyms = mkParams(methodSym) + val selector = mkSel(paramSyms) + if (selector eq EmptyTree) EmptyTree else { val methodBodyTyper = newTyper(context.makeNewScope(context.tree, methodSym)) // should use the DefDef for the context's tree, but it doesn't exist yet (we need the typer we're creating to create it) @@ -2373,9 +2369,29 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { } } - val members = if (!isPartial) List(applyMethod) else List(applyOrElseMethodDef, isDefinedAtMethod) - if (members.head eq EmptyTree) setError(tree) - else typed(Block(List(ClassDef(anonClass, NoMods, List(List()), List(List()), members, tree.pos)), New(anonClass.tpe)), mode, pt) + val members = if (isPartial) { + // TODO: don't check for MarkerCPSTypes -- check whether all targs are subtype of any (which they are not under CPS) + if ((MarkerCPSTypes ne NoSymbol) && (targs exists (_ hasAnnotation MarkerCPSTypes))) List(applyMethod, isDefinedAtMethod) + else List(applyOrElseMethodDef, isDefinedAtMethod) + } else List(applyMethod) + + def translated = + if (members.head eq EmptyTree) setError(tree) + else typed(Block(List(ClassDef(anonClass, NoMods, List(List()), List(List()), members, tree.pos)), New(anonClass.tpe)), mode, pt) + } + + // Function(params, Match(sel, cases)) ==> new <Partial>Function { def apply<OrElse>(params) = `translateMatch('sel match { cases }')` } + class MatchFunTyperBetaReduced(fun: Function, sel: Tree, cases: List[CaseDef], mode: Int, pt: Type) extends MatchFunTyper(fun, cases, mode, pt) { + override def deriveFormals = + fun.vparams map { p => if(p.tpt.tpe == null) typedType(p.tpt).tpe else p.tpt.tpe } + + // the only difference from the super class is that we must preserve the names of the parameters + override def mkParams(methodSym: Symbol, formals: List[Type] = deriveFormals) = + (fun.vparams, formals).zipped map { (p, tp) => + methodSym.newValueParameter(p.name, p.pos.focus, SYNTHETIC) setInfo tp + } + + override def mkSel(params: List[Symbol]) = sel.duplicate } /** @@ -2428,21 +2444,32 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { } } - val vparamSyms = fun.vparams map { vparam => - enterSym(context, vparam) - if (context.retyping) context.scope enter vparam.symbol - vparam.symbol + fun.body match { + // later phase indicates scaladoc is calling (where shit is messed up, I tell you) + // -- so fall back to old patmat, which is more forgiving + case Match(sel, cases) if (sel ne EmptyTree) && doMatchTranslation => + // go to outer context -- must discard the context that was created for the Function since we're discarding the function + // thus, its symbol, which serves as the current context.owner, is not the right owner + // you won't know you're using the wrong owner until lambda lift crashes (unless you know better than to use the wrong owner) + val outerTyper = newTyper(context.outer) + (new outerTyper.MatchFunTyperBetaReduced(fun, sel, cases, mode, pt)).translated + case _ => + val vparamSyms = fun.vparams map { vparam => + enterSym(context, vparam) + if (context.retyping) context.scope enter vparam.symbol + vparam.symbol + } + val vparams = fun.vparams mapConserve (typedValDef) + // for (vparam <- vparams) { + // checkNoEscaping.locals(context.scope, WildcardType, vparam.tpt); () + // } + val formals = vparamSyms map (_.tpe) + val body1 = typed(fun.body, respt) + val restpe = packedType(body1, fun.symbol).deconst.resultType + val funtpe = typeRef(clazz.tpe.prefix, clazz, formals :+ restpe) + // body = checkNoEscaping.locals(context.scope, restpe, body) + treeCopy.Function(fun, vparams, body1).setType(funtpe) } - val vparams = fun.vparams mapConserve (typedValDef) -// for (vparam <- vparams) { -// checkNoEscaping.locals(context.scope, WildcardType, vparam.tpt); () -// } - val formals = vparamSyms map (_.tpe) - val body1 = typed(fun.body, respt) - val restpe = packedType(body1, fun.symbol).deconst.resultType - val funtpe = typeRef(clazz.tpe.prefix, clazz, formals :+ restpe) -// body = checkNoEscaping.locals(context.scope, restpe, body) - treeCopy.Function(fun, vparams, body1).setType(funtpe) } } @@ -3086,7 +3113,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { if (annInfo.atp.isErroneous) { hasError = true; None } else Some(NestedAnnotArg(annInfo)) - // use of Array.apply[T: ClassManifest](xs: T*): Array[T] + // use of Array.apply[T: ArrayTag](xs: T*): Array[T] // and Array.apply(x: Int, xs: Int*): Array[Int] (and similar) case Apply(fun, args) => val typedFun = typed(fun, forFunMode(mode), WildcardType) @@ -3274,14 +3301,12 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { case tp => tp } - (hidden map { s => - // Hanging onto lower bound in case anything interesting - // happens with it. - (s, s.existentialBound match { - case TypeBounds(lo, hi) => TypeBounds(lo, hiBound(s)) - case _ => hiBound(s) - }) - }).toMap + // Hanging onto lower bound in case anything interesting + // happens with it. + mapFrom(hidden)(s => s.existentialBound match { + case TypeBounds(lo, hi) => TypeBounds(lo, hiBound(s)) + case _ => hiBound(s) + }) } /** Given a set `rawSyms` of term- and type-symbols, and a type @@ -3305,7 +3330,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { val typeParams: List[Symbol] = rawSyms map { sym => val name = sym.name match { case x: TypeName => x - case x => nme.singletonName(x) + case x => tpnme.singletonName(x) } val bound = allBounds(sym) val sowner = if (isRawParameter(sym)) context.owner else sym.owner @@ -3814,9 +3839,14 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { } } - // translation only happens when (selector != EmptyTree) && !isPastTyper && opt.virtPatmat def typedTranslatedMatch(tree: Tree, selector: Tree, cases: List[CaseDef]): Tree = { - if (selector == EmptyTree) { + if (doMatchTranslation) { + if (selector ne EmptyTree) { + val (selector1, selectorTp, casesAdapted, ownType, doTranslation) = typedMatch(selector, cases, mode, pt) + typed(translatedMatch(selector1, selectorTp, casesAdapted, ownType, doTranslation), mode, pt) + } else (new MatchFunTyper(tree, cases, mode, pt)).translated + } else if (selector == EmptyTree) { + if (opt.virtPatmat) debugwarn("virtpatmat should not encounter empty-selector matches "+ tree) val arity = if (isFunctionType(pt)) pt.normalize.typeArgs.length - 1 else 1 val params = for (i <- List.range(0, arity)) yield atPos(tree.pos.focusStart) { @@ -3827,7 +3857,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { val selector1 = atPos(tree.pos.focusStart) { if (arity == 1) ids.head else gen.mkTuple(ids) } val body = treeCopy.Match(tree, selector1, cases) typed1(atPos(tree.pos) { Function(params, body) }, mode, pt) - } else if (!((phase.id < currentRun.uncurryPhase.id) && opt.virtPatmat)) { + } else { val selector1 = checkDead(typed(selector, EXPRmode | BYVALmode, WildcardType)) var cases1 = typedCases(cases, packCaptured(selector1.tpe.widen), pt) val (owntype, needAdapt) = ptOrLub(cases1 map (_.tpe)) @@ -3835,9 +3865,6 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { cases1 = cases1 map (adaptCase(_, mode, owntype)) } treeCopy.Match(tree, selector1, cases1) setType owntype - } else { - val (selector1, selectorTp, casesAdapted, ownType, doTranslation) = typedMatch(selector, cases, mode, pt) - typed(translatedMatch(selector1, selectorTp, casesAdapted, ownType, doTranslation), mode, pt) } } @@ -4103,7 +4130,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { } def convertToAssignment(fun: Tree, qual: Tree, name: Name, args: List[Tree]): Tree = { - val prefix = name.subName(0, name.length - nme.EQL.length) + val prefix = name stripSuffix nme.EQL def mkAssign(vble: Tree): Tree = Assign( vble, @@ -4112,21 +4139,18 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { ) setPos tree.pos def mkUpdate(table: Tree, indices: List[Tree]) = { - gen.evalOnceAll(table :: indices, context.owner, context.unit) { ts => - val tab = ts.head - val is = ts.tail - Apply( - Select(tab(), nme.update) setPos table.pos, - ((is map (i => i())) ::: List( - Apply( - Select( - Apply( - Select(tab(), nme.apply) setPos table.pos, - is map (i => i())) setPos qual.pos, - prefix) setPos fun.pos, - args) setPos tree.pos) - ) - ) setPos tree.pos + gen.evalOnceAll(table :: indices, context.owner, context.unit) { + case tab :: is => + def mkCall(name: Name, extraArgs: Tree*) = ( + Apply( + Select(tab(), name) setPos table.pos, + is.map(i => i()) ++ extraArgs + ) setPos tree.pos + ) + mkCall( + nme.update, + Apply(Select(mkCall(nme.apply), prefix) setPos fun.pos, args) setPos tree.pos + ) } } @@ -4193,15 +4217,11 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { treeCopy.Super(tree, qual1, mix) setType SuperType(clazz.thisType, owntype) } - def typedThis(qual: Name) = { - val qualifyingClassSym = if (tree.symbol != NoSymbol) Some(tree.symbol) else qualifyingClass(tree, qual) - qualifyingClassSym match { - case Some(clazz) => - tree setSymbol clazz setType clazz.thisType.underlying - if (isStableContext(tree, mode, pt)) tree setType clazz.thisType - tree - case None => tree - } + def typedThis(qual: Name) = tree.symbol orElse qualifyingClass(tree, qual, packageOK = false) match { + case NoSymbol => tree + case clazz => + tree setSymbol clazz setType clazz.thisType.underlying + if (isStableContext(tree, mode, pt)) tree setType clazz.thisType else tree } /** Attribute a selection where <code>tree</code> is <code>qual.name</code>. @@ -4212,34 +4232,19 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { * @return ... */ def typedSelect(qual: Tree, name: Name): Tree = { - val sym = - if (tree.symbol != NoSymbol) { - if (phase.erasedTypes && qual.isInstanceOf[Super]) - qual.tpe = tree.symbol.owner.tpe - if (false && settings.debug.value) { // todo: replace by settings.check.value? - val alts = qual.tpe.member(tree.symbol.name).alternatives - if (!(alts exists (alt => - alt == tree.symbol || alt.isTerm && (alt.tpe matches tree.symbol.tpe)))) - assert(false, "symbol "+tree.symbol+tree.symbol.locationString+" not in "+alts+" of "+qual.tpe+ - "\n members = "+qual.tpe.members+ - "\n type history = "+qual.tpe.termSymbol.infosString+ - "\n phase = "+phase) - } - tree.symbol - } else { - member(qual, name) + val sym = tree.symbol orElse member(qual, name) orElse { + // symbol not found? --> try to convert implicitly to a type that does have the required + // member. Added `| PATTERNmode` to allow enrichment in patterns (so we can add e.g., an + // xml member to StringContext, which in turn has an unapply[Seq] method) + if (name != nme.CONSTRUCTOR && inExprModeOr(mode, PATTERNmode)) { + val qual1 = adaptToMemberWithArgs(tree, qual, name, mode, true, true) + if (qual1 ne qual) + return typed(treeCopy.Select(tree, qual1, name), mode, pt) } - - // symbol not found? --> try to convert implicitly to a type that does have the required member - // added `| PATTERNmode` to allow enrichment in patterns (so we can add e.g., an xml member to StringContext, which in turn has an unapply[Seq] method) - if (sym == NoSymbol && name != nme.CONSTRUCTOR && (mode & (EXPRmode | PATTERNmode)) != 0) { - val qual1 = - if (member(qual, name) != NoSymbol) qual - else adaptToMemberWithArgs(tree, qual, name, mode, true, true) - - if (qual1 ne qual) - return typed(treeCopy.Select(tree, qual1, name), mode, pt) + NoSymbol } + if (phase.erasedTypes && qual.isInstanceOf[Super] && tree.symbol != NoSymbol) + qual.tpe = tree.symbol.owner.tpe if (!reallyExists(sym)) { if (context.owner.enclosingTopLevelClass.isJavaDefined && name.isTypeName) { @@ -4254,14 +4259,12 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { case _ => } - if (settings.debug.value) { - log( - "qual = "+qual+":"+qual.tpe+ - "\nSymbol="+qual.tpe.termSymbol+"\nsymbol-info = "+qual.tpe.termSymbol.info+ - "\nscope-id = "+qual.tpe.termSymbol.info.decls.hashCode()+"\nmembers = "+qual.tpe.members+ - "\nname = "+name+"\nfound = "+sym+"\nowner = "+context.enclClass.owner - ) - } + debuglog( + "qual = "+qual+":"+qual.tpe+ + "\nSymbol="+qual.tpe.termSymbol+"\nsymbol-info = "+qual.tpe.termSymbol.info+ + "\nscope-id = "+qual.tpe.termSymbol.info.decls.hashCode()+"\nmembers = "+qual.tpe.members+ + "\nname = "+name+"\nfound = "+sym+"\nowner = "+context.enclClass.owner + ) def makeInteractiveErrorTree = { val tree1 = tree match { @@ -4717,9 +4720,8 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { catches1 = catches1 map (adaptCase(_, mode, owntype)) } - if((phase.id < currentRun.uncurryPhase.id) && opt.virtPatmat) { + if (doMatchTranslation) catches1 = (MatchTranslator(this)).translateTry(catches1, owntype, tree.pos) - } treeCopy.Try(tree, block1, catches1, finalizer1) setType owntype @@ -4821,12 +4823,12 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { // [Eugene] no more MaxArrayDims. ClassTags are flexible enough to allow creation of arrays of arbitrary dimensionality (w.r.t JVM restrictions) val Some((level, componentType)) = erasure.GenericArray.unapply(tpt.tpe) val tagType = List.iterate(componentType, level)(tpe => appliedType(ArrayClass.asType, List(tpe))).last - val newArrayApp = atPos(tree.pos) { - val tag = resolveClassTag(tree, tagType) + val newArrayApp = atPos(tree.pos) { + val tag = resolveArrayTag(tree.pos, tagType) if (tag.isEmpty) MissingClassTagError(tree, tagType) else new ApplyToImplicitArgs(Select(tag, nme.newArray), args) - } - typed(newArrayApp, mode, pt) + } + typed(newArrayApp, mode, pt) case tree1 => tree1 } @@ -5191,36 +5193,6 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser { case None => typed(tree, mode, pt) } - // `tree` is only necessary here for its position - // but that's invaluable for error reporting, so I decided to include it into this method's contract - // before passing EmptyTree, please, consider passing something meaningful first - def resolveClassTag(tree: Tree, tp: Type): Tree = beforeTyper { - inferImplicit( - EmptyTree, - appliedType(ClassTagClass.typeConstructor, List(tp)), - /*reportAmbiguous =*/ true, - /*isView =*/ false, - /*context =*/ context, - /*saveAmbiguousDivergent =*/ true, - /*pos =*/ tree.pos - ).tree - } - - // `tree` is only necessary here for its position - // but that's invaluable for error reporting, so I decided to include it into this method's contract - // before passing EmptyTree, please, consider passing something meaningful first - def resolveTypeTag(tree: Tree, pre: Type, tp: Type, full: Boolean): Tree = beforeTyper { - inferImplicit( - EmptyTree, - appliedType(singleType(pre, pre member (if (full) ConcreteTypeTagClass else TypeTagClass).name), List(tp)), - /*reportAmbiguous =*/ true, - /*isView =*/ false, - /*context =*/ context, - /*saveAmbiguousDivergent =*/ true, - /*pos =*/ tree.pos - ).tree - } - /* def convertToTypeTree(tree: Tree): Tree = tree match { case TypeTree() => tree diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala index 5dd9ce0e02..48ec941b50 100644 --- a/src/compiler/scala/tools/nsc/util/ClassPath.scala +++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala @@ -26,12 +26,12 @@ object ClassPath { def scalaLibrary = locate[Option[_]] def scalaCompiler = locate[Global] - def infoFor[T](value: T) = info(value.getClass) - def info[T](clazz: Class[T]) = new ClassAndJarInfo()(ClassManifest[T](clazz)) - def info[T: ClassManifest] = new ClassAndJarInfo[T] - def locate[T: ClassManifest] = info[T].rootClasspath - def locateJar[T: ClassManifest] = info[T].rootPossibles find (x => isJarOrZip(x)) map (x => File(x)) - def locateDir[T: ClassManifest] = info[T].rootPossibles find (_.isDirectory) map (_.toDirectory) + def infoFor[T](value: T) = info(value.getClass) + def info[T](clazz: Class[T]) = new ClassAndJarInfo()(ClassTag[T](clazz)) + def info[T: ClassTag] = new ClassAndJarInfo[T] + def locate[T: ClassTag] = info[T].rootClasspath + def locateJar[T: ClassTag] = info[T].rootPossibles find (x => isJarOrZip(x)) map (x => File(x)) + def locateDir[T: ClassTag] = info[T].rootPossibles find (_.isDirectory) map (_.toDirectory) /** Expand single path entry */ private def expandS(pattern: String): List[String] = { diff --git a/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala b/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala index 700fe0c1a6..120cceb238 100644 --- a/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala +++ b/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala @@ -67,8 +67,8 @@ trait ScalaClassLoader extends JClassLoader { result } - def constructorsOf[T <: AnyRef : Manifest]: List[Constructor[T]] = - manifest[T].erasure.getConstructors.toList map (_.asInstanceOf[Constructor[T]]) + def constructorsOf[T <: AnyRef : ClassTag]: List[Constructor[T]] = + classTag[T].erasure.getConstructors.toList map (_.asInstanceOf[Constructor[T]]) /** The actual bytes for a class file, or an empty array if it can't be found. */ def classBytes(className: String): Array[Byte] = classAsStream(className) match { @@ -125,9 +125,9 @@ object ScalaClassLoader { def bootLoader = apply(null) def contextChain = loaderChain(contextLoader) - def pathToErasure[T: ClassManifest] = pathToClass(classManifest[T].erasure) - def pathToClass(clazz: Class[_]) = clazz.getName.replace('.', JFile.separatorChar) + ".class" - def locate[T: ClassManifest] = contextLoader getResource pathToErasure[T] + def pathToErasure[T: ClassTag] = pathToClass(classTag[T].erasure) + def pathToClass(clazz: Class[_]) = clazz.getName.replace('.', JFile.separatorChar) + ".class" + def locate[T: ClassTag] = contextLoader getResource pathToErasure[T] /** Tries to guess the classpath by type matching the context classloader * and its parents, looking for any classloaders which will reveal their diff --git a/src/compiler/scala/tools/reflect/Invoked.scala b/src/compiler/scala/tools/reflect/Invoked.scala index 30c6201a0d..516c6b9bf6 100644 --- a/src/compiler/scala/tools/reflect/Invoked.scala +++ b/src/compiler/scala/tools/reflect/Invoked.scala @@ -16,7 +16,7 @@ class Invoked private (val proxy: AnyRef, val m: Method, val args: List[AnyRef]) def name = m.getName def arity = m.getParameterTypes.size def returnType = m.getReturnType - def returns[T: Manifest] = returnType == manifest[T].erasure + def returns[T: ClassTag] = returnType == classTag[T].erasure def invokeOn(target: AnyRef) = m.invoke(target, args: _*) def isObjectMethod = Set("toString", "equals", "hashCode") contains name diff --git a/src/compiler/scala/tools/reflect/UniversalFn.scala b/src/compiler/scala/tools/reflect/UniversalFn.scala index 9ccd580560..b0c2a19021 100644 --- a/src/compiler/scala/tools/reflect/UniversalFn.scala +++ b/src/compiler/scala/tools/reflect/UniversalFn.scala @@ -26,8 +26,8 @@ class UniversalFn private (val closure: AnyRef, val method: Method) extends (Seq * them to this universal function. Will throw an exception in the * face of any bad data. */ - def as[T: Manifest] : T = { - val clazz = manifest[T].erasure + def as[T: ClassTag] : T = { + val clazz = classTag[T].erasure require(clazz.isInterface, "Type argument must be an interface.") val interfaceMethods = clazz.getDeclaredMethods.toSet diff --git a/src/compiler/scala/tools/reflect/package.scala b/src/compiler/scala/tools/reflect/package.scala index f5c836a4e9..0b0c0905cb 100644 --- a/src/compiler/scala/tools/reflect/package.scala +++ b/src/compiler/scala/tools/reflect/package.scala @@ -27,17 +27,17 @@ package object reflect { } } - def zeroOfClass(clazz: Class[_]) = zeroOf(Manifest(ClassManifest(clazz).tpe)) - def zeroOf[T](implicit m: Manifest[T]): AnyRef = { - if (m == manifest[Boolean] || m == manifest[jl.Boolean]) false: jl.Boolean - else if (m == manifest[Unit] || m == manifest[jl.Void] || m == manifest[scala.runtime.BoxedUnit]) scala.runtime.BoxedUnit.UNIT - else if (m == manifest[Char] || m == manifest[jl.Character]) 0.toChar: jl.Character - else if (m == manifest[Byte] || m == manifest[jl.Byte]) 0.toByte: jl.Byte - else if (m == manifest[Short] || m == manifest[jl.Short]) 0.toShort: jl.Short - else if (m == manifest[Int] || m == manifest[jl.Integer]) 0: jl.Integer - else if (m == manifest[Long] || m == manifest[jl.Long]) 0l: jl.Long - else if (m == manifest[Float] || m == manifest[jl.Float]) 0f: jl.Float - else if (m == manifest[Double] || m == manifest[jl.Double]) 0d: jl.Double + def zeroOfClass(clazz: Class[_]) = zeroOf(ClassTag(clazz)) + def zeroOf[T](implicit t: ClassTag[T]): AnyRef = { + if (t == classTag[Boolean] || t == classTag[jl.Boolean]) false: jl.Boolean + else if (t == classTag[Unit] || t == classTag[jl.Void] || t == classTag[scala.runtime.BoxedUnit]) scala.runtime.BoxedUnit.UNIT + else if (t == classTag[Char] || t == classTag[jl.Character]) 0.toChar: jl.Character + else if (t == classTag[Byte] || t == classTag[jl.Byte]) 0.toByte: jl.Byte + else if (t == classTag[Short] || t == classTag[jl.Short]) 0.toShort: jl.Short + else if (t == classTag[Int] || t == classTag[jl.Integer]) 0: jl.Integer + else if (t == classTag[Long] || t == classTag[jl.Long]) 0l: jl.Long + else if (t == classTag[Float] || t == classTag[jl.Float]) 0f: jl.Float + else if (t == classTag[Double] || t == classTag[jl.Double]) 0d: jl.Double else null } } diff --git a/src/compiler/scala/tools/util/StringOps.scala b/src/compiler/scala/tools/util/StringOps.scala index 02eb364abe..725e0afb79 100644 --- a/src/compiler/scala/tools/util/StringOps.scala +++ b/src/compiler/scala/tools/util/StringOps.scala @@ -25,6 +25,16 @@ trait StringOps { val ys = oempty(xs: _*) if (ys.isEmpty) orElse else ys mkString sep } + def trimTrailingSpace(s: String) = { + if (s.length == 0 || !s.charAt(s.length - 1).isWhitespace) s + else { + var idx = s.length - 1 + while (idx >= 0 && s.charAt(idx).isWhitespace) + idx -= 1 + + s.substring(0, idx + 1) + } + } def decompose(str: String, sep: Char): List[String] = { def ws(start: Int): List[String] = diff --git a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala index af0d768607..bed8e93d1b 100644 --- a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala +++ b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala @@ -94,8 +94,7 @@ abstract class CPSAnnotationChecker extends CPSUtils { if (!cpsEnabled) return bounds val anyAtCPS = newCpsParamsMarker(NothingClass.tpe, AnyClass.tpe) - - if (isFunctionType(tparams.head.owner.tpe) || tparams.head.owner == PartialFunctionClass) { + if (isFunctionType(tparams.head.owner.tpe) || isPartialFunctionType(tparams.head.owner.tpe)) { vprintln("function bound: " + tparams.head.owner.tpe + "/"+bounds+"/"+targs) if (hasCpsParamTypes(targs.last)) bounds.reverse match { diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala index 0975f16c6e..e1d699debc 100644 --- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala +++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala @@ -457,11 +457,13 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with val (anfStats, anfExpr) = rec(stms, cpsA, List()) // println("\nanf-block:\n"+ ((stms :+ expr) mkString ("{", "\n", "}")) +"\nBECAME\n"+ ((anfStats :+ anfExpr) mkString ("{", "\n", "}"))) - if (anfStats.nonEmpty && (anfStats forall gen.hasSynthCaseSymbol)) { + // SUPER UGLY HACK: handle virtpatmat-style matches, whose labels have already been turned into DefDefs + if (anfStats.nonEmpty && (anfStats forall (t => !t.isDef || gen.hasSynthCaseSymbol(t)))) { val (prologue, rest) = (anfStats :+ anfExpr) span (s => !s.isInstanceOf[DefDef]) // find first case // val (defs, calls) = rest partition (_.isInstanceOf[DefDef]) if (rest nonEmpty){ - val stats = prologue ++ rest.reverse // ++ calls + // the filter drops the ()'s emitted when transValue encountered a LabelDef + val stats = prologue ++ (rest filter (_.isInstanceOf[DefDef])).reverse // ++ calls // println("REVERSED "+ (stats mkString ("{", "\n", "}"))) (stats, localTyper.typed{Apply(Ident(rest.head.symbol), List())}) // call first label to kick-start the match } else (anfStats, anfExpr) diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala index 2db4054ef5..a78de8e6c8 100644 --- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala +++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala @@ -190,32 +190,29 @@ abstract class SelectiveCPSTransform extends PluginComponent with val targettp = transformCPSType(tree.tpe) -// val expr2 = if (catches.nonEmpty) { - val pos = catches.head.pos - val argSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableClass.tpe) - val rhs = Match(Ident(argSym), catches1) - val fun = Function(List(ValDef(argSym)), rhs) - val funSym = currentOwner.newValueParameter(cpsNames.catches, pos).setInfo(appliedType(PartialFunctionClass.tpe, List(ThrowableClass.tpe, targettp))) - val funDef = localTyper.typed(atPos(pos) { ValDef(funSym, fun) }) - val expr2 = localTyper.typed(atPos(pos) { Apply(Select(expr1, expr1.tpe.member(cpsNames.flatMapCatch)), List(Ident(funSym))) }) - - argSym.owner = fun.symbol - rhs.changeOwner(currentOwner -> fun.symbol) - - val exSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableClass.tpe) - - import CODE._ - // generate a case that is supported directly by the back-end - val catchIfDefined = CaseDef( - Bind(exSym, Ident(nme.WILDCARD)), - EmptyTree, - IF ((REF(funSym) DOT nme.isDefinedAt)(REF(exSym))) THEN (REF(funSym) APPLY (REF(exSym))) ELSE Throw(REF(exSym)) - ) - - val catch2 = localTyper.typedCases(List(catchIfDefined), ThrowableClass.tpe, targettp) - //typedCases(tree, catches, ThrowableClass.tpe, pt) - - localTyper.typed(Block(List(funDef), treeCopy.Try(tree, treeCopy.Block(block1, stms, expr2), catch2, finalizer1))) + val pos = catches.head.pos + val funSym = currentOwner.newValueParameter(cpsNames.catches, pos).setInfo(appliedType(PartialFunctionClass.tpe, List(ThrowableClass.tpe, targettp))) + val funDef = localTyper.typed(atPos(pos) { + ValDef(funSym, Match(EmptyTree, catches1)) + }) + val expr2 = localTyper.typed(atPos(pos) { + Apply(Select(expr1, expr1.tpe.member(cpsNames.flatMapCatch)), List(Ident(funSym))) + }) + + val exSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableClass.tpe) + + import CODE._ + // generate a case that is supported directly by the back-end + val catchIfDefined = CaseDef( + Bind(exSym, Ident(nme.WILDCARD)), + EmptyTree, + IF ((REF(funSym) DOT nme.isDefinedAt)(REF(exSym))) THEN (REF(funSym) APPLY (REF(exSym))) ELSE Throw(REF(exSym)) + ) + + val catch2 = localTyper.typedCases(List(catchIfDefined), ThrowableClass.tpe, targettp) + //typedCases(tree, catches, ThrowableClass.tpe, pt) + + localTyper.typed(Block(List(funDef), treeCopy.Try(tree, treeCopy.Block(block1, stms, expr2), catch2, finalizer1))) /* diff --git a/src/dbc/scala/dbc/DataType.scala b/src/dbc/scala/dbc/DataType.scala deleted file mode 100644 index 677621e0c0..0000000000 --- a/src/dbc/scala/dbc/DataType.scala +++ /dev/null @@ -1,69 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc; - - -/** An ISO-9075:2003 (SQL) data type. Mappings between SQL types and - * database specific types should be provided by the database driver. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class DataType { - - /** Tests whether this datatype is equivalent to another. Usually, two - * types are defined as equivalent if they are equal. Two types can be - * equivalent without being equal if values of those types will be - * encoded in the same native Scala type. - */ - def isEquivalent(datatype: DataType): Boolean; - - /** Tests whether this datatype is equivalent or a subtype of another - * datatype. Type <code>A</code> is said to be subtype of type - * <code>B</code> if any value of type <code>A</code> can be - * represented as a value of type <code>B</code>. - */ - def isSubtypeOf(datatype: DataType): Boolean; - - /** The native Scala type in which values of this SQL type will be - * encoded. - */ - type NativeType <: Any; - - /** The native Scala type in which values of this SQL type will be - * encoded. This must point to the same type as <code>NativeType</code>. - */ - def nativeTypeId: DataType.Id; - - /** Whether the value can take the null value, None when this property is - * unknown. - */ - def nullable: Option[Boolean] = None; - - /** The SQL name of the type */ - def sqlString: String = "UNDEFINED DATA TYPE" - -} - -@deprecated(DbcIsDeprecated, "2.9.0") object DataType { - - type Id = Int; - - val OBJECT : Id = 10; - val BOOLEAN : Id = 20; - val BYTE : Id = 30; - val SHORT : Id = 31; - val INT : Id = 32; - val LONG : Id = 33; - val BIG_INTEGER: Id = 34; - val BIG_DECIMAL: Id = 35; - val FLOAT : Id = 40; - val DOUBLE : Id = 41; - val STRING : Id = 50; - -} diff --git a/src/dbc/scala/dbc/Database.scala b/src/dbc/scala/dbc/Database.scala deleted file mode 100644 index 60e16367e8..0000000000 --- a/src/dbc/scala/dbc/Database.scala +++ /dev/null @@ -1,187 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc - - -import java.sql._ - -/** A link to a database. The <code>Database</code> abstract class must - * be specialised for every different DBMS. - * - * @author Gilles Dubochet - */ -@deprecated(DbcIsDeprecated, "2.9.0") case class Database(dbms: Vendor) { - - class Closed extends Exception {} - - /** A lock used for operations that need to be atomic for this database - * instance. */ - private val lock: scala.concurrent.Lock = new scala.concurrent.Lock() - - /** The vendor of the DBMS that contains this database. */ - private val vendor: Vendor = dbms - - /** The Database connections available to use. */ - private var availableConnections: List[Connection] = Nil - - /** The connections that are currently in use. */ - private var usedConnections: List[Connection] = Nil - - /** Whether the database no longer accepts new connections. */ - private var closing: Boolean = false; - - /** Retrieves a connection from the available connection pool or creates - * a new one. - * - * @return A connection that can be used to access the database. - */ - private def getConnection: Connection = { - if (closing) { - throw new Closed; - } else { - availableConnections match { - case Nil => { - lock.acquire; - val connection = vendor.getConnection; - usedConnections = connection :: usedConnections; - lock.release; - connection - } - case connection :: cs => { - lock.acquire; - availableConnections = cs; - usedConnections = connection :: usedConnections; - lock.release; - connection; - } - } - } - } - - /** Closes a connection to this database. A closed connection might - * also return to the available connection pool if the latter is depleted. - * - * @param connection The connection that should be closed. - */ - private def closeConnection(connection: Connection): Unit = { - if (closing) { - connection.close() - } else { - lock.acquire - usedConnections = usedConnections.filterNot(e => (e.equals(connection))); - if (availableConnections.length < vendor.retainedConnections) - availableConnections = connection :: availableConnections - else - connection.close() - lock.release - } - } - - /** .. - */ - def close() { - closing = true - for (conn <- availableConnections) conn.close() - } - - /** Executes a statement that returns a relation on this database. - * - * @param relationStatement The statement to execute. - * @return The relation returned by the database for this statement. - */ - def executeStatement(relationStatement: statement.Relation): result.Relation = - executeStatement(relationStatement, false); - - /** Executes a statement that returns a relation on this database. - * - * @param relationStatement The statement to execute. - * @param debug Whether debugging information should be printed on the console. - * @return The relation returned by the database for this statement. - */ - def executeStatement(relationStatement: statement.Relation, - debug: Boolean): result.Relation = - new scala.dbc.result.Relation { - val statement = relationStatement - if (debug) Console.println("## " + statement.sqlString) - private val connection = getConnection - val sqlResult = connection.createStatement().executeQuery(statement.sqlString) - closeConnection(connection) - statement.typeCheck(this) - } - - /** Executes a statement that updates the state of the database. - * @param statusStatement The statement to execute. - * @return The status of the database after the statement has been executed. */ - def executeStatement(statusStatement: statement.Status): result.Status[Unit] = - executeStatement(statusStatement, false); - - /** Executes a statement that updates the state of the database. - * - * @param statusStatement The statement to execute. - * @param debug Whether debugging information should be printed on the console. - * @return The status of the database after the statement has been executed. - */ - def executeStatement(statusStatement: statement.Status, - debug: Boolean): result.Status[Unit] = - new scala.dbc.result.Status[Unit] { - val statement = statusStatement; - if (debug) Console.println("## " + statement.sqlString); - def result = () - private val connection = getConnection; - val jdbcStatement: java.sql.Statement = connection.createStatement(); - jdbcStatement.execute(statement.sqlString); - val touchedCount = Some(jdbcStatement.getUpdateCount()); - closeConnection(connection); - } - - /** Executes a list of statements or other operations inside a transaction. - * Only statements are protected in a transaction, other Scala code is not. - * - * @param transactionStatement The transaction to execute as a closure. - * @return The status of the database after the transaction has been executed. - */ - def executeStatement[ResultType](transactionStatement: statement.Transaction[ResultType]): result.Status[ResultType] = - executeStatement(transactionStatement, false); - - /** Executes a list of statements or other operations inside a transaction. - * Only statements are protected in a transaction, other Scala code is not. - * - * @param transactionStatement The transaction to execute as a closure. - * @param debug Whether debugging information should be printed on the console. - * @return The status of the database after the transaction has been executed. - */ - def executeStatement[ResultType](transactionStatement: statement.Transaction[ResultType], debug: Boolean): result.Status[ResultType] = { - new scala.dbc.result.Status[ResultType] { - val touchedCount = None - val statement = transactionStatement - private val connection = getConnection - connection.setAutoCommit(false) - val jdbcStatement: java.sql.Statement = connection.createStatement(); - if (debug) Console.println("## " + transactionStatement.sqlStartString); - jdbcStatement.execute(transactionStatement.sqlStartString); - val result: ResultType = try { - val buffer = transactionStatement.transactionBody(Database.this); - if (debug) Console.println("## " + transactionStatement.sqlCommitString); - jdbcStatement.execute(transactionStatement.sqlCommitString); - buffer - } catch { - case e: Throwable => { - if (debug) Console.println("## " + transactionStatement.sqlAbortString); - jdbcStatement.execute(transactionStatement.sqlAbortString); - throw e - } - } - connection.setAutoCommit(true) - closeConnection(connection) - } - } - -} diff --git a/src/dbc/scala/dbc/Syntax.scala b/src/dbc/scala/dbc/Syntax.scala deleted file mode 100644 index 85cd1c1a1d..0000000000 --- a/src/dbc/scala/dbc/Syntax.scala +++ /dev/null @@ -1,47 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc; - - -import java.math.{BigDecimal, BigInteger}; - - -/** This class .. - * - */ -@deprecated(DbcIsDeprecated, "2.9.0") object Syntax { - - import syntax.DataTypeUtil; - - /* Data types */ - def boolean = DataTypeUtil.boolean; - def tinyint = DataTypeUtil.tinyint; - def smallint = DataTypeUtil.smallint; - def integer = DataTypeUtil.integer; - def bigint = DataTypeUtil.bigint; - def real = DataTypeUtil.real; - - def numeric(precision: Int) = DataTypeUtil.numeric(precision); - def numeric(precision: Int, scale: Int) = DataTypeUtil.numeric(precision, scale); - - def doublePrecision = DataTypeUtil.doublePrecision; - def character(length: Int) = DataTypeUtil.character(length); - def characterVarying(length: Int) = DataTypeUtil.characterVarying(length); - def characterLargeObject = DataTypeUtil.characterLargeObject; - - /* Statements */ - //def select - - /* Other stuff */ - def database (server: String, username: String, password: String): dbc.Database = - syntax.Database.database(server, username, password); - -} diff --git a/src/dbc/scala/dbc/Utilities.scala b/src/dbc/scala/dbc/Utilities.scala deleted file mode 100644 index c37b1bb98d..0000000000 --- a/src/dbc/scala/dbc/Utilities.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc; - - -/** An object offering transformation methods (views) on various values. - * This object's members must be visible in an expression to use value - * auto-conversion. - */ -@deprecated(DbcIsDeprecated, "2.9.0") object Utilities { - - implicit def constantToValue (obj: statement.expression.Constant): Value = - obj.constantValue; - - implicit def valueToConstant (obj: Value): statement.expression.Constant = - new statement.expression.Constant { - val constantValue = obj; - } - -} diff --git a/src/dbc/scala/dbc/Value.scala b/src/dbc/scala/dbc/Value.scala deleted file mode 100644 index a502f51cb5..0000000000 --- a/src/dbc/scala/dbc/Value.scala +++ /dev/null @@ -1,27 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc; - - -/** A SQL-99 value of any type. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Value { - - /** The SQL-99 type of the value. */ - val dataType: DataType; - - type NativeType = dataType.type#NativeType; - - val nativeValue: NativeType; - - /** A SQL-99 compliant string representation of the value. */ - def sqlString: String; - -} diff --git a/src/dbc/scala/dbc/Vendor.scala b/src/dbc/scala/dbc/Vendor.scala deleted file mode 100644 index 68f6102526..0000000000 --- a/src/dbc/scala/dbc/Vendor.scala +++ /dev/null @@ -1,41 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc; - - -import java.sql.{Connection, Driver}; - - -/** This class .. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Vendor { - - def nativeDriverClass: Class[_]; - def uri: java.net.URI; - def user: String; - def pass: String; - def nativeProperties: java.util.Properties = { - val properties = new java.util.Properties(); - properties.setProperty("user", user); - properties.setProperty("password", pass); - properties - } - - def retainedConnections: Int; - - def getConnection: Connection = { - val driver = nativeDriverClass.newInstance().asInstanceOf[Driver]; - driver.connect(uri.toString(),nativeProperties) - } - - def urlProtocolString: String; - -} diff --git a/src/dbc/scala/dbc/datatype/ApproximateNumeric.scala b/src/dbc/scala/dbc/datatype/ApproximateNumeric.scala deleted file mode 100644 index 31752e18c7..0000000000 --- a/src/dbc/scala/dbc/datatype/ApproximateNumeric.scala +++ /dev/null @@ -1,57 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A type category for all SQL types that store varying-precision - * numbers. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class ApproximateNumeric[Type] ( - override val nativeTypeId: DataType.Id -) extends datatype.Numeric[Type](nativeTypeId) { - - def isEquivalent(datatype: DataType) = datatype match { - case dt: ApproximateNumeric[_] => - (nativeTypeId == dt.nativeTypeId && - precisionRadix == dt.precisionRadix && - precision == dt.precision && - signed == dt.signed) - case _ => - false - } - - def isSubtypeOf (datatype:DataType) = datatype match { - case dt:ApproximateNumeric[_] => - (nativeTypeId == dt.nativeTypeId && - precisionRadix == dt.precisionRadix && - precision <= dt.precision && - signed == dt.signed) - case _ => - false - } - - /** A SQL-99 compliant string representation of the type. - * <h3>Compatibility notice</h3> This method assumes that a real - * uses 32 bits and a double 64. This is not defined in the - * standard but is usually the case. - */ - override def sqlString: java.lang.String = Tuple2(precisionRadix,precision) match { - case Tuple2(2,64) => "REAL" - case Tuple2(2,128) => "DOUBLE PRECISION" - case Tuple2(2,p) => - throw exception.UnsupportedFeature("SQL-99 does not support an approximate numeric type with a binary defined precision other than 16, 32 and 64 bits"); - case Tuple2(10,p) => "FLOAT (" + p.toString() + ")" - case Tuple2(pr,_) => - throw exception.UnsupportedFeature("SQL-99 does not support the precision of an approximate numeric type to be defined in a radix other than 2 or 10"); - } - -} diff --git a/src/dbc/scala/dbc/datatype/Boolean.scala b/src/dbc/scala/dbc/datatype/Boolean.scala deleted file mode 100644 index 4a32ce98f1..0000000000 --- a/src/dbc/scala/dbc/datatype/Boolean.scala +++ /dev/null @@ -1,31 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** The SQL type for a truth value. */ -@deprecated(DbcIsDeprecated, "2.9.0") class Boolean extends DataType { - - def isEquivalent (datatype:DataType) = datatype match { - case dt:Boolean => true - case _ => false - } - - def isSubtypeOf (datatype:DataType) = isEquivalent(datatype); - - type NativeType = scala.Boolean; - val nativeTypeId = DataType.BOOLEAN; - - /** A SQL-99 compliant string representation of the type. */ - override def sqlString: java.lang.String = "BOOLEAN"; - -} diff --git a/src/dbc/scala/dbc/datatype/Character.scala b/src/dbc/scala/dbc/datatype/Character.scala deleted file mode 100644 index 02dec06281..0000000000 --- a/src/dbc/scala/dbc/datatype/Character.scala +++ /dev/null @@ -1,40 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A SQL type for a string of characters of arbitrary length with - * arbitrary character set. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Character extends CharacterString { - - def isEquivalent(datatype: DataType) = datatype match { - case dt: Character => - length == dt.length && encoding == dt.encoding - case _ => - false - } - - def isSubtypeOf(datatype: DataType) = datatype match { - case dt: Character => - length >= dt.length && encoding == dt.encoding - case _ => - false - } - - /** The length of the string defined in characters. */ - def length: Int; - - /** A SQL-99 compliant string representation of the type. */ - override def sqlString: java.lang.String = "CHARACTER (" + length.toString() + ")"; - -} diff --git a/src/dbc/scala/dbc/datatype/CharacterLargeObject.scala b/src/dbc/scala/dbc/datatype/CharacterLargeObject.scala deleted file mode 100644 index 2c7ef64d66..0000000000 --- a/src/dbc/scala/dbc/datatype/CharacterLargeObject.scala +++ /dev/null @@ -1,31 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A SQL type for an unbounded length string of characters with arbitrary - * character set. */ -@deprecated(DbcIsDeprecated, "2.9.0") class CharacterLargeObject extends CharacterString { - - def isEquivalent (datatype:DataType) = datatype match { - case dt:CharacterLargeObject => { - encoding == dt.encoding - } - case _ => false - } - - def isSubtypeOf (datatype:DataType) = isEquivalent(datatype); - - /** A SQL-99 compliant string representation of the type. */ - override def sqlString: java.lang.String = "CHARACTER LARGE OBJECT"; - -} diff --git a/src/dbc/scala/dbc/datatype/CharacterString.scala b/src/dbc/scala/dbc/datatype/CharacterString.scala deleted file mode 100644 index 54d6e0111f..0000000000 --- a/src/dbc/scala/dbc/datatype/CharacterString.scala +++ /dev/null @@ -1,24 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A type category for all SQL types that store strings of characters. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterString extends String { - - type NativeType = java.lang.String; - val nativeTypeId = DataType.STRING; - - /** The name of the character set in which the string is encoded. */ - def encoding: Option[java.lang.String] = None; - -} diff --git a/src/dbc/scala/dbc/datatype/CharacterVarying.scala b/src/dbc/scala/dbc/datatype/CharacterVarying.scala deleted file mode 100644 index 9df487579f..0000000000 --- a/src/dbc/scala/dbc/datatype/CharacterVarying.scala +++ /dev/null @@ -1,41 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A SQL type for a varying length string of characters with arbitrary - * maximal length and arbitrary character set. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterVarying extends CharacterString { - - def isEquivalent(datatype: DataType) = datatype match { - case dt: CharacterVarying => - length == dt.length && encoding == dt.encoding - case _ => - false - } - - def isSubtypeOf(datatype: DataType) = datatype match { - case dt: CharacterVarying => - length >= dt.length && encoding == dt.encoding - case _ => - false - } - - /** The maximal length of the string defined in characters. */ - def length: Int; - - /** A SQL-99 compliant string representation of the type. */ - override def sqlString: java.lang.String = - "CHARACTER VARYING (" + length.toString() + ")"; - -} diff --git a/src/dbc/scala/dbc/datatype/ExactNumeric.scala b/src/dbc/scala/dbc/datatype/ExactNumeric.scala deleted file mode 100644 index a578846977..0000000000 --- a/src/dbc/scala/dbc/datatype/ExactNumeric.scala +++ /dev/null @@ -1,65 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A type category for all SQL types that store constant-precision - * numbers. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class ExactNumeric[Type]( - override val nativeTypeId: DataType.Id -) extends datatype.Numeric[Type](nativeTypeId) { - - def isEquivalent(datatype: DataType) = datatype match { - case dt: ExactNumeric[_] => - (nativeTypeId == dt.nativeTypeId && - precisionRadix == dt.precisionRadix && - precision == dt.precision && - scale == dt.scale && - signed == dt.signed) - case _ => - false - } - - def isSubtypeOf(datatype: DataType) = datatype match { - case dt: ExactNumeric[_] => - (nativeTypeId == dt.nativeTypeId && - precisionRadix == dt.precisionRadix && - precision <= dt.precision && - scale <= dt.scale && - signed == dt.signed) - case _ => - false - } - - /** The number of digits used after the decimal point. */ - def scale: Int; - - /** A SQL-99 compliant string representation of the type. - * <h3>Compatibility notice</h3> This method assumes that an integer - * uses 32 bits, a small 16 and a big 64. This is not defined in the - * standard but is usually the case. - */ - override def sqlString: java.lang.String = Tuple3(precisionRadix,precision,scale) match { - case Tuple3(2,16,0) => "SMALLINT" - case Tuple3(2,32,0) => "INTEGER" - case Tuple3(2,64,0) => "BIGINT" - case Tuple3(2,java.lang.Integer.MAX_VALUE,0) => "BIGINT" - case Tuple3(2,p,s) => - throw exception.UnsupportedFeature("SQL-99 does not support an exact numeric type with a binary defined precision other than 16, 32 and 64 bits"); - case Tuple3(10,p,0) => "NUMERIC (" + p.toString() + ")" - case Tuple3(10,p,s) => "NUMERIC (" + p.toString() + ", " + s.toString() + ")" - case Tuple3(pr,_,_) => - throw exception.UnsupportedFeature("SQL-99 does not support the precision of an exact numeric type to be defined in a radix other than 2 or 10"); - } - -} diff --git a/src/dbc/scala/dbc/datatype/Factory.scala b/src/dbc/scala/dbc/datatype/Factory.scala deleted file mode 100644 index bb9b3f5b61..0000000000 --- a/src/dbc/scala/dbc/datatype/Factory.scala +++ /dev/null @@ -1,250 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -import java.sql.Types._; -import java.math.BigInteger; -import java.math.BigDecimal; - -@deprecated(DbcIsDeprecated, "2.9.0") object Factory { - - final val java_lang_Integer_SIZE = 32; - final val java_lang_Long_SIZE = 64; - - /** Returns a nullable property formatted as a boolean option */ - def isNullable (metadata:java.sql.ResultSetMetaData, index:Int): Option[scala.Boolean] = - metadata.isNullable(index) match { - case java.sql.ResultSetMetaData.columnNoNulls => Some(false); - case java.sql.ResultSetMetaData.columnNullable => Some(true); - case java.sql.ResultSetMetaData.columnNullableUnknown => None; - } - - /** Returns the binary precision for an integer field. This should only be - * used to find precision for integer numbers. It assumes that - * bytes cannot be used partially (result % 8 = 0). */ - def bytePrecision (precision:Int, signed:scala.Boolean, safe:scala.Boolean): Int = { - val decimalPrecision = precision + (if (safe) 1 else 0); - Pair(signed,decimalPrecision) match { - case Pair(_,0) => java.lang.Integer.MAX_VALUE // That's a bit of a hack. - case Pair(_,dp) if (dp <= 3) => 8 - case Pair(_,dp) if (dp <= 5) => 16 - case Pair(true,dp) if (dp <= 7) => 24 - case Pair(false,dp) if (dp <= 8) => 24 - case Pair(_,dp) if (dp <= 10) => 32 - case Pair(true,dp) if (dp <= 12) => 40 - case Pair(false,dp) if (dp <= 13) => 40 - case Pair(_,dp) if (dp <= 15) => 48 - case Pair(_,dp) if (dp <= 17) => 56 - case Pair(true,dp) if (dp <= 19) => 64 - case Pair(false,dp) if (dp <= 20) => 64 - case Pair(_,dp) if (dp <= 22) => 72 - case Pair(true,dp) if (dp <= 24) => 80 - case Pair(false,dp) if (dp <= 25) => 80 - case Pair(_,dp) if (dp <= 27) => 88 - case Pair(_,dp) if (dp <= 29) => 96 - case Pair(_,dp) if (dp <= 32) => 104 - case Pair(_,dp) if (dp <= 34) => 112 - case Pair(true,dp) if (dp <= 36) => 120 - case Pair(false,dp) if (dp <= 37) => 120 - case Pair(_,dp) if (dp <= 39) => 128 - case _ => java.lang.Integer.MAX_VALUE - } - } - - def create (metadata:java.sql.ResultSetMetaData, index:Int): DataType = { - metadata.getColumnType(index) match { - /* Boolean data types. */ - case BOOLEAN => new datatype.Boolean { - override val nullable = isNullable(metadata,index); - } - case BIT => new datatype.Boolean { - override val nullable = isNullable(metadata,index); - } - /* Fixed precision numeric data types. */ - case DECIMAL => { - Pair(bytePrecision(metadata.getPrecision(index),metadata.isSigned(index),true),metadata.getScale(index) == 0) match { - case Pair(bp,true) if (bp <= java_lang_Integer_SIZE) => - new datatype.ExactNumeric[Int](DataType.INT) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - case Pair(bp,true) if (bp <= java_lang_Long_SIZE) => - new datatype.ExactNumeric[Long](DataType.LONG) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - case Pair(_,true) => - new datatype.ExactNumeric[BigInteger](DataType.BIG_INTEGER) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - case Pair(_,false) => - new datatype.ExactNumeric[BigDecimal](DataType.BIG_DECIMAL) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - } - } - case NUMERIC => { - Pair(bytePrecision(metadata.getPrecision(index),metadata.isSigned(index),true),metadata.getScale(index) == 0) match { - case Pair(bp,true) if (bp <= java_lang_Integer_SIZE) => - new datatype.ExactNumeric[Int](DataType.INT) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - case Pair(bp,true) if (bp <= java_lang_Long_SIZE) => - new datatype.ExactNumeric[Long](DataType.LONG) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - case Pair(_,true) => - new datatype.ExactNumeric[BigInteger](DataType.BIG_INTEGER) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - case Pair(_,false) => - new datatype.ExactNumeric[BigDecimal](DataType.BIG_DECIMAL) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 10; - val precision = metadata.getPrecision(index); - val signed = metadata.isSigned(index); - val scale = metadata.getScale(index); - } - } - } - /* Fixed precision integer data types. */ - case BIGINT => - new datatype.ExactNumeric[Long](DataType.LONG) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 2; - val precision = 64; - val signed = metadata.isSigned(index); - val scale = 0; - } - case INTEGER => - new datatype.ExactNumeric[Int](DataType.INT) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 2; - val precision = 32; - val signed = metadata.isSigned(index); - val scale = 0; - } - case SMALLINT => - new datatype.ExactNumeric[Short](DataType.SHORT) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 2; - val precision = 16; - val signed = metadata.isSigned(index); - val scale = 0; - } - case TINYINT => - new datatype.ExactNumeric[Byte](DataType.BYTE) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 2; - val precision = 8; - val signed = metadata.isSigned(index); - val scale = 0; - } - /* Floating point numeric data types. */ - case REAL => - new datatype.ApproximateNumeric[Float](DataType.FLOAT) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 2; - val precision = 64; - val signed = metadata.isSigned(index); - } - case DOUBLE => - new datatype.ApproximateNumeric[Double](DataType.DOUBLE) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 2; - val precision = 128; - val signed = metadata.isSigned(index); - } - case FLOAT => - new datatype.ApproximateNumeric[Double](DataType.DOUBLE) { - override val nullable = isNullable(metadata,index); - val precisionRadix = 2; - val precision = 128; - val signed = metadata.isSigned(index); - } - /* Character string data types. */ - case CHAR => new datatype.Character { - override val nullable = isNullable(metadata,index); - val length = metadata.getColumnDisplaySize(index); - } - case CLOB => new datatype.CharacterLargeObject { - override val nullable = isNullable(metadata,index); - } - case LONGVARCHAR => { - if (metadata.getColumnDisplaySize(index) >= 0) - new datatype.CharacterVarying { - override val nullable = isNullable(metadata,index); - def length = metadata.getColumnDisplaySize(index); - } - else // A PostgreSQL Hack - new datatype.CharacterLargeObject { - override val nullable = isNullable(metadata,index); - } - } - case VARCHAR => { - if (metadata.getColumnDisplaySize(index) >= 0) - new datatype.CharacterVarying { - override val nullable = isNullable(metadata,index); - def length = metadata.getColumnDisplaySize(index); - } - else // A PostgreSQL Hack - new datatype.CharacterLargeObject { - override val nullable = isNullable(metadata,index); - } - } - /* Undefined cases. */ - case OTHER => new datatype.Unknown { - override val nullable = isNullable(metadata, index); - } - /* Unsupported data types. */ - case REF | ARRAY | STRUCT => - sys.error ("I don't support composite data types yet."); - case DATALINK | DISTINCT | JAVA_OBJECT | NULL => - sys.error ("I won't support strange data types."); - /* Unsupported binary string data types. */ - case BINARY | BLOB | LONGVARBINARY | VARBINARY => - sys.error ("I don't support binary string data types yet."); - /* Unsupported date and time data types. */ - case DATE | TIME | TIMESTAMP => - sys.error ("I don't support date and time data types yet."); - /* Default case */ - case x => sys.error ("I don't know about this ("+metadata.getColumnTypeName(index)+") JDBC type.") - } - } -} diff --git a/src/dbc/scala/dbc/datatype/Numeric.scala b/src/dbc/scala/dbc/datatype/Numeric.scala deleted file mode 100644 index c13f454dde..0000000000 --- a/src/dbc/scala/dbc/datatype/Numeric.scala +++ /dev/null @@ -1,32 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A type category for all SQL types that store numbers. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Numeric[Type](_nativeTypeId: DataType.Id) extends DataType { - - type NativeType = Type; - val nativeTypeId = _nativeTypeId; - - /** The radix in which the precision (and scale when appliable) is defined. - * ISO-9075 only allows 2 and 10 for this value. - */ - def precisionRadix: Int; - - /** The number of significant digits for that number. */ - def precision: Int; - - /** Whether the number is signed or not. */ - def signed: scala.Boolean; - -} diff --git a/src/dbc/scala/dbc/datatype/String.scala b/src/dbc/scala/dbc/datatype/String.scala deleted file mode 100644 index 291504f777..0000000000 --- a/src/dbc/scala/dbc/datatype/String.scala +++ /dev/null @@ -1,24 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** A type category for all SQL types that store strings of elements. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class String extends DataType { - - /** The maximal possible length of the string defined in characters. - * This is an implementation-specific value. - */ - def maxLength: Option[Int] = None; - -} diff --git a/src/dbc/scala/dbc/datatype/Unknown.scala b/src/dbc/scala/dbc/datatype/Unknown.scala deleted file mode 100644 index 14a33c6be9..0000000000 --- a/src/dbc/scala/dbc/datatype/Unknown.scala +++ /dev/null @@ -1,34 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package datatype; - - -/** The SQL type for a truth value. */ -@deprecated(DbcIsDeprecated, "2.9.0") class Unknown extends DataType { - - def isEquivalent(datatype: DataType) = datatype match { - case dt: Unknown => - nativeTypeId == dt.nativeTypeId - case _ => - false - } - - def isSubtypeOf(datatype: DataType) = true; - - type NativeType = AnyRef; - val nativeTypeId = DataType.OBJECT; - - /** A SQL-99 compliant string representation of the type. */ - override def sqlString: java.lang.String = - sys.error("The 'UNKNOWN' data type cannot be represented."); - -} diff --git a/src/dbc/scala/dbc/exception/IncompatibleSchema.scala b/src/dbc/scala/dbc/exception/IncompatibleSchema.scala deleted file mode 100644 index c8d53bbf1a..0000000000 --- a/src/dbc/scala/dbc/exception/IncompatibleSchema.scala +++ /dev/null @@ -1,19 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package exception - - -/** A type category for all SQL types that store constant-precision numbers. */ -@deprecated(DbcIsDeprecated, "2.9.0") case class IncompatibleSchema ( - expectedSchema: List[DataType], - foundSchema: List[DataType] -) extends Exception; diff --git a/src/dbc/scala/dbc/exception/UnsupportedFeature.scala b/src/dbc/scala/dbc/exception/UnsupportedFeature.scala deleted file mode 100644 index dd6f904077..0000000000 --- a/src/dbc/scala/dbc/exception/UnsupportedFeature.scala +++ /dev/null @@ -1,16 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package exception - - -/** A type category for all SQL types that store constant-precision numbers. */ -@deprecated(DbcIsDeprecated, "2.9.0") case class UnsupportedFeature (msg: String) extends Exception; diff --git a/src/dbc/scala/dbc/package.scala b/src/dbc/scala/dbc/package.scala deleted file mode 100644 index b1552e11d3..0000000000 --- a/src/dbc/scala/dbc/package.scala +++ /dev/null @@ -1,6 +0,0 @@ -package scala - -package object dbc { - final val DbcIsDeprecated = - "scala.dbc will be removed after version 2.9. Use an active sql library such as scalaquery instead." -}
\ No newline at end of file diff --git a/src/dbc/scala/dbc/result/Field.scala b/src/dbc/scala/dbc/result/Field.scala deleted file mode 100644 index cd3309bb14..0000000000 --- a/src/dbc/scala/dbc/result/Field.scala +++ /dev/null @@ -1,63 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package result - - -import scala.dbc.datatype._ -import scala.dbc.value._ - -/** An ISO-9075:2003 (SQL) table field. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Field { - - /** The content (value) of the field. The type of this value is undefined, - * transformation into a useful type will be done by an automatic view - * function defined in the field object. - */ - def content: Value - - final def value[Type <: Value]: Type = - content.asInstanceOf[Type] - - final def exactNumericValue[NativeType] = - content.asInstanceOf[dbc.value.ExactNumeric[NativeType]] - - final def approximateNumericValue[NativeType] = - content.asInstanceOf[dbc.value.ApproximateNumeric[NativeType]] - - final def booleanValue = - content.asInstanceOf[dbc.value.Boolean] - - final def characterValue = - content.asInstanceOf[dbc.value.Character] - - final def characterLargeObjectValue = - content.asInstanceOf[dbc.value.CharacterLargeObject] - - final def characterVaryingValue = - content.asInstanceOf[dbc.value.CharacterVarying] - - final def unknownValue = - content.asInstanceOf[dbc.value.Unknown] - - /** The tuple that contains this field. */ - def originatingTuple: Tuple - - /** The field metadata attached to this field. */ - def metadata: FieldMetadata - -} - -@deprecated(DbcIsDeprecated, "2.9.0") object Field { - - implicit def fieldToValue (field: Field): Value = field.content - -} diff --git a/src/dbc/scala/dbc/result/FieldMetadata.scala b/src/dbc/scala/dbc/result/FieldMetadata.scala deleted file mode 100644 index 3c2de297d0..0000000000 --- a/src/dbc/scala/dbc/result/FieldMetadata.scala +++ /dev/null @@ -1,40 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package result - - -/** The class <code>FieldMetadata</cocde> provides informations attached to - * a field about its content and its relationship to the originating database. - */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class FieldMetadata { - - /** The name of the field. */ - def name: String - - /** The index of the field in the tuple. */ - def index: Int - - /** The expected type of the field. This information is used for automatic - * transformation of the field value into a usable type. - */ - def datatype: DataType - - /** The name of the catalog in the database from which the field originates */ - def catalog: String - - /** The name of the schema in the database from which the field originates */ - def schema: String - - /** The name of the table in the database from which the field originates */ - def table: String - -} diff --git a/src/dbc/scala/dbc/result/Relation.scala b/src/dbc/scala/dbc/result/Relation.scala deleted file mode 100644 index 98d653d61e..0000000000 --- a/src/dbc/scala/dbc/result/Relation.scala +++ /dev/null @@ -1,84 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package result - - -/** An ISO-9075:2003 (SQL) table. This is equivalent to a relation in the - * relational model. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Relation -extends collection.AbstractIterable[Tuple] - with Iterable[Tuple] { - - /** The statement that generated this relation. */ - def statement: scala.dbc.statement.Relation - - /** A JDBC result containing this relation. */ - protected def sqlResult: java.sql.ResultSet - - /** A JDBC metadata object attached to the relation. */ - protected def sqlMetadata: java.sql.ResultSetMetaData = sqlResult.getMetaData() - - /** Metadata about all fields in a tuple of the relation. */ - def metadata: List[FieldMetadata] = - for (count <- List.range(1, sqlMetadata.getColumnCount()+1)) yield - new FieldMetadata { - val name: String = sqlMetadata.getColumnName(count) - val index: Int = count - val datatype: DataType = dbc.datatype.Factory.create(sqlMetadata,count) - val catalog: String = sqlMetadata.getCatalogName(count) - val schema: String = sqlMetadata.getSchemaName(count) - val table: String = sqlMetadata.getTableName(count) - } - - /** Metadata about the field at the given index. If there is no such - * field <code>None</code> is returned instead. */ - def metadataFor (index:Int): Option[FieldMetadata] = { - val meta = metadata - if (meta.length > index) - Some(meta(index)) - else - None - } - - /** Metadata about the field with the given column name. If there is no - * such field, <code>None</code> is returned instead. */ - def metadataFor (name:String): Option[FieldMetadata] = - metadata.find(f=>(f.name==name)); - - /** An iterator on the tuples of the relation. - * <h3>Caution</h3> A Relation only has one single iterator, due to limitations - * in DBMS. This means that if this method is called multiple times, all returned - * iterators will share the same state. */ - def iterator: Iterator[Tuple] = new collection.AbstractIterator[Tuple] { - protected val result: java.sql.ResultSet = Relation.this.sqlResult - def hasNext: Boolean = resultNext - private var resultNext = result.next() - def next: Tuple = { - if (resultNext) { - val newTuple = new Tuple { - val me = this - val originatingRelation = Relation.this - val fields: List[Field] = for (fieldMetadata <- metadata) yield - new Field { - val metadata = fieldMetadata - val content = dbc.value.Factory.create(result,metadata.index,metadata.datatype) - val originatingTuple = me - } - } - resultNext = result.next() - newTuple - } - else sys.error("next on empty iterator") - } - } - -} diff --git a/src/dbc/scala/dbc/result/Status.scala b/src/dbc/scala/dbc/result/Status.scala deleted file mode 100644 index d3152a58ab..0000000000 --- a/src/dbc/scala/dbc/result/Status.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package result; - - -import scala.dbc.datatype._; - -/** An object containing the status of a query */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Status[ResultType] { - - /** The statement that generated this status result. */ - def statement: scala.dbc.statement.Statement; - - /** The number of elements modified or added by this statement. */ - def touchedCount: Option[Int]; - - def result: ResultType; - -} diff --git a/src/dbc/scala/dbc/result/Tuple.scala b/src/dbc/scala/dbc/result/Tuple.scala deleted file mode 100644 index 80ab5c22aa..0000000000 --- a/src/dbc/scala/dbc/result/Tuple.scala +++ /dev/null @@ -1,42 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package result; - - -/** An ISO-9075:2003 (SQL) table row. This is equivalent to a tuple in the relational model. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Tuple { - - /** All the fields contained in the tuple. */ - def fields: List[Field]; - - /** The relation that contains the tuple. */ - def originatingRelation: Relation; - - /** The field at the given index. If there is no such field (that is the index is out of bounds), <code>None</code> is returned instead. */ - def apply (index:Int): Field = - try { - fields(index) - } catch { - case e => - throw new java.lang.IndexOutOfBoundsException("Field at index "+index+" does not exist in relation"); - } - - /** The field with the given column name. If there is no such field, <code>None</code> is returned instead. */ - def apply (name:String): Field = { - def findField (fields: List[Field], name:String): Field = fields match { - case Nil => throw new java.lang.IndexOutOfBoundsException("Field '"+name+"' does not exist in relation") - case field :: _ if (field.metadata.name == name) => field - case field :: fields => findField (fields, name) - } - findField (fields, name); - } -} diff --git a/src/dbc/scala/dbc/statement/DerivedColumn.scala b/src/dbc/scala/dbc/statement/DerivedColumn.scala deleted file mode 100644 index ae05df986a..0000000000 --- a/src/dbc/scala/dbc/statement/DerivedColumn.scala +++ /dev/null @@ -1,38 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class DerivedColumn { - - /** The value for the column. This value can be of any type but must be - * calculated from fields that appear in a relation that takes part - * in the query. - */ - def valueExpression: Expression - - /** A new name for this field. This name must be unique for the query in - * which the column takes part. - */ - def asClause: Option[String] - - /** A SQL-99 compliant string representation of the derived column - * sub-statement. This only has a meaning inside a select statement. - */ - def sqlString: String = - valueExpression.sqlInnerString + - (asClause match { - case None => "" - case Some(ac) => " AS " + ac - }) - -} diff --git a/src/dbc/scala/dbc/statement/Expression.scala b/src/dbc/scala/dbc/statement/Expression.scala deleted file mode 100644 index c2da91e9ef..0000000000 --- a/src/dbc/scala/dbc/statement/Expression.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -/** An expression that calculates some value from fields. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Expression extends Relation { - - def fieldTypes: List[DataType] = Nil - - /** A SQL-99 compliant string representation of the expression. */ - def sqlString: String = "SELECT " + sqlInnerString - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. - */ - def sqlInnerString: String - -} diff --git a/src/dbc/scala/dbc/statement/Insert.scala b/src/dbc/scala/dbc/statement/Insert.scala deleted file mode 100644 index 189ccec54f..0000000000 --- a/src/dbc/scala/dbc/statement/Insert.scala +++ /dev/null @@ -1,31 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -import scala.dbc.statement.expression._ - -/** An insertion of values into a table. */ -@deprecated(DbcIsDeprecated, "2.9.0") case class Insert(insertionTarget: String, insertionData: InsertionData) - extends Status { - - /** A SQL-99 compliant string representation of the select statement. */ - def sqlString: String = - "INSERT INTO " + insertionTarget + " " + insertionData.sqlString - - /** The name of the table where the data should be added. */ - //def insertionTarget: String - - /** The data that will be added tot he table. */ - //def insertionData: InsertionData - -} diff --git a/src/dbc/scala/dbc/statement/InsertionData.scala b/src/dbc/scala/dbc/statement/InsertionData.scala deleted file mode 100644 index e91ad7efe6..0000000000 --- a/src/dbc/scala/dbc/statement/InsertionData.scala +++ /dev/null @@ -1,40 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -import scala.dbc.statement.expression._ - -/** Data to be inserted into a table in an <code>Insert</code>. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class InsertionData { - def sqlString: String -} - -@deprecated(DbcIsDeprecated, "2.9.0") object InsertionData { - /** Insertion of data resulting from a query on the database. */ - @deprecated(DbcIsDeprecated, "2.9.0") case class Subquery(query: Relation) extends InsertionData { - def sqlString = query.sqlString - } - /** Insertion of data as explicitly defined values. */ - @deprecated(DbcIsDeprecated, "2.9.0") case class Constructor( - columnNames: Option[List[String]], - columnValues: List[Expression] - ) extends InsertionData { - def sqlString = - (columnNames match { - case None => "" - case Some(cn) => cn.mkString(" (",", ",")") - }) + - " VALUES" + - columnValues.map(e => e.sqlInnerString).mkString(" (",", ",")") - } -} diff --git a/src/dbc/scala/dbc/statement/IsolationLevel.scala b/src/dbc/scala/dbc/statement/IsolationLevel.scala deleted file mode 100644 index b31614c3dd..0000000000 --- a/src/dbc/scala/dbc/statement/IsolationLevel.scala +++ /dev/null @@ -1,32 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class IsolationLevel { - def sqlString: String -} - -@deprecated(DbcIsDeprecated, "2.9.0") object IsolationLevel { - case object ReadUncommitted extends IsolationLevel { - def sqlString = "ISOLATION LEVEL READ UNCOMMITTED" - } - case object ReadCommitted extends IsolationLevel { - def sqlString = "ISOLATION LEVEL READ COMMITTED" - } - case object RepeatableRead extends IsolationLevel { - def sqlString = "ISOLATION LEVEL REPEATABLE READ" - } - case object Serializable extends IsolationLevel { - def sqlString = "ISOLATION LEVEL SERIALIZABLE" - } -} diff --git a/src/dbc/scala/dbc/statement/JoinType.scala b/src/dbc/scala/dbc/statement/JoinType.scala deleted file mode 100644 index 698612b10d..0000000000 --- a/src/dbc/scala/dbc/statement/JoinType.scala +++ /dev/null @@ -1,56 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -/** A join behaviour in a <code>Jointure</code>. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class JoinType { - /** A SQL-99 string representation of the join behaviour. */ - def sqlString: String -} - -@deprecated(DbcIsDeprecated, "2.9.0") object JoinType { - - /** A join behaviour where a joined tuple is created only when a - * corresponding tuple exists in both original relations. - */ - case object Inner extends JoinType { - val sqlString = "INNER JOIN" - } - - /** A join behaviour family where a joined tuple is created even when a - * tuple has no corresponding tuple in the other relation. The fields - * populated by values of the other tuple will receive the NULL value. - */ - abstract class Outer extends JoinType - - object Outer { - /** An outer join behaviour where there will be at least on tuple for - * every tuple in the left relation. - */ - case object Left extends Outer { - val sqlString = "LEFT OUTER JOIN" - } - /** An outer join behaviour where there will be at least on tuple for - * every tuple in the right relation. - */ - case object Right extends Outer { - val sqlString = "RIGHT OUTER JOIN" - } - /** An outer join behaviour where there will be at least on tuple for - * every tuple in both right and left relations. - */ - case object Full extends Outer { - val sqlString = "FULL OUTER JOIN" - } - } -} diff --git a/src/dbc/scala/dbc/statement/Jointure.scala b/src/dbc/scala/dbc/statement/Jointure.scala deleted file mode 100644 index 74c871cc3e..0000000000 --- a/src/dbc/scala/dbc/statement/Jointure.scala +++ /dev/null @@ -1,45 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -/** A jointure between two relations. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Jointure extends Relation { - - /** The relation on the left part of the join. */ - def leftRelation: Relation - - /** The relation on the right part of the join. */ - def rightRelation: Relation - - /** The type of the jointure. */ - def joinType: JoinType - - /** The condition on which the jointure needs be done. */ - def joinCondition: Option[Expression] - - /** A SQL-99 compliant string representation of the relation statement. */ - def sqlString: String = "SELECT * FROM " + sqlInnerString - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside a query. - */ - def sqlInnerString: String = - leftRelation.sqlInnerString + " " + - joinType.sqlString + " " + - rightRelation.sqlInnerString + - (joinCondition match { - case Some(jc) => jc.sqlString - case None => "" - }) - -} diff --git a/src/dbc/scala/dbc/statement/Relation.scala b/src/dbc/scala/dbc/statement/Relation.scala deleted file mode 100644 index 787707ee82..0000000000 --- a/src/dbc/scala/dbc/statement/Relation.scala +++ /dev/null @@ -1,55 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement; - - -/** A statement that returns a relation. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Relation extends Statement { - - def isCompatibleType: (DataType,DataType)=>Boolean = - ((dt,wdt)=>dt.isSubtypeOf(wdt)); - - def typeCheck (relation: result.Relation): Unit = { - val sameType: Boolean = ( - relation.metadata.length == fieldTypes.length && - (relation.metadata.zip(fieldTypes).forall({case Pair(field,expectedType) => - isCompatibleType(field.datatype, expectedType)})) - ); - if (!sameType) - throw new exception.IncompatibleSchema(fieldTypes,relation.metadata.map(field=>field.datatype)); - } - - def fieldTypes: List[DataType]; - - def sqlTypeString: String = - if (fieldTypes.isEmpty) - "UNTYPED" - else - fieldTypes.map(dt=>dt.sqlString).mkString("RELATION (",", ",")"); - - /** A SQL-99 compliant string representation of the statement. */ - def sqlString: String; - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String; - - /** Executes the statement on the given database. */ - def execute (database: scala.dbc.Database): scala.dbc.result.Relation = { - database.executeStatement(this); - } - - def execute (database:scala.dbc.Database, debug:Boolean): scala.dbc.result.Relation = { - database.executeStatement(this,debug); - } - -} diff --git a/src/dbc/scala/dbc/statement/Select.scala b/src/dbc/scala/dbc/statement/Select.scala deleted file mode 100644 index a9ca0212ed..0000000000 --- a/src/dbc/scala/dbc/statement/Select.scala +++ /dev/null @@ -1,99 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -/** A statement that when executed on a database will return a relation. - * The returned relation will be a subset of a table in the database or - * a jointure between such subsets. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Select extends Relation { - - /** Defines if duplicated tuples should be removed from the returned - * relation. <h3>Compatibility notice</h3> Some DBMS (PostgreSQL) allow - * uniqueness constrains on an arbitrary field instead of the entire - * tuple. */ - def setQuantifier: Option[SetQuantifier] - - /** Defines the output fields that a tuple in the returned relation will - * contain, and their content with respect to the tables in the - * database. If the fields are not specified (that is the list is - * empty), all possible input fields will be returned. <h3>Compatibility - * notice</h3> SQL's qualified asterisk select sublist is not - * available. */ - def selectList: List[DerivedColumn] - - /** Defines the relations from which the query will obtain its data.*/ - def fromClause: List[Relation] - - /** Defines condition that must be true in the returned relation's tuples. - * This value expression must return a boolean or boolean-compatible - * value. This condition is applied before any GROUP BY clause. - */ - def whereClause: Option[Expression] - - /** Defines the grouping of the returned relation's tuples. One tuple is - * returned for every group. The value of <code>selectList</code> must - * use aggregate functions for calculation. - */ - def groupByClause: Option[List[Expression]] - - /** Defines conditions that must be true in the returned relation's tuples. - * The value expression must return a boolean can only refer to fields - * that are grouped or to any field from inside an aggregate function. - */ - def havingClause: Option[Expression] - - /* def windowClause: Option[_]; */ - - /** A SQL-99 compliant string representation of the select statement. */ - def sqlString: String = ( - "SELECT" + - (setQuantifier match { - case None => "" - case Some(sq) => " " + sq.sqlString - }) + - (selectList match { - case Nil => " *" - case _ => (" " + selectList.tail.foldLeft(selectList.head.sqlString) - ((name:String, dc:DerivedColumn) => name + ", " + dc.sqlString)) - }) + - (fromClause match { - case Nil => sys.error("Empty from clause is not allowed") - case _ => (" FROM " + fromClause.tail.foldLeft(fromClause.head.sqlInnerString) - ((name:String, rel:Relation) => name + ", " + rel.sqlInnerString)) - }) + - (whereClause match { - case None => "" - case Some(expr) => " WHERE " + expr.sqlInnerString - }) + - (groupByClause match { - case None => "" - case Some(gbl) => gbl match { - case Nil => sys.error("Empty group by clause is not allowed") - case _ => - (" GROUP BY " + - gbl.tail.foldLeft(gbl.head.sqlInnerString) - ((name:String, gb) => name + ", " + gb.sqlInnerString)) - } - }) + - (havingClause match { - case None => "" - case Some(expr) => " HAVING " + expr.sqlString - }) - ); - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside a query. - */ - def sqlInnerString: String = "("+sqlString+")" - -} diff --git a/src/dbc/scala/dbc/statement/SetQuantifier.scala b/src/dbc/scala/dbc/statement/SetQuantifier.scala deleted file mode 100644 index 77a4b79b8d..0000000000 --- a/src/dbc/scala/dbc/statement/SetQuantifier.scala +++ /dev/null @@ -1,38 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -/** A set quantifier that defines the collection type of a relation. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class SetQuantifier { - /** A SQL-99 compliant string representation of the set quantifier. */ - def sqlString: String -} - -@deprecated(DbcIsDeprecated, "2.9.0") object SetQuantifier { - - /** A set quantifier that defines a relation as being a bag. That means - * that duplicates are allowed. - */ - case object AllTuples extends SetQuantifier { - /** A SQL-99 compliant string representation of the set quantifier. */ - def sqlString: String = "ALL" - } - - /** A set quantifier that defines a relation as being a set. That means - * that duplicates are not allowed and will be pruned. - */ - case object DistinctTuples extends SetQuantifier { - /** A SQL-99 compliant string representation of the set quantifier. */ - def sqlString: String = "DISTINCT" - } -} diff --git a/src/dbc/scala/dbc/statement/Status.scala b/src/dbc/scala/dbc/statement/Status.scala deleted file mode 100644 index 0ce64b978d..0000000000 --- a/src/dbc/scala/dbc/statement/Status.scala +++ /dev/null @@ -1,32 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - -import scala.dbc.Database -import scala.dbc.result - -/** A statement that changes the status of the database. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Status extends Statement { - - /** A SQL-99 compliant string representation of the statement. */ - def sqlString: String - - /** Executes the statement on the given database. */ - def execute(database: Database): result.Status[Unit] = { - database.executeStatement(this) - } - - def execute(database: Database, debug: Boolean): result.Status[Unit] = { - database.executeStatement(this, debug) - } - -} diff --git a/src/dbc/scala/dbc/statement/Table.scala b/src/dbc/scala/dbc/statement/Table.scala deleted file mode 100644 index e729f801a3..0000000000 --- a/src/dbc/scala/dbc/statement/Table.scala +++ /dev/null @@ -1,38 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement - - -/** A reference to a table in the database. - * @author Gilles Dubochet - * @version 1.0 */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Table extends Relation { - - /** The name of the table in the database. */ - def tableName: String - - /** The name that the table will be called in the enclosing statement. */ - def tableRename: Option[String] - - /** A SQL-99 compliant string representation of the relation statement. */ - def sqlString: String = "SELECT * FROM " + tableName - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside a query. */ - def sqlInnerString: String = - tableName + - (tableRename match { - case None => "" - case Some(rename) => " AS " + rename - }) - -} diff --git a/src/dbc/scala/dbc/statement/Transaction.scala b/src/dbc/scala/dbc/statement/Transaction.scala deleted file mode 100644 index 1740dae3f9..0000000000 --- a/src/dbc/scala/dbc/statement/Transaction.scala +++ /dev/null @@ -1,55 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement; - - -/** A statement that changes the status of the database. */ -@deprecated(DbcIsDeprecated, "2.9.0") case class Transaction [ResultType] ( - transactionBody: (scala.dbc.Database=>ResultType), - accessMode: Option[AccessMode], - isolationLevel: Option[IsolationLevel] -) extends Statement { - - /** A SQL-99 compliant string representation of the statement. */ - def sqlStartString: String = ( - "START TRANSACTION" + - (Pair(accessMode,isolationLevel) match { - case Pair(None,None) => "" - case Pair(Some(am),None) => " " + am.sqlString - case Pair(None,Some(il)) => " " + il.sqlString - case Pair(Some(am),Some(il)) => " " + am.sqlString + ", " + il.sqlString - }) - ); - - def sqlCommitString: String = { - "COMMIT" - } - - def sqlAbortString: String = { - "ROLLBACK" - } - - //def transactionBody: (()=>Unit); - - //def accessMode: Option[AccessMode]; - - //def isolationLevel: Option[IsolationLevel]; - - def execute (database: scala.dbc.Database): scala.dbc.result.Status[ResultType] = { - database.executeStatement(this); - } - - def execute (database: scala.dbc.Database, debug: Boolean): scala.dbc.result.Status[ResultType] = { - database.executeStatement(this,debug); - } - -} diff --git a/src/dbc/scala/dbc/statement/Update.scala b/src/dbc/scala/dbc/statement/Update.scala deleted file mode 100644 index 836549a4be..0000000000 --- a/src/dbc/scala/dbc/statement/Update.scala +++ /dev/null @@ -1,47 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement; - - -import scala.dbc.statement.expression._; - -/** An update of the state of a table. */ -@deprecated(DbcIsDeprecated, "2.9.0") case class Update ( - updateTarget: String, - setClauses: List[SetClause], - whereClause: Option[Expression] -) extends Status { - - - /** A SQL-99 compliant string representation of the select statement. */ - def sqlString: String = ( - "UPDATE " + - updateTarget + - " SET " + setClauses.map(sc=>sc.sqlString).mkString("",", ","") + - (whereClause match { - case None => "" - case Some(expr) => " WHERE " + expr.sqlString - }) - ); - - /** The name of the table that should be updated. */ - //def updateTarget: String; - - /** The data that will be added tot he table. */ - //def setClauses: List[SetClause]; - - /** Defines condition that must be true in the tuples that will be updated. - * This value expression must return a boolean or boolean-compatible - * value. */ - //def whereClause: Option[scala.dbc.statement.expression.Expression]; - -} diff --git a/src/dbc/scala/dbc/statement/expression/Aggregate.scala b/src/dbc/scala/dbc/statement/expression/Aggregate.scala deleted file mode 100644 index c42bffe20e..0000000000 --- a/src/dbc/scala/dbc/statement/expression/Aggregate.scala +++ /dev/null @@ -1,35 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Aggregate extends Expression { - - def aggregateName: String; - - def setFunction: SetFunction; - - def filterClause: Option[Expression]; - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = ( - aggregateName + - "(" + setFunction.sqlString + ")" + - (filterClause match { - case None => "" - case Some(fc) => " FILTER (WHERE " + fc.sqlString + ")" - }) - ) - -} diff --git a/src/dbc/scala/dbc/statement/expression/BinaryOperator.scala b/src/dbc/scala/dbc/statement/expression/BinaryOperator.scala deleted file mode 100644 index 32f016dbf6..0000000000 --- a/src/dbc/scala/dbc/statement/expression/BinaryOperator.scala +++ /dev/null @@ -1,33 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class BinaryOperator extends Expression { - - /** The name of the operator. */ - def operator: String; - - /** The expression applied on the left of the operator. */ - def leftOperand: Expression; - - /** The expression applied on the right of the operator. */ - def rightOperand: Expression; - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = { - leftOperand.sqlInnerString + " " + operator + " " + rightOperand.sqlInnerString - } - -} diff --git a/src/dbc/scala/dbc/statement/expression/Constant.scala b/src/dbc/scala/dbc/statement/expression/Constant.scala deleted file mode 100644 index 70ec7819dc..0000000000 --- a/src/dbc/scala/dbc/statement/expression/Constant.scala +++ /dev/null @@ -1,23 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Constant extends Expression { - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = constantValue.sqlString; - - /** The value of the constant. */ - def constantValue: Value; -} diff --git a/src/dbc/scala/dbc/statement/expression/Default.scala b/src/dbc/scala/dbc/statement/expression/Default.scala deleted file mode 100644 index 78204d0172..0000000000 --- a/src/dbc/scala/dbc/statement/expression/Default.scala +++ /dev/null @@ -1,22 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -case object Default extends Expression { - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = "DEFAULT"; - -} diff --git a/src/dbc/scala/dbc/statement/expression/Field.scala b/src/dbc/scala/dbc/statement/expression/Field.scala deleted file mode 100644 index 9a90903a99..0000000000 --- a/src/dbc/scala/dbc/statement/expression/Field.scala +++ /dev/null @@ -1,40 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Field extends Expression { - - /** The name of the schema in the database where the field is located. */ - def schemaName: Option[String] = None; - - /** The name of the table in the database where the field is located. */ - def tableName: Option[String]; - - /** The name of the field in the database. */ - def fieldName: String; - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = ( - (schemaName match { - case None => "" - case Some(sn) => sn + "." - }) + - (tableName match { - case None => "" - case Some(tn) => tn + "." - }) + fieldName - ) - -} diff --git a/src/dbc/scala/dbc/statement/expression/FunctionCall.scala b/src/dbc/scala/dbc/statement/expression/FunctionCall.scala deleted file mode 100644 index 962cf209b9..0000000000 --- a/src/dbc/scala/dbc/statement/expression/FunctionCall.scala +++ /dev/null @@ -1,33 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") case class FunctionCall ( - functionName: String, - arguments: List[Expression] -) extends Expression { - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = { - functionName + "(" + arguments.mkString("",", ","") + ")" - } - - /** The name of the function to call. */ - //def functionName: String; - - /** A list of all argument expressions to pass to the function, in order. */ - //def arguments: List[Expression]; - -} diff --git a/src/dbc/scala/dbc/statement/expression/Select.scala b/src/dbc/scala/dbc/statement/expression/Select.scala deleted file mode 100644 index 7a6a4a21c4..0000000000 --- a/src/dbc/scala/dbc/statement/expression/Select.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Select extends Expression { - - /** The actual select statement */ - def selectStatement: statement.Select; - - /** A SQL-99 compliant string representation of the expression. */ - override def sqlString: String = selectStatement.sqlString; - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = "("+selectStatement.sqlString+")"; - -} diff --git a/src/dbc/scala/dbc/statement/expression/SetFunction.scala b/src/dbc/scala/dbc/statement/expression/SetFunction.scala deleted file mode 100644 index 060b2236f2..0000000000 --- a/src/dbc/scala/dbc/statement/expression/SetFunction.scala +++ /dev/null @@ -1,40 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class SetFunction { - /** A SQL-99 compliant string representation of the set quantifier. */ - def sqlString: String; -} - -@deprecated(DbcIsDeprecated, "2.9.0") object SetFunction { - abstract class Asterisk extends SetFunction { - def sqlString = "(*)"; - } - abstract class General extends SetFunction { - def setQuantifier: Option[SetQuantifier]; - def valueExpression: Expression; - def sqlString = ( - "(" + - (setQuantifier match { - case None => "" - case Some(sq) => sq.sqlString + " " - }) + - valueExpression.sqlString + ")" - ); - } - abstract class Binary extends SetFunction { - def sqlString = sys.error("Binary set function is not supported yet."); - } -} diff --git a/src/dbc/scala/dbc/statement/expression/TypeCast.scala b/src/dbc/scala/dbc/statement/expression/TypeCast.scala deleted file mode 100644 index dbb8dc1b4d..0000000000 --- a/src/dbc/scala/dbc/statement/expression/TypeCast.scala +++ /dev/null @@ -1,32 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") case class TypeCast ( - expression: Expression, - castType: DataType -) extends Expression { - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = { - "CAST (" + expression.sqlInnerString + " AS " + castType.sqlString + ")"; - } - - /** The expression that will be casted. */ - //def expression: Expression; - - /** The type to which to cast. */ - //def castType: scala.dbc.datatype.DataType; -} diff --git a/src/dbc/scala/dbc/statement/expression/UnaryOperator.scala b/src/dbc/scala/dbc/statement/expression/UnaryOperator.scala deleted file mode 100644 index 4172c451fb..0000000000 --- a/src/dbc/scala/dbc/statement/expression/UnaryOperator.scala +++ /dev/null @@ -1,33 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package statement -package expression; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class UnaryOperator extends Expression { - - /** The name of the operator */ - def operator: String; - - /** Whether the operator comes before the operand or not. */ - def operatorIsLeft: Boolean; - - /** The operand applied to the operator. */ - def operand: Expression; - - /** A SQL-99 compliant string representation of the relation sub- - * statement. This only has a meaning inside another statement. */ - def sqlInnerString: String = operatorIsLeft match { - case true => operator + " " + operand.sqlInnerString; - case false => operand.sqlInnerString + " " + operator; - } -} diff --git a/src/dbc/scala/dbc/syntax/DataTypeUtil.scala b/src/dbc/scala/dbc/syntax/DataTypeUtil.scala deleted file mode 100644 index a0ebd1713e..0000000000 --- a/src/dbc/scala/dbc/syntax/DataTypeUtil.scala +++ /dev/null @@ -1,98 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package syntax; - - -import java.math.BigDecimal; -import java.math.BigInteger; - -@deprecated(DbcIsDeprecated, "2.9.0") object DataTypeUtil { - - final val java_lang_Integer_SIZE = 32; - final val java_lang_Long_SIZE = 64; - - def boolean = new datatype.Boolean; - def tinyint = new datatype.ExactNumeric[Byte](dbc.DataType.BYTE) { - val precisionRadix = 2; - val precision = 8; - val signed = true; - val scale = 0; - } - def smallint = new datatype.ExactNumeric[Short](dbc.DataType.SHORT) { - val precisionRadix = 2; - val precision = 16; - val signed = true; - val scale = 0; - } - def integer = new datatype.ExactNumeric[Int](dbc.DataType.INT) { - val precisionRadix = 2; - val precision = 32; - val signed = true; - val scale = 0; - } - def bigint = new datatype.ExactNumeric[Long](dbc.DataType.LONG) { - val precisionRadix = 2; - val precision = 64; - val signed = true; - val scale = 0; - } - def numeric (_precision:Int): DataType = numeric(_precision,0); - def numeric (_precision:Int, _scale:Int): DataType = - Pair(datatype.Factory.bytePrecision(_precision,true,true),_scale == 0) match { - case Pair(bp,true) if (bp <= java_lang_Integer_SIZE) => - new datatype.ExactNumeric[Int](DataType.INT) { - val precisionRadix = 10; - val precision = _precision; - val signed = true; - val scale = 0; - } - case Pair(bp,true) if (bp <= java_lang_Long_SIZE) => - new datatype.ExactNumeric[Long](DataType.LONG) { - val precisionRadix = 10; - val precision = _precision; - val signed = true; - val scale = 0; - } - case Pair(_,true) => - new datatype.ExactNumeric[BigInteger](DataType.BIG_INTEGER) { - val precisionRadix = 10; - val precision = _precision; - val signed = true; - val scale = 0; - } - case Pair(_,false) => - new datatype.ExactNumeric[BigDecimal](DataType.BIG_DECIMAL) { - val precisionRadix = 10; - val precision = _precision; - val signed = true; - val scale = _scale; - } - } - def real = new datatype.ApproximateNumeric[Float](DataType.FLOAT) { - val precisionRadix = 2; - val precision = 64; - val signed = true; - } - def doublePrecision = new datatype.ApproximateNumeric[Double](DataType.DOUBLE) { - val precisionRadix = 2; - val precision = 128; - val signed = true; - } - def character (_length: Int) = new datatype.Character { - val length = _length; - } - def characterVarying (_length: Int) = new datatype.CharacterVarying { - def length = _length; - } - def characterLargeObject = new datatype.CharacterLargeObject; - -} diff --git a/src/dbc/scala/dbc/syntax/Database.scala b/src/dbc/scala/dbc/syntax/Database.scala deleted file mode 100644 index 4357fb7d4c..0000000000 --- a/src/dbc/scala/dbc/syntax/Database.scala +++ /dev/null @@ -1,33 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package syntax; - - -import java.net.URI; - -@deprecated(DbcIsDeprecated, "2.9.0") object Database { - - def database (server:String, username:String, password:String): dbc.Database = { - val uri = new URI(server); - // Java 1.5 if (uri.toString().contains("postgres")) { - if (uri.toString().indexOf("postgres") != -1) { - new dbc.Database(new vendor.PostgreSQL { - val uri = new URI(server); - val user = username; - val pass = password; - }) - } else { - throw new Exception("No DBMS vendor support could be found for the given URI"); - } - } - -} diff --git a/src/dbc/scala/dbc/syntax/Statement.scala b/src/dbc/scala/dbc/syntax/Statement.scala deleted file mode 100644 index baccbfaa64..0000000000 --- a/src/dbc/scala/dbc/syntax/Statement.scala +++ /dev/null @@ -1,274 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package syntax; - - -import java.math.BigDecimal; -import java.math.BigInteger; - -import StatementExpression._; - -/* - -ASSUMPTIONS: - -IMPROVABLE: -For type safety, all types must be defined. If one is missing, none is taken into account. -It is possible to redefine many types or renamings for a field, in that case, - only the last one is taken into account ("a" as "b" as "c" of boolean as "e" of integer - is equivalent to "a" as "e" of integer). - -FIXED: - -*/ - -@deprecated(DbcIsDeprecated, "2.9.0") object Statement { - - // SELECT ZYGOTE ... - - def select: SelectZygote = new SelectZygote { - val setQuantifier = None; - } - def selectBag: SelectZygote = new SelectZygote { - val setQuantifier = Some(statement.SetQuantifier.AllTuples); - } - def selectSet: SelectZygote = new SelectZygote { - val setQuantifier = Some(statement.SetQuantifier.DistinctTuples); - } - - abstract class SelectZygote { - def setQuantifier: Option[statement.SetQuantifier]; - def fields (sdc:SelectDerivedColumns): SelectOf = new SelectOf { - val setQuantifier = SelectZygote.this.setQuantifier; - val selectList = sdc.selectList; - val selectTypes = sdc.selectTypes; - } - } - - abstract class SelectDerivedField { - def fieldValue: StatementField; - def fieldRename: Option[String] = {val x = None; x} - def fieldType: Option[dbc.DataType] = {val x = None; x} - def as (rename:String): SelectDerivedField = new SelectDerivedField { - val fieldValue = SelectDerivedField.this.fieldValue; - override val fieldRename = Some(rename); - override val fieldType = SelectDerivedField.this.fieldType; - } - def of (datatype:dbc.DataType): SelectDerivedField = new SelectDerivedField { - val fieldValue = SelectDerivedField.this.fieldValue; - override val fieldRename = SelectDerivedField.this.fieldRename; - override val fieldType = Some(datatype); - } - } - - implicit def statementFieldToSelectDerivedField (fv:StatementField): SelectDerivedField = new SelectDerivedField { - val fieldValue = fv; - } - - implicit def stringToSelectDerivedField (fv:String): SelectDerivedField = new SelectDerivedField { - val fieldValue: StatementField = StatementExpression.stringToStatementField(fv); - } - - abstract class SelectDerivedColumns { - def selectList: List[statement.DerivedColumn]; - def selectTypes: List[DataType]; - def and (sdc:SelectDerivedColumns): SelectDerivedColumns = new SelectDerivedColumns { - val selectList = SelectDerivedColumns.this.selectList ::: sdc.selectList; - val selectTypes = - if (SelectDerivedColumns.this.selectTypes.isEmpty | sdc.selectTypes.isEmpty) - Nil - else - SelectDerivedColumns.this.selectTypes ::: sdc.selectTypes; - } - } - - implicit def selectDerivedFieldToSelectDerivedColumns (sdf:SelectDerivedField): SelectDerivedColumns = new SelectDerivedColumns { - val selectList = List(new statement.DerivedColumn { - val valueExpression = sdf.fieldValue.toStatement; - val asClause = sdf.fieldRename; - }); - val selectTypes = if (sdf.fieldType.isEmpty) Nil else List(sdf.fieldType.get); - } - - implicit def stringToSelectDerivedColumns (sdfs:String): SelectDerivedColumns = { - val sdf: SelectDerivedField = sdfs; - selectDerivedFieldToSelectDerivedColumns(sdf); - } - - // SELECT OF ... - - abstract class SelectOf { - def setQuantifier: Option[statement.SetQuantifier]; - def selectList: List[statement.DerivedColumn]; - def selectTypes: List[DataType]; - def from (sst:SelectSourceTables): SelectBeyond = new SelectBeyond { - val setQuantifier = SelectOf.this.setQuantifier; - val selectList = SelectOf.this.selectList; - val selectTypes = SelectOf.this.selectTypes; - val fromClause = sst.fromClause; - val whereClause = None; - val groupByClause = None; - val havingClause = None; - } - } - - abstract class SelectSourceTable { - def fromRelation: statement.Relation; - def innerJoin (sst: SelectSourceTable): SelectSourceTable = new SelectSourceTable { - val fromRelation = new statement.Jointure { - val leftRelation = SelectSourceTable.this.fromRelation; - val rightRelation = sst.fromRelation; - val joinType = statement.JoinType.Inner; - val joinCondition = None; - val fieldTypes = leftRelation.fieldTypes ::: rightRelation.fieldTypes; - } - } - def leftOuterJoin (sst: SelectSourceTable): SelectSourceTable = new SelectSourceTable { - val fromRelation = new statement.Jointure { - val leftRelation = SelectSourceTable.this.fromRelation; - val rightRelation = sst.fromRelation; - val joinType = statement.JoinType.Outer.Left; - val joinCondition = None; - val fieldTypes = leftRelation.fieldTypes ::: rightRelation.fieldTypes; - } - } - def rightOuterJoin (sst: SelectSourceTable): SelectSourceTable = new SelectSourceTable { - val fromRelation = new statement.Jointure { - val leftRelation = SelectSourceTable.this.fromRelation; - val rightRelation = sst.fromRelation; - val joinType = statement.JoinType.Outer.Right; - val joinCondition = None; - val fieldTypes = leftRelation.fieldTypes ::: rightRelation.fieldTypes; - } - } - def fullOuterJoin (sst: SelectSourceTable): SelectSourceTable = new SelectSourceTable { - val fromRelation = new statement.Jointure { - val leftRelation = SelectSourceTable.this.fromRelation; - val rightRelation = sst.fromRelation; - val joinType = statement.JoinType.Outer.Full; - val joinCondition = None; - val fieldTypes = leftRelation.fieldTypes ::: rightRelation.fieldTypes; - } - } - } - - implicit def stringToSelectSourceTable (sct:String): SelectSourceTable = new SelectSourceTable { - val fromRelation = new statement.Table { - val tableName = sct; - val tableRename = None; - val fieldTypes = Nil; - } - } - - implicit def selectToSelectSourceTable (sct:statement.Select): SelectSourceTable = new SelectSourceTable { - val fromRelation = sct; - } - - abstract class SelectSourceTables { - def fromClause: List[statement.Relation]; - def join (sct:SelectSourceTable): SelectSourceTables = new SelectSourceTables { - val fromClause = SelectSourceTables.this.fromClause ::: List(sct.fromRelation); - } - } - - implicit def stringToSelectSourceTables (sct:String): SelectSourceTables = new SelectSourceTables { - val fromClause = List(new statement.Table { - val tableName = sct; - val tableRename = None; - val fieldTypes = Nil; - }); - } - - implicit def selectToSelectSourceTables (sct:statement.Select): SelectSourceTables = new SelectSourceTables { - val fromClause = List(sct); - } - - implicit def selectSourceTableToSelectSourceTables (sct:SelectSourceTable): SelectSourceTables = new SelectSourceTables { - val fromClause = List(sct.fromRelation); - } - - // SELECT BEYOND ... - - abstract class SelectBeyond { - def setQuantifier: Option[statement.SetQuantifier]; - def selectList: List[statement.DerivedColumn]; - def selectTypes: List[DataType]; - def fromClause: List[statement.Relation]; - def whereClause: Option[statement.Expression]; - def groupByClause: Option[List[statement.Expression]]; - def havingClause: Option[statement.Expression]; - def where (se:StatementExpression): SelectBeyond = new SelectBeyond { - val setQuantifier = SelectBeyond.this.setQuantifier; - val selectList = SelectBeyond.this.selectList; - val selectTypes = SelectBeyond.this.selectTypes; - val fromClause = SelectBeyond.this.fromClause; - val whereClause = Some(se.toStatement); - val groupByClause = SelectBeyond.this.groupByClause; - val havingClause = SelectBeyond.this.havingClause; - } - def groupBy (sgb:SelectGroupBy): SelectBeyond = new SelectBeyond { - val setQuantifier = SelectBeyond.this.setQuantifier; - val selectList = SelectBeyond.this.selectList; - val selectTypes = SelectBeyond.this.selectTypes; - val fromClause = SelectBeyond.this.fromClause; - val whereClause = SelectBeyond.this.whereClause; - val groupByClause = Some(sgb.groupByClause); - val havingClause = SelectBeyond.this.havingClause; - } - def having (se:StatementExpression): SelectBeyond = new SelectBeyond { - val setQuantifier = SelectBeyond.this.setQuantifier; - val selectList = SelectBeyond.this.selectList; - val selectTypes = SelectBeyond.this.selectTypes; - val fromClause = SelectBeyond.this.fromClause; - val whereClause = SelectBeyond.this.whereClause; - val groupByClause = SelectBeyond.this.groupByClause; - val havingClause = Some(se.toStatement); - } - } - - implicit def selectBeyondToStatementSelect (sb:SelectBeyond): statement.Select = new statement.Select { - val setQuantifier = sb.setQuantifier; - val selectList = sb.selectList; - val fromClause = sb.fromClause; - val whereClause = sb.whereClause; - val groupByClause = sb.groupByClause; - val havingClause = sb.havingClause; - val fieldTypes = sb.selectTypes; - } - - abstract class SelectGroupBy { - def groupByClause: List[statement.Expression]; - def then (se:StatementExpression): SelectGroupBy = new SelectGroupBy { - val groupByClause = - SelectGroupBy.this.groupByClause ::: List(se.toStatement); - } - def then (se:String): SelectGroupBy = new SelectGroupBy { - val groupByClause = - SelectGroupBy.this.groupByClause ::: List(new statement.expression.Field { - val tableName = None; - val fieldName = se; - }); - } - } - - implicit def statementExpressionToSelectGroupBy (se:StatementExpression): SelectGroupBy = new SelectGroupBy { - val groupByClause = List(se.toStatement); - } - - implicit def stringToSelectGroupBy (se:String): SelectGroupBy = new SelectGroupBy { - val groupByClause = List(new statement.expression.Field { - val tableName = None; - val fieldName = se; - }); - } - -} diff --git a/src/dbc/scala/dbc/syntax/StatementExpression.scala b/src/dbc/scala/dbc/syntax/StatementExpression.scala deleted file mode 100644 index 65bb0947f7..0000000000 --- a/src/dbc/scala/dbc/syntax/StatementExpression.scala +++ /dev/null @@ -1,221 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package syntax; - - -import java.math.BigDecimal; -import java.math.BigInteger; - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class StatementExpression { - - def toStatement: statement.Expression; - - def and (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "AND"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def or (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "OR"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def == (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "="; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def < (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "<"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def > (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = ">"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def <= (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "<="; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def >= (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = ">="; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def <> (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "<>"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def isNull: StatementExpression = new StatementExpression { - val toStatement = new statement.expression.UnaryOperator { - val operator = "IS NULL"; - val operatorIsLeft = false; - val operand = StatementExpression.this.toStatement; - } - } - def isNotNull: StatementExpression = new StatementExpression { - val toStatement = new statement.expression.UnaryOperator { - val operator = "IS NOT NULL"; - val operatorIsLeft = false; - val operand = StatementExpression.this.toStatement; - } - } - def + (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "+"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def - (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "-"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def * (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "*"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def / (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "/"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def % (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "%"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def ^ (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "^"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def not : StatementExpression = new StatementExpression { - val toStatement = new statement.expression.UnaryOperator { - val operator = "!"; - val operatorIsLeft = false; - val operand = StatementExpression.this.toStatement; - } - } - def || (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "||"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def like (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "LIKE"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def similar (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "SIMILAR"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = se.toStatement; - } - } - def in (se:statement.Select): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.BinaryOperator { - val operator = "IN"; - val leftOperand = StatementExpression.this.toStatement; - val rightOperand = new statement.expression.Select { - val selectStatement = se; - }; - } - } - -} - -@deprecated(DbcIsDeprecated, "2.9.0") object StatementExpression { - - def not (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.UnaryOperator { - val operator = "NOT"; - val operatorIsLeft = true; - val operand = se.toStatement; - } - } - def abs (se:StatementExpression): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.UnaryOperator { - val operator = "@"; - val operatorIsLeft = true; - val operand = se.toStatement; - } - } - def exists (se:statement.Select): StatementExpression = new StatementExpression { - val toStatement = new statement.expression.UnaryOperator { - val operator = "EXISTS"; - val operatorIsLeft = true; - val operand = new statement.expression.Select { - val selectStatement = se; - }; - } - } - - abstract class StatementField extends StatementExpression { - def fieldName: String; - def tableName: Option[String] = None; - def in (tn:String): StatementField = new StatementField { - val fieldName = StatementField.this.fieldName; - override val tableName = Some(tn); - } - def toStatement: statement.expression.Field = new statement.expression.Field { - override val schemaName = None; - val tableName = StatementField.this.tableName; - val fieldName = StatementField.this.fieldName; - } - } - - implicit def stringToStatementField (ef:String): StatementField = new StatementField { - val fieldName = ef; - } - - - - -} diff --git a/src/dbc/scala/dbc/value/ApproximateNumeric.scala b/src/dbc/scala/dbc/value/ApproximateNumeric.scala deleted file mode 100644 index fa47d8815b..0000000000 --- a/src/dbc/scala/dbc/value/ApproximateNumeric.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class ApproximateNumeric [Type] extends Value { - - val dataType: datatype.ApproximateNumeric[Type]; - - def sqlString = nativeValue.toString(); - - } - -@deprecated(DbcIsDeprecated, "2.9.0") object ApproximateNumeric { - - implicit def approximateNumericToFloar (obj:value.ApproximateNumeric[Float]): Float = obj.nativeValue; - implicit def approximateNumericToDouble (obj:value.ApproximateNumeric[Double]): Double = obj.nativeValue; - -} diff --git a/src/dbc/scala/dbc/value/Boolean.scala b/src/dbc/scala/dbc/value/Boolean.scala deleted file mode 100644 index 5221ce2328..0000000000 --- a/src/dbc/scala/dbc/value/Boolean.scala +++ /dev/null @@ -1,27 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Boolean extends Value { - - val dataType: datatype.Boolean; - - def sqlString = if (nativeValue) "TRUE" else "FALSE"; - -} - -@deprecated(DbcIsDeprecated, "2.9.0") object Boolean { - - implicit def booleanToBoolean (obj:value.Boolean): scala.Boolean = obj.nativeValue; - -} diff --git a/src/dbc/scala/dbc/value/Character.scala b/src/dbc/scala/dbc/value/Character.scala deleted file mode 100644 index 4ff983c591..0000000000 --- a/src/dbc/scala/dbc/value/Character.scala +++ /dev/null @@ -1,35 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -/** A SQL-99 value of type character string. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Character extends Value { - - override val dataType: datatype.Character; - - /** An SQL-99 compliant string representation of the value. */ - def sqlString: String = { - "'" + nativeValue + "'" - } - -} - -/** An object offering transformation methods (views) on the value. - * This object must be visible in an expression to use value auto- - * conversion. */ -@deprecated(DbcIsDeprecated, "2.9.0") object Character { - - /** A character string value as a native string. */ - implicit def characterToString (obj:value.Character): String = obj.nativeValue; - -} diff --git a/src/dbc/scala/dbc/value/CharacterLargeObject.scala b/src/dbc/scala/dbc/value/CharacterLargeObject.scala deleted file mode 100644 index b9e81eb3af..0000000000 --- a/src/dbc/scala/dbc/value/CharacterLargeObject.scala +++ /dev/null @@ -1,35 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -/** A SQL-99 value of type character large object. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterLargeObject extends Value { - - override val dataType: datatype.CharacterLargeObject; - - /** An SQL-99 compliant string representation of the value. */ - def sqlString: String = { - "'" + nativeValue + "'" - } - -} - -/** An object offering transformation methods (views) on the value. - * This object must be visible in an expression to use value auto- - * conversion. */ -@deprecated(DbcIsDeprecated, "2.9.0") object CharacterLargeObject { - - /** A character large object value as a native string. */ - implicit def characterLargeObjectToString (obj:value.CharacterLargeObject): String = obj.nativeValue; - -} diff --git a/src/dbc/scala/dbc/value/CharacterVarying.scala b/src/dbc/scala/dbc/value/CharacterVarying.scala deleted file mode 100644 index 72e7d06362..0000000000 --- a/src/dbc/scala/dbc/value/CharacterVarying.scala +++ /dev/null @@ -1,35 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -/** A SQL-99 value of type character varying string. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterVarying extends Value { - - override val dataType: datatype.CharacterVarying; - - /** An SQL-99 compliant string representation of the value. */ - def sqlString: String = { - "'" + nativeValue + "'" - } - -} - -/** An object offering transformation methods (views) on the value. - * This object must be visible in an expression to use value auto- - * conversion. */ -@deprecated(DbcIsDeprecated, "2.9.0") object CharacterVarying { - - /** A character varying string value as a native string. */ - implicit def characterVaryingToString (obj:value.CharacterVarying): String = obj.nativeValue; - -} diff --git a/src/dbc/scala/dbc/value/Conversion.scala b/src/dbc/scala/dbc/value/Conversion.scala deleted file mode 100644 index c9297e37db..0000000000 --- a/src/dbc/scala/dbc/value/Conversion.scala +++ /dev/null @@ -1,156 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - -import java.math._; - -@deprecated(DbcIsDeprecated, "2.9.0") object Conversion { - - class Illegal (msg:String) extends Exception(msg); - - implicit def view1 (value:Value): Byte = { - if (value.dataType.nativeTypeId == DataType.BYTE) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Byte]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to byte: "+value) - } - } - - implicit def view2 (value:Value): Short = { - if (value.dataType.nativeTypeId == DataType.BYTE) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Byte]]; - v.nativeValue.toShort - } else if (value.dataType.nativeTypeId == DataType.SHORT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Short]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to short: "+value) - } - } - - implicit def view3 (value:Value): Int = { - if (value.dataType.nativeTypeId == DataType.BYTE) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Byte]]; - v.nativeValue.toInt - } else if (value.dataType.nativeTypeId == DataType.SHORT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Short]]; - v.nativeValue.toInt - } else if (value.dataType.nativeTypeId == DataType.INT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Int]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to int: "+value) - } - } - - implicit def view4 (value:Value): Long = { - if (value.dataType.nativeTypeId == DataType.BYTE) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Byte]]; - v.nativeValue.toLong - } else if (value.dataType.nativeTypeId == DataType.SHORT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Short]]; - v.nativeValue.toLong - } else if (value.dataType.nativeTypeId == DataType.INT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Int]]; - v.nativeValue.toLong - } else if (value.dataType.nativeTypeId == DataType.LONG) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Long]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to long: "+value) - } - } - - implicit def view5 (value:Value): BigInteger = { - if (value.dataType.nativeTypeId == DataType.BYTE) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Byte]]; - new BigInteger(v.nativeValue.toString(),10) - } else if (value.dataType.nativeTypeId == DataType.SHORT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Short]]; - new BigInteger(v.nativeValue.toString(),10) - } else if (value.dataType.nativeTypeId == DataType.INT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Int]]; - new BigInteger(v.nativeValue.toString(),10) - } else if (value.dataType.nativeTypeId == DataType.LONG) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Long]]; - new BigInteger(v.nativeValue.toString(),10) - } else if (value.dataType.nativeTypeId == DataType.BIG_INTEGER) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[BigInteger]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to big integer: "+value) - } - } - - implicit def view6 (value:Value): BigDecimal = { - if (value.dataType.nativeTypeId == DataType.BYTE) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Byte]]; - new BigDecimal(v.nativeValue.toString()) - } else if (value.dataType.nativeTypeId == DataType.SHORT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Short]]; - new BigDecimal(v.nativeValue.toString()) - } else if (value.dataType.nativeTypeId == DataType.INT) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Int]]; - new BigDecimal(v.nativeValue.toString()) - } else if (value.dataType.nativeTypeId == DataType.LONG) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[Long]]; - new BigDecimal(v.nativeValue.toString()) - } else if (value.dataType.nativeTypeId == DataType.BIG_INTEGER) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[BigInteger]]; - new BigDecimal(v.nativeValue) - } else if (value.dataType.nativeTypeId == DataType.BIG_DECIMAL) { - val v = value.asInstanceOf[dbc.value.ExactNumeric[BigDecimal]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to big decimal: "+value) - } - } - - implicit def view7 (value:Value): Float = { - if (value.dataType.nativeTypeId == DataType.FLOAT) { - val v = value.asInstanceOf[dbc.value.ApproximateNumeric[Float]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to float: "+value) - } - } - - implicit def view8 (value:Value): Double = { - if (value.dataType.nativeTypeId == DataType.FLOAT) { - val v = value.asInstanceOf[dbc.value.ApproximateNumeric[Float]]; - v.nativeValue.toFloat - } else if (value.dataType.nativeTypeId == DataType.DOUBLE) { - val v = value.asInstanceOf[dbc.value.ApproximateNumeric[Double]]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to double: "+value) - } - } - - implicit def view9 (value:Value): scala.Boolean = { - if (value.dataType.nativeTypeId == DataType.BOOLEAN) { - val v = value.asInstanceOf[dbc.value.Boolean]; - v.nativeValue - } else { - throw new Illegal("Cannot convert value to boolean: "+value) - } - } - - implicit def view10 (value:Value): String = value match { - case v:dbc.value.Character => v.nativeValue; - case v:dbc.value.CharacterLargeObject => v.nativeValue; - case v:dbc.value.CharacterVarying => v.nativeValue; - case _ => throw new Illegal("Cannot convert value to string") - } - -} diff --git a/src/dbc/scala/dbc/value/ExactNumeric.scala b/src/dbc/scala/dbc/value/ExactNumeric.scala deleted file mode 100644 index 7cd8b89a8c..0000000000 --- a/src/dbc/scala/dbc/value/ExactNumeric.scala +++ /dev/null @@ -1,35 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -import java.math.BigInteger; -import java.math.BigDecimal; - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class ExactNumeric [Type] extends Value { - - val dataType: datatype.ExactNumeric[Type]; - - def sqlString = nativeValue.toString(); - -} - -@deprecated(DbcIsDeprecated, "2.9.0") object ExactNumeric { - - implicit def exactNumericToByte (obj:value.ExactNumeric[Byte]): Byte = obj.nativeValue; - implicit def exactNumericToShort (obj:value.ExactNumeric[Short]): Short = obj.nativeValue; - implicit def exactNumericToInt (obj:value.ExactNumeric[Int]): Int = obj.nativeValue; - implicit def exactNumericToLong (obj:value.ExactNumeric[Long]): Long = obj.nativeValue; - implicit def exactNumericToBigInteger (obj:value.ExactNumeric[BigInteger]): BigInteger = obj.nativeValue; - implicit def exactNumericToBigDecimal (obj:value.ExactNumeric[BigDecimal]): BigDecimal = obj.nativeValue; - -} diff --git a/src/dbc/scala/dbc/value/Factory.scala b/src/dbc/scala/dbc/value/Factory.scala deleted file mode 100644 index 2d6101f6de..0000000000 --- a/src/dbc/scala/dbc/value/Factory.scala +++ /dev/null @@ -1,95 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -import java.math.BigInteger; -import java.math.BigDecimal; - -@deprecated(DbcIsDeprecated, "2.9.0") object Factory { - - def create (result: java.sql.ResultSet, index: Int, expectedDataType: DataType): Value = { - expectedDataType.nativeTypeId match { - case DataType.OBJECT => - new value.Unknown { - val dataType = expectedDataType.asInstanceOf[datatype.Unknown]; - val nativeValue: AnyRef = result.getObject(index); - } - case DataType.STRING => { - expectedDataType match { - case t:datatype.Character => - new value.Character { - val dataType = t; - val nativeValue: String = result.getString(index); - } - case t:datatype.CharacterVarying => - new value.CharacterVarying { - val dataType = t; - val nativeValue: String = result.getString(index); - } - case t:datatype.CharacterLargeObject => - new value.CharacterLargeObject { - val dataType = t; - val nativeValue: String = result.getString(index); - } - } - } - case DataType.BOOLEAN => - new value.Boolean { - val dataType = expectedDataType.asInstanceOf[datatype.Boolean]; - val nativeValue: scala.Boolean = result.getBoolean(index); - } - case DataType.FLOAT => - new value.ApproximateNumeric[Float] { - val dataType = expectedDataType.asInstanceOf[datatype.ApproximateNumeric[Float]]; - val nativeValue: Float = result.getFloat(index); - } - case DataType.DOUBLE => - new value.ApproximateNumeric[Double] { - val dataType = expectedDataType.asInstanceOf[datatype.ApproximateNumeric[Double]]; - val nativeValue: Double = result.getDouble(index); - } - case DataType.BYTE => - new value.ExactNumeric[Byte] { - val dataType = expectedDataType.asInstanceOf[datatype.ExactNumeric[Byte]]; - val nativeValue: Byte = result.getByte(index); - } - case DataType.SHORT => - new value.ExactNumeric[Short] { - val dataType = expectedDataType.asInstanceOf[datatype.ExactNumeric[Short]]; - val nativeValue: Short = result.getShort(index); - } - case DataType.INT => - new value.ExactNumeric[Int] { - val dataType = expectedDataType.asInstanceOf[datatype.ExactNumeric[Int]]; - val nativeValue: Int = result.getInt(index); - } - case DataType.LONG => - new value.ExactNumeric[Long] { - val dataType = expectedDataType.asInstanceOf[datatype.ExactNumeric[Long]]; - val nativeValue:Long = result.getLong(index); - } - case DataType.BIG_INTEGER => - new value.ExactNumeric[BigInteger] { - val dataType = expectedDataType.asInstanceOf[datatype.ExactNumeric[BigInteger]]; - val nativeValue: BigInteger = result.getBigDecimal(index).unscaledValue(); - } - case DataType.BIG_DECIMAL => - new value.ExactNumeric[BigDecimal] { - val dataType = expectedDataType.asInstanceOf[datatype.ExactNumeric[BigDecimal]]; - val nativeValue: BigDecimal = result.getBigDecimal(index); - } - - } - } - -} diff --git a/src/dbc/scala/dbc/value/Unknown.scala b/src/dbc/scala/dbc/value/Unknown.scala deleted file mode 100644 index 89764a5831..0000000000 --- a/src/dbc/scala/dbc/value/Unknown.scala +++ /dev/null @@ -1,27 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package value; - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Unknown extends Value { - - val dataType: datatype.Unknown; - - def sqlString = sys.error("An 'ANY' value cannot be represented."); - -} - -@deprecated(DbcIsDeprecated, "2.9.0") object UnknownType { - - def view (obj:value.Unknown): AnyRef = obj.nativeValue; - -} diff --git a/src/dbc/scala/dbc/vendor/PostgreSQL.scala b/src/dbc/scala/dbc/vendor/PostgreSQL.scala deleted file mode 100644 index ac528d5f82..0000000000 --- a/src/dbc/scala/dbc/vendor/PostgreSQL.scala +++ /dev/null @@ -1,29 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.dbc -package vendor; - - -import compat.Platform - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class PostgreSQL extends Vendor { - - def uri:java.net.URI; - def user:String; - def pass:String; - - val retainedConnections = 5; - - val nativeDriverClass = Platform.getClassForName("org.postgresql.Driver"); - - val urlProtocolString = "jdbc:postgresql:" - -} diff --git a/src/detach/library/scala/remoting/Channel.scala b/src/detach/library/scala/remoting/Channel.scala index 541e45a477..54b8fb100e 100644 --- a/src/detach/library/scala/remoting/Channel.scala +++ b/src/detach/library/scala/remoting/Channel.scala @@ -116,20 +116,20 @@ class Channel protected (socket: Socket) { * the expected type. */ @throws(classOf[ChannelException]) - def receive[T](implicit expected: reflect.Manifest[T]): T = { - val found = in.readObject().asInstanceOf[reflect.Manifest[_]] + def receive[T](implicit expected: reflect.ClassTag[T]): T = { + val found = in.readObject().asInstanceOf[reflect.ClassTag[_]] info("receive: found="+found+", expected="+expected) - import scala.reflect.Manifest + import scala.reflect.ClassTag val x = found match { - case Manifest.Unit => () - case Manifest.Boolean => in.readBoolean() - case Manifest.Byte => in.readByte() - case Manifest.Char => in.readChar() - case Manifest.Short => in.readShort() - case Manifest.Int => in.readInt() - case Manifest.Long => in.readLong() - case Manifest.Float => in.readFloat() - case Manifest.Double => in.readDouble() + case ClassTag.Unit => () + case ClassTag.Boolean => in.readBoolean() + case ClassTag.Byte => in.readByte() + case ClassTag.Char => in.readChar() + case ClassTag.Short => in.readShort() + case ClassTag.Int => in.readInt() + case ClassTag.Long => in.readLong() + case ClassTag.Float => in.readFloat() + case ClassTag.Double => in.readDouble() case _ => in.readObject() } val res = if (found <:< expected) @@ -144,12 +144,12 @@ class Channel protected (socket: Socket) { /** <code>?</code> method may throw either an * <code>ClassNotFoundException</code> or an <code>IOException</code>. */ - def ?[T](implicit m: reflect.Manifest[T]): T = receive[T](m) + def ?[T](implicit t: reflect.ClassTag[T]): T = receive[T](t) /** <code>send</code> method may throw an <code>IOException</code>. */ - def send[T](x: T)(implicit m: reflect.Manifest[T]) { - out writeObject m + def send[T](x: T)(implicit t: reflect.ClassTag[T]) { + out writeObject t x match { case x: Unit => // nop case x: Boolean => out writeBoolean x @@ -168,7 +168,7 @@ class Channel protected (socket: Socket) { /** <code>!</code> method may throw an <code>IOException</code>. */ - def (implicit m: reflect.Manifest[T]) { send(x)(m) } + def (implicit m: reflect.ClassTag[T]) { send(x)(m) } def close() { try { socket.close() } diff --git a/src/intellij/dbc.iml.SAMPLE b/src/intellij/dbc.iml.SAMPLE index 5a6df4cfaa..d2647cfb26 100644 --- a/src/intellij/dbc.iml.SAMPLE +++ b/src/intellij/dbc.iml.SAMPLE @@ -12,9 +12,6 @@ </component> <component name="NewModuleRootManager" inherit-compiler-output="true"> <exclude-output /> - <content url="file://$MODULE_DIR$/../dbc"> - <sourceFolder url="file://$MODULE_DIR$/../dbc" isTestSource="false" /> - </content> <orderEntry type="inheritedJdk" /> <orderEntry type="sourceFolder" forTests="false" /> <orderEntry type="module" module-name="library" /> diff --git a/src/intellij/scala-lang.ipr.SAMPLE b/src/intellij/scala-lang.ipr.SAMPLE index 93b6285cfb..94a9329dd6 100644 --- a/src/intellij/scala-lang.ipr.SAMPLE +++ b/src/intellij/scala-lang.ipr.SAMPLE @@ -197,7 +197,6 @@ <modules> <module fileurl="file://$PROJECT_DIR$/actors.iml" filepath="$PROJECT_DIR$/actors.iml" /> <module fileurl="file://$PROJECT_DIR$/compiler.iml" filepath="$PROJECT_DIR$/compiler.iml" /> - <module fileurl="file://$PROJECT_DIR$/dbc.iml" filepath="$PROJECT_DIR$/dbc.iml" /> <module fileurl="file://$PROJECT_DIR$/library.iml" filepath="$PROJECT_DIR$/library.iml" /> <module fileurl="file://$PROJECT_DIR$/manual.iml" filepath="$PROJECT_DIR$/manual.iml" /> <module fileurl="file://$PROJECT_DIR$/partest.iml" filepath="$PROJECT_DIR$/partest.iml" /> diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala index 5b8ebde308..fd61cfd0a1 100644 --- a/src/library/scala/Array.scala +++ b/src/library/scala/Array.scala @@ -12,17 +12,17 @@ import scala.collection.generic._ import scala.collection.{ mutable, immutable } import mutable.{ ArrayBuilder, ArraySeq } import compat.Platform.arraycopy -import scala.reflect.ClassManifest +import scala.reflect.ArrayTag import scala.runtime.ScalaRunTime.{ array_apply, array_update } /** Contains a fallback builder for arrays when the element type - * does not have a class manifest. In that case a generic array is built. + * does not have a class tag. In that case a generic array is built. */ class FallbackArrayBuilding { /** A builder factory that generates a generic array. * Called instead of `Array.newBuilder` if the element type of an array - * does not have a class manifest. Note that fallbackBuilder factory + * does not have a class tag. Note that fallbackBuilder factory * needs an implicit parameter (otherwise it would not be dominated in * implicit search by `Array.canBuildFrom`). We make sure that * implicit search is always successful. @@ -48,16 +48,16 @@ class FallbackArrayBuilding { * @version 1.0 */ object Array extends FallbackArrayBuilding { - implicit def canBuildFrom[T](implicit m: ClassManifest[T]): CanBuildFrom[Array[_], T, Array[T]] = + implicit def canBuildFrom[T](implicit t: ArrayTag[T]): CanBuildFrom[Array[_], T, Array[T]] = new CanBuildFrom[Array[_], T, Array[T]] { - def apply(from: Array[_]) = ArrayBuilder.make[T]()(m) - def apply() = ArrayBuilder.make[T]()(m) + def apply(from: Array[_]) = ArrayBuilder.make[T]()(t) + def apply() = ArrayBuilder.make[T]()(t) } /** * Returns a new [[scala.collection.mutable.ArrayBuilder]]. */ - def newBuilder[T](implicit m: ClassManifest[T]): ArrayBuilder[T] = ArrayBuilder.make[T]()(m) + def newBuilder[T](implicit t: ArrayTag[T]): ArrayBuilder[T] = ArrayBuilder.make[T]()(t) private def slowcopy(src : AnyRef, srcPos : Int, @@ -98,14 +98,14 @@ object Array extends FallbackArrayBuilding { } /** Returns an array of length 0 */ - def empty[T: ClassManifest]: Array[T] = new Array[T](0) + def empty[T: ArrayTag]: Array[T] = new Array[T](0) /** Creates an array with given elements. * * @param xs the elements to put in the array * @return an array containing all elements from xs. */ - def apply[T: ClassManifest](xs: T*): Array[T] = { + def apply[T: ArrayTag](xs: T*): Array[T] = { val array = new Array[T](xs.length) var i = 0 for (x <- xs.iterator) { array(i) = x; i += 1 } @@ -194,23 +194,23 @@ object Array extends FallbackArrayBuilding { } /** Creates array with given dimensions */ - def ofDim[T: ClassManifest](n1: Int): Array[T] = + def ofDim[T: ArrayTag](n1: Int): Array[T] = new Array[T](n1) /** Creates a 2-dimensional array */ - def ofDim[T: ClassManifest](n1: Int, n2: Int): Array[Array[T]] = { + def ofDim[T: ArrayTag](n1: Int, n2: Int): Array[Array[T]] = { val arr: Array[Array[T]] = (new Array[Array[T]](n1): Array[Array[T]]) for (i <- 0 until n1) arr(i) = new Array[T](n2) arr // tabulate(n1)(_ => ofDim[T](n2)) } /** Creates a 3-dimensional array */ - def ofDim[T: ClassManifest](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] = + def ofDim[T: ArrayTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] = tabulate(n1)(_ => ofDim[T](n2, n3)) /** Creates a 4-dimensional array */ - def ofDim[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] = + def ofDim[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] = tabulate(n1)(_ => ofDim[T](n2, n3, n4)) /** Creates a 5-dimensional array */ - def ofDim[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] = + def ofDim[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] = tabulate(n1)(_ => ofDim[T](n2, n3, n4, n5)) /** Concatenates all arrays into a single array. @@ -218,7 +218,7 @@ object Array extends FallbackArrayBuilding { * @param xss the given arrays * @return the array created from concatenating `xss` */ - def concat[T: ClassManifest](xss: Array[T]*): Array[T] = { + def concat[T: ArrayTag](xss: Array[T]*): Array[T] = { val b = newBuilder[T] b.sizeHint(xss.map(_.size).sum) for (xs <- xss) b ++= xs @@ -239,7 +239,7 @@ object Array extends FallbackArrayBuilding { * @return an Array of size n, where each element contains the result of computing * `elem`. */ - def fill[T: ClassManifest](n: Int)(elem: => T): Array[T] = { + def fill[T: ArrayTag](n: Int)(elem: => T): Array[T] = { val b = newBuilder[T] b.sizeHint(n) var i = 0 @@ -257,7 +257,7 @@ object Array extends FallbackArrayBuilding { * @param n2 the number of elements in the 2nd dimension * @param elem the element computation */ - def fill[T: ClassManifest](n1: Int, n2: Int)(elem: => T): Array[Array[T]] = + def fill[T: ArrayTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]] = tabulate(n1)(_ => fill(n2)(elem)) /** Returns a three-dimensional array that contains the results of some element @@ -268,7 +268,7 @@ object Array extends FallbackArrayBuilding { * @param n3 the number of elements in the 3nd dimension * @param elem the element computation */ - def fill[T: ClassManifest](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]] = + def fill[T: ArrayTag](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]] = tabulate(n1)(_ => fill(n2, n3)(elem)) /** Returns a four-dimensional array that contains the results of some element @@ -280,7 +280,7 @@ object Array extends FallbackArrayBuilding { * @param n4 the number of elements in the 4th dimension * @param elem the element computation */ - def fill[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]] = + def fill[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]] = tabulate(n1)(_ => fill(n2, n3, n4)(elem)) /** Returns a five-dimensional array that contains the results of some element @@ -293,7 +293,7 @@ object Array extends FallbackArrayBuilding { * @param n5 the number of elements in the 5th dimension * @param elem the element computation */ - def fill[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]] = + def fill[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]] = tabulate(n1)(_ => fill(n2, n3, n4, n5)(elem)) /** Returns an array containing values of a given function over a range of integer @@ -303,7 +303,7 @@ object Array extends FallbackArrayBuilding { * @param f The function computing element values * @return A traversable consisting of elements `f(0),f(1), ..., f(n - 1)` */ - def tabulate[T: ClassManifest](n: Int)(f: Int => T): Array[T] = { + def tabulate[T: ArrayTag](n: Int)(f: Int => T): Array[T] = { val b = newBuilder[T] b.sizeHint(n) var i = 0 @@ -321,7 +321,7 @@ object Array extends FallbackArrayBuilding { * @param n2 the number of elements in the 2nd dimension * @param f The function computing element values */ - def tabulate[T: ClassManifest](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] = + def tabulate[T: ArrayTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] = tabulate(n1)(i1 => tabulate(n2)(f(i1, _))) /** Returns a three-dimensional array containing values of a given function @@ -332,7 +332,7 @@ object Array extends FallbackArrayBuilding { * @param n3 the number of elements in the 3rd dimension * @param f The function computing element values */ - def tabulate[T: ClassManifest](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]] = + def tabulate[T: ArrayTag](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]] = tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _))) /** Returns a four-dimensional array containing values of a given function @@ -344,7 +344,7 @@ object Array extends FallbackArrayBuilding { * @param n4 the number of elements in the 4th dimension * @param f The function computing element values */ - def tabulate[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]] = + def tabulate[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]] = tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _))) /** Returns a five-dimensional array containing values of a given function @@ -357,7 +357,7 @@ object Array extends FallbackArrayBuilding { * @param n5 the number of elements in the 5th dimension * @param f The function computing element values */ - def tabulate[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]] = + def tabulate[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]] = tabulate(n1)(i1 => tabulate(n2, n3, n4, n5)(f(i1, _, _, _, _))) /** Returns an array containing a sequence of increasing integers in a range. @@ -396,7 +396,7 @@ object Array extends FallbackArrayBuilding { * @param f the function that is repeatedly applied * @return the array returning `len` values in the sequence `start, f(start), f(f(start)), ...` */ - def iterate[T: ClassManifest](start: T, len: Int)(f: T => T): Array[T] = { + def iterate[T: ArrayTag](start: T, len: Int)(f: T => T): Array[T] = { val b = newBuilder[T] if (len > 0) { @@ -476,7 +476,7 @@ object Array extends FallbackArrayBuilding { * @define collectExample * @define undefinedorder * @define thatinfo the class of the returned collection. In the standard library configuration, - * `That` is either `Array[B]` if a ClassManifest is available for B or `ArraySeq[B]` otherwise. + * `That` is either `Array[B]` if an ArrayTag is available for B or `ArraySeq[B]` otherwise. * @define zipthatinfo $thatinfo * @define bfinfo an implicit value of class `CanBuildFrom` which determines the result class `That` from the current * representation type `Repr` and the new element type `B`. diff --git a/src/library/scala/Either.scala b/src/library/scala/Either.scala index a5e1dc7fe7..20451600a9 100644 --- a/src/library/scala/Either.scala +++ b/src/library/scala/Either.scala @@ -261,7 +261,7 @@ object Either { * case ex => Left(ex) * } * - * // this will only be executed if interactWithDB returns a Some + * // this will only be executed if interactWithDB returns a Right * val report = * for (r <- interactWithDB(someQuery).right) yield generateReport(r) * if (report.isRight) diff --git a/src/library/scala/Function0.scala b/src/library/scala/Function0.scala index dceed26439..3690a0e65b 100644 --- a/src/library/scala/Function0.scala +++ b/src/library/scala/Function0.scala @@ -6,13 +6,13 @@ ** |/ ** \* */ // GENERATED CODE: DO NOT EDIT. -// genprod generated these sources at: Tue Feb 14 16:49:03 PST 2012 +// genprod generated these sources at: Mon Apr 30 07:46:11 PDT 2012 package scala /** A function of 0 parameters. - * + * * In the following example, the definition of javaVersion is a * shorthand for the anonymous class definition anonfun0: * @@ -24,7 +24,7 @@ package scala * def apply(): String = sys.props("java.version") * } * assert(javaVersion() == anonfun0()) - * } + * } * }}} * * Note that `Function1` does not define a total function, as might diff --git a/src/library/scala/Function1.scala b/src/library/scala/Function1.scala index 8995ef912b..f9b37fc6bd 100644 --- a/src/library/scala/Function1.scala +++ b/src/library/scala/Function1.scala @@ -11,7 +11,7 @@ package scala /** A function of 1 parameter. - * + * * In the following example, the definition of succ is a * shorthand for the anonymous class definition anonfun1: * @@ -22,7 +22,7 @@ package scala * def apply(x: Int): Int = x + 1 * } * assert(succ(0) == anonfun1(0)) - * } + * } * }}} * * Note that `Function1` does not define a total function, as might @@ -44,7 +44,7 @@ trait Function1[@specialized(scala.Int, scala.Long, scala.Float, scala.Double, s * @param g a function A => T1 * @return a new function `f` such that `f(x) == apply(g(x))` */ - def compose[A](g: A => T1): A => R = { x => apply(g(x)) } + @annotation.unspecialized def compose[A](g: A => T1): A => R = { x => apply(g(x)) } /** Composes two instances of Function1 in a new Function1, with this function applied first. * @@ -52,7 +52,7 @@ trait Function1[@specialized(scala.Int, scala.Long, scala.Float, scala.Double, s * @param g a function R => A * @return a new function `f` such that `f(x) == g(apply(x))` */ - def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) } + @annotation.unspecialized def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) } override def toString() = "<function1>" } diff --git a/src/library/scala/Function10.scala b/src/library/scala/Function10.scala index 9e107fc53d..f7e5d414f2 100644 --- a/src/library/scala/Function10.scala +++ b/src/library/scala/Function10.scala @@ -21,16 +21,17 @@ trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)).curried } - /** Creates a tupled version of this function: instead of 10 arguments, * it accepts a single [[scala.Tuple10]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) == f(Tuple10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)` */ - def tupled: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] => R = { + + @annotation.unspecialized def tupled: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] => R = { case Tuple10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) } override def toString() = "<function10>" diff --git a/src/library/scala/Function11.scala b/src/library/scala/Function11.scala index 783a86ab5d..53742bf733 100644 --- a/src/library/scala/Function11.scala +++ b/src/library/scala/Function11.scala @@ -21,16 +21,17 @@ trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] ex /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)).curried } - /** Creates a tupled version of this function: instead of 11 arguments, * it accepts a single [[scala.Tuple11]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) == f(Tuple11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)` */ - def tupled: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] => R = { + + @annotation.unspecialized def tupled: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] => R = { case Tuple11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) } override def toString() = "<function11>" diff --git a/src/library/scala/Function12.scala b/src/library/scala/Function12.scala index 7f4dee6216..e349d9017d 100644 --- a/src/library/scala/Function12.scala +++ b/src/library/scala/Function12.scala @@ -21,16 +21,17 @@ trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)).curried } - /** Creates a tupled version of this function: instead of 12 arguments, * it accepts a single [[scala.Tuple12]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) == f(Tuple12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)` */ - def tupled: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] => R = { + + @annotation.unspecialized def tupled: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] => R = { case Tuple12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) } override def toString() = "<function12>" diff --git a/src/library/scala/Function13.scala b/src/library/scala/Function13.scala index 23853dde69..10ec64b87a 100644 --- a/src/library/scala/Function13.scala +++ b/src/library/scala/Function13.scala @@ -21,16 +21,17 @@ trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)).curried } - /** Creates a tupled version of this function: instead of 13 arguments, * it accepts a single [[scala.Tuple13]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) == f(Tuple13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)` */ - def tupled: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] => R = { + + @annotation.unspecialized def tupled: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] => R = { case Tuple13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) } override def toString() = "<function13>" diff --git a/src/library/scala/Function14.scala b/src/library/scala/Function14.scala index 372f1cfafb..82dd409223 100644 --- a/src/library/scala/Function14.scala +++ b/src/library/scala/Function14.scala @@ -21,16 +21,17 @@ trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)).curried } - /** Creates a tupled version of this function: instead of 14 arguments, * it accepts a single [[scala.Tuple14]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) == f(Tuple14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)` */ - def tupled: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] => R = { + + @annotation.unspecialized def tupled: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] => R = { case Tuple14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) } override def toString() = "<function14>" diff --git a/src/library/scala/Function15.scala b/src/library/scala/Function15.scala index 47c7309695..be5fbeeca1 100644 --- a/src/library/scala/Function15.scala +++ b/src/library/scala/Function15.scala @@ -21,16 +21,17 @@ trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)).curried } - /** Creates a tupled version of this function: instead of 15 arguments, * it accepts a single [[scala.Tuple15]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) == f(Tuple15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)` */ - def tupled: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] => R = { + + @annotation.unspecialized def tupled: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] => R = { case Tuple15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) } override def toString() = "<function15>" diff --git a/src/library/scala/Function16.scala b/src/library/scala/Function16.scala index 8eea42de5b..7a185b369c 100644 --- a/src/library/scala/Function16.scala +++ b/src/library/scala/Function16.scala @@ -21,16 +21,17 @@ trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)).curried } - /** Creates a tupled version of this function: instead of 16 arguments, * it accepts a single [[scala.Tuple16]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)) == f(Tuple16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)` */ - def tupled: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] => R = { + + @annotation.unspecialized def tupled: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] => R = { case Tuple16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) } override def toString() = "<function16>" diff --git a/src/library/scala/Function17.scala b/src/library/scala/Function17.scala index 2d93af34f2..94e0000802 100644 --- a/src/library/scala/Function17.scala +++ b/src/library/scala/Function17.scala @@ -21,16 +21,17 @@ trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)).curried } - /** Creates a tupled version of this function: instead of 17 arguments, * it accepts a single [[scala.Tuple17]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) == f(Tuple17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)` */ - def tupled: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] => R = { + + @annotation.unspecialized def tupled: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] => R = { case Tuple17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) } override def toString() = "<function17>" diff --git a/src/library/scala/Function18.scala b/src/library/scala/Function18.scala index ffca98c443..a3ee6776ba 100644 --- a/src/library/scala/Function18.scala +++ b/src/library/scala/Function18.scala @@ -21,16 +21,17 @@ trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)).curried } - /** Creates a tupled version of this function: instead of 18 arguments, * it accepts a single [[scala.Tuple18]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)) == f(Tuple18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)` */ - def tupled: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] => R = { + + @annotation.unspecialized def tupled: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] => R = { case Tuple18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) } override def toString() = "<function18>" diff --git a/src/library/scala/Function19.scala b/src/library/scala/Function19.scala index f661ea7707..038dcbb778 100644 --- a/src/library/scala/Function19.scala +++ b/src/library/scala/Function19.scala @@ -21,16 +21,17 @@ trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)).curried } - /** Creates a tupled version of this function: instead of 19 arguments, * it accepts a single [[scala.Tuple19]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)) == f(Tuple19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)` */ - def tupled: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] => R = { + + @annotation.unspecialized def tupled: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] => R = { case Tuple19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) } override def toString() = "<function19>" diff --git a/src/library/scala/Function2.scala b/src/library/scala/Function2.scala index cacb96ef5d..0794a4048a 100644 --- a/src/library/scala/Function2.scala +++ b/src/library/scala/Function2.scala @@ -11,7 +11,7 @@ package scala /** A function of 2 parameters. - * + * * In the following example, the definition of max is a * shorthand for the anonymous class definition anonfun2: * @@ -23,7 +23,7 @@ package scala * def apply(x: Int, y: Int): Int = if (x < y) y else x * } * assert(max(0, 1) == anonfun2(0, 1)) - * } + * } * }}} * * Note that `Function1` does not define a total function, as might @@ -40,16 +40,17 @@ trait Function2[@specialized(scala.Int, scala.Long, scala.Double) -T1, @speciali /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2) == apply(x1, x2)` - */ def curried: T1 => T2 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => R = { (x1: T1) => (x2: T2) => apply(x1, x2) } - /** Creates a tupled version of this function: instead of 2 arguments, * it accepts a single [[scala.Tuple2]] argument. * * @return a function `f` such that `f((x1, x2)) == f(Tuple2(x1, x2)) == apply(x1, x2)` */ - def tupled: Tuple2[T1, T2] => R = { + + @annotation.unspecialized def tupled: Tuple2[T1, T2] => R = { case Tuple2(x1, x2) => apply(x1, x2) } override def toString() = "<function2>" diff --git a/src/library/scala/Function20.scala b/src/library/scala/Function20.scala index e4fb9f280c..727684d6d5 100644 --- a/src/library/scala/Function20.scala +++ b/src/library/scala/Function20.scala @@ -21,16 +21,17 @@ trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)).curried } - /** Creates a tupled version of this function: instead of 20 arguments, * it accepts a single [[scala.Tuple20]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)) == f(Tuple20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)` */ - def tupled: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] => R = { + + @annotation.unspecialized def tupled: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] => R = { case Tuple20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) } override def toString() = "<function20>" diff --git a/src/library/scala/Function21.scala b/src/library/scala/Function21.scala index 9823386856..2441278be8 100644 --- a/src/library/scala/Function21.scala +++ b/src/library/scala/Function21.scala @@ -21,16 +21,17 @@ trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20)(x21) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)).curried } - /** Creates a tupled version of this function: instead of 21 arguments, * it accepts a single [[scala.Tuple21]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)) == f(Tuple21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)` */ - def tupled: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] => R = { + + @annotation.unspecialized def tupled: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] => R = { case Tuple21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) } override def toString() = "<function21>" diff --git a/src/library/scala/Function22.scala b/src/library/scala/Function22.scala index e708f7f49a..1f70b190a6 100644 --- a/src/library/scala/Function22.scala +++ b/src/library/scala/Function22.scala @@ -21,16 +21,17 @@ trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20)(x21)(x22) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => T22 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => T22 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21, x22: T22) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)).curried } - /** Creates a tupled version of this function: instead of 22 arguments, * it accepts a single [[scala.Tuple22]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)) == f(Tuple22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)` */ - def tupled: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] => R = { + + @annotation.unspecialized def tupled: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] => R = { case Tuple22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) } override def toString() = "<function22>" diff --git a/src/library/scala/Function3.scala b/src/library/scala/Function3.scala index 62a997c1b5..bbbde82056 100644 --- a/src/library/scala/Function3.scala +++ b/src/library/scala/Function3.scala @@ -21,16 +21,17 @@ trait Function3[-T1, -T2, -T3, +R] extends AnyRef { self => /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3) == apply(x1, x2, x3)` - */ def curried: T1 => T2 => T3 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => R = { (x1: T1) => (x2: T2) => (x3: T3) => apply(x1, x2, x3) } - /** Creates a tupled version of this function: instead of 3 arguments, * it accepts a single [[scala.Tuple3]] argument. * * @return a function `f` such that `f((x1, x2, x3)) == f(Tuple3(x1, x2, x3)) == apply(x1, x2, x3)` */ - def tupled: Tuple3[T1, T2, T3] => R = { + + @annotation.unspecialized def tupled: Tuple3[T1, T2, T3] => R = { case Tuple3(x1, x2, x3) => apply(x1, x2, x3) } override def toString() = "<function3>" diff --git a/src/library/scala/Function4.scala b/src/library/scala/Function4.scala index 86d2faeac8..f100860a97 100644 --- a/src/library/scala/Function4.scala +++ b/src/library/scala/Function4.scala @@ -21,16 +21,17 @@ trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef { self => /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4) == apply(x1, x2, x3, x4)` - */ def curried: T1 => T2 => T3 => T4 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => R = { (x1: T1) => (x2: T2) => (x3: T3) => (x4: T4) => apply(x1, x2, x3, x4) } - /** Creates a tupled version of this function: instead of 4 arguments, * it accepts a single [[scala.Tuple4]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4)) == f(Tuple4(x1, x2, x3, x4)) == apply(x1, x2, x3, x4)` */ - def tupled: Tuple4[T1, T2, T3, T4] => R = { + + @annotation.unspecialized def tupled: Tuple4[T1, T2, T3, T4] => R = { case Tuple4(x1, x2, x3, x4) => apply(x1, x2, x3, x4) } override def toString() = "<function4>" diff --git a/src/library/scala/Function5.scala b/src/library/scala/Function5.scala index bd9af77f12..cba9b6ce52 100644 --- a/src/library/scala/Function5.scala +++ b/src/library/scala/Function5.scala @@ -21,16 +21,17 @@ trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef { self => /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5) == apply(x1, x2, x3, x4, x5)` - */ def curried: T1 => T2 => T3 => T4 => T5 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5) => self.apply(x1, x2, x3, x4, x5)).curried } - /** Creates a tupled version of this function: instead of 5 arguments, * it accepts a single [[scala.Tuple5]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5)) == f(Tuple5(x1, x2, x3, x4, x5)) == apply(x1, x2, x3, x4, x5)` */ - def tupled: Tuple5[T1, T2, T3, T4, T5] => R = { + + @annotation.unspecialized def tupled: Tuple5[T1, T2, T3, T4, T5] => R = { case Tuple5(x1, x2, x3, x4, x5) => apply(x1, x2, x3, x4, x5) } override def toString() = "<function5>" diff --git a/src/library/scala/Function6.scala b/src/library/scala/Function6.scala index 4f601a468c..0b8addf7de 100644 --- a/src/library/scala/Function6.scala +++ b/src/library/scala/Function6.scala @@ -21,16 +21,17 @@ trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef { self => /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6) == apply(x1, x2, x3, x4, x5, x6)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6) => self.apply(x1, x2, x3, x4, x5, x6)).curried } - /** Creates a tupled version of this function: instead of 6 arguments, * it accepts a single [[scala.Tuple6]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6)) == f(Tuple6(x1, x2, x3, x4, x5, x6)) == apply(x1, x2, x3, x4, x5, x6)` */ - def tupled: Tuple6[T1, T2, T3, T4, T5, T6] => R = { + + @annotation.unspecialized def tupled: Tuple6[T1, T2, T3, T4, T5, T6] => R = { case Tuple6(x1, x2, x3, x4, x5, x6) => apply(x1, x2, x3, x4, x5, x6) } override def toString() = "<function6>" diff --git a/src/library/scala/Function7.scala b/src/library/scala/Function7.scala index 6978b6545d..2098658fa9 100644 --- a/src/library/scala/Function7.scala +++ b/src/library/scala/Function7.scala @@ -21,16 +21,17 @@ trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef { self => /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7) == apply(x1, x2, x3, x4, x5, x6, x7)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7) => self.apply(x1, x2, x3, x4, x5, x6, x7)).curried } - /** Creates a tupled version of this function: instead of 7 arguments, * it accepts a single [[scala.Tuple7]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7)) == f(Tuple7(x1, x2, x3, x4, x5, x6, x7)) == apply(x1, x2, x3, x4, x5, x6, x7)` */ - def tupled: Tuple7[T1, T2, T3, T4, T5, T6, T7] => R = { + + @annotation.unspecialized def tupled: Tuple7[T1, T2, T3, T4, T5, T6, T7] => R = { case Tuple7(x1, x2, x3, x4, x5, x6, x7) => apply(x1, x2, x3, x4, x5, x6, x7) } override def toString() = "<function7>" diff --git a/src/library/scala/Function8.scala b/src/library/scala/Function8.scala index 903551d939..08a480dce5 100644 --- a/src/library/scala/Function8.scala +++ b/src/library/scala/Function8.scala @@ -21,16 +21,17 @@ trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef { sel /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8) == apply(x1, x2, x3, x4, x5, x6, x7, x8)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8)).curried } - /** Creates a tupled version of this function: instead of 8 arguments, * it accepts a single [[scala.Tuple8]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8)) == f(Tuple8(x1, x2, x3, x4, x5, x6, x7, x8)) == apply(x1, x2, x3, x4, x5, x6, x7, x8)` */ - def tupled: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] => R = { + + @annotation.unspecialized def tupled: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] => R = { case Tuple8(x1, x2, x3, x4, x5, x6, x7, x8) => apply(x1, x2, x3, x4, x5, x6, x7, x8) } override def toString() = "<function8>" diff --git a/src/library/scala/Function9.scala b/src/library/scala/Function9.scala index 0c273ba929..2e35f7949c 100644 --- a/src/library/scala/Function9.scala +++ b/src/library/scala/Function9.scala @@ -21,16 +21,17 @@ trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef /** Creates a curried version of this function. * * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)` - */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => R = { + */ + @annotation.unspecialized def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)).curried } - /** Creates a tupled version of this function: instead of 9 arguments, * it accepts a single [[scala.Tuple9]] argument. * * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9)) == f(Tuple9(x1, x2, x3, x4, x5, x6, x7, x8, x9)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)` */ - def tupled: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] => R = { + + @annotation.unspecialized def tupled: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] => R = { case Tuple9(x1, x2, x3, x4, x5, x6, x7, x8, x9) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9) } override def toString() = "<function9>" diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index 15e007528b..9eb1e6a11b 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -100,39 +100,36 @@ object Predef extends LowPriorityImplicits { // def AnyRef = scala.AnyRef // Manifest types, companions, and incantations for summoning - @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0") type ClassManifest[T] = scala.reflect.ClassManifest[T] - @deprecated("OptManifest is no longer supported and using it may lead to incorrect results, use `@scala.reflect.TypeTag` instead", "2.10.0") type OptManifest[T] = scala.reflect.OptManifest[T] - @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0") type Manifest[T] = scala.reflect.Manifest[T] - @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0") val ClassManifest = scala.reflect.ClassManifest - // [Paul to Eugene] No lazy vals in Predef. Too expensive. Have to work harder on breaking initialization dependencies. - @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0") - lazy val Manifest = scala.reflect.Manifest // needs to be lazy, because requires scala.reflect.mirror instance - @deprecated("NoManifest is no longer supported and using it may lead to incorrect results, use `@scala.reflect.TypeTag` instead", "2.10.0") - lazy val NoManifest = scala.reflect.NoManifest // needs to be lazy, because requires scala.reflect.mirror instance + val Manifest = scala.reflect.Manifest + val NoManifest = scala.reflect.NoManifest def manifest[T](implicit m: Manifest[T]) = m def classManifest[T](implicit m: ClassManifest[T]) = m def optManifest[T](implicit m: OptManifest[T]) = m // Tag types and companions, and incantations for summoning - type ClassTag[T] = scala.reflect.ClassTag[T] - type TypeTag[T] = scala.reflect.TypeTag[T] - type ConcreteTypeTag[T] = scala.reflect.ConcreteTypeTag[T] - val ClassTag = scala.reflect.ClassTag // doesn't need to be lazy, because it's not a path-dependent type + type ArrayTag[T] = scala.reflect.ArrayTag[T] + type ErasureTag[T] = scala.reflect.ErasureTag[T] + type ClassTag[T] = scala.reflect.ClassTag[T] + type TypeTag[T] = scala.reflect.TypeTag[T] + type ConcreteTypeTag[T] = scala.reflect.ConcreteTypeTag[T] + val ClassTag = scala.reflect.ClassTag // doesn't need to be lazy, because it's not a path-dependent type // [Paul to Eugene] No lazy vals in Predef. Too expensive. Have to work harder on breaking initialization dependencies. - lazy val TypeTag = scala.reflect.TypeTag // needs to be lazy, because requires scala.reflect.mirror instance - lazy val ConcreteTypeTag = scala.reflect.ConcreteTypeTag + lazy val TypeTag = scala.reflect.TypeTag // needs to be lazy, because requires scala.reflect.mirror instance + lazy val ConcreteTypeTag = scala.reflect.ConcreteTypeTag // [Eugene to Martin] it's really tedious to type "implicitly[...]" all the time, so I'm reintroducing these shortcuts - def classTag[T](implicit ctag: ClassTag[T]) = ctag - def tag[T](implicit ttag: TypeTag[T]) = ttag - def typeTag[T](implicit ttag: TypeTag[T]) = ttag - def concreteTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag - def concreteTypeTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag + def arrayTag[T](implicit atag: ArrayTag[T]) = atag + def erasureTag[T](implicit etag: ErasureTag[T]) = etag + def classTag[T](implicit ctag: ClassTag[T]) = ctag + def tag[T](implicit ttag: TypeTag[T]) = ttag + def typeTag[T](implicit ttag: TypeTag[T]) = ttag + def concreteTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag + def concreteTypeTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag // Minor variations on identity functions def identity[A](x: A): A = x // @see `conforms` for the implicit version @@ -310,42 +307,36 @@ object Predef extends LowPriorityImplicits { // views -------------------------------------------------------------- - implicit def exceptionWrapper(exc: Throwable) = new runtime.RichException(exc) - - implicit def zipped2ToTraversable[El1, El2](zz: Tuple2[_, _]#Zipped[_, El1, _, El2]): Traversable[(El1, El2)] = - new collection.AbstractTraversable[(El1, El2)] { - def foreach[U](f: ((El1, El2)) => U): Unit = zz foreach Function.untupled(f) - } - - implicit def zipped3ToTraversable[El1, El2, El3](zz: Tuple3[_, _, _]#Zipped[_, El1, _, El2, _, El3]): Traversable[(El1, El2, El3)] = - new collection.AbstractTraversable[(El1, El2, El3)] { - def foreach[U](f: ((El1, El2, El3)) => U): Unit = zz foreach Function.untupled(f) - } - - implicit def genericArrayOps[T](xs: Array[T]): ArrayOps[T] = xs match { - case x: Array[AnyRef] => refArrayOps[AnyRef](x).asInstanceOf[ArrayOps[T]] - case x: Array[Int] => intArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Double] => doubleArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Long] => longArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Float] => floatArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Char] => charArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Byte] => byteArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Short] => shortArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Boolean] => booleanArrayOps(x).asInstanceOf[ArrayOps[T]] - case x: Array[Unit] => unitArrayOps(x).asInstanceOf[ArrayOps[T]] + implicit def exceptionWrapper(exc: Throwable) = new runtime.RichException(exc) + implicit def tuple2ToZippedOps[T1, T2](x: (T1, T2)) = new runtime.Tuple2Zipped.Ops(x) + implicit def tuple3ToZippedOps[T1, T2, T3](x: (T1, T2, T3)) = new runtime.Tuple3Zipped.Ops(x) + implicit def seqToCharSequence(xs: collection.IndexedSeq[Char]): CharSequence = new runtime.SeqCharSequence(xs) + implicit def arrayToCharSequence(xs: Array[Char]): CharSequence = new runtime.ArrayCharSequence(xs) + + implicit def genericArrayOps[T](xs: Array[T]): ArrayOps[T] = (xs match { + case x: Array[AnyRef] => refArrayOps[AnyRef](x) + case x: Array[Boolean] => booleanArrayOps(x) + case x: Array[Byte] => byteArrayOps(x) + case x: Array[Char] => charArrayOps(x) + case x: Array[Double] => doubleArrayOps(x) + case x: Array[Float] => floatArrayOps(x) + case x: Array[Int] => intArrayOps(x) + case x: Array[Long] => longArrayOps(x) + case x: Array[Short] => shortArrayOps(x) + case x: Array[Unit] => unitArrayOps(x) case null => null - } + }).asInstanceOf[ArrayOps[T]] - implicit def refArrayOps[T <: AnyRef](xs: Array[T]): ArrayOps[T] = new ArrayOps.ofRef[T](xs) - implicit def intArrayOps(xs: Array[Int]): ArrayOps[Int] = new ArrayOps.ofInt(xs) - implicit def doubleArrayOps(xs: Array[Double]): ArrayOps[Double] = new ArrayOps.ofDouble(xs) - implicit def longArrayOps(xs: Array[Long]): ArrayOps[Long] = new ArrayOps.ofLong(xs) - implicit def floatArrayOps(xs: Array[Float]): ArrayOps[Float] = new ArrayOps.ofFloat(xs) - implicit def charArrayOps(xs: Array[Char]): ArrayOps[Char] = new ArrayOps.ofChar(xs) - implicit def byteArrayOps(xs: Array[Byte]): ArrayOps[Byte] = new ArrayOps.ofByte(xs) - implicit def shortArrayOps(xs: Array[Short]): ArrayOps[Short] = new ArrayOps.ofShort(xs) implicit def booleanArrayOps(xs: Array[Boolean]): ArrayOps[Boolean] = new ArrayOps.ofBoolean(xs) - implicit def unitArrayOps(xs: Array[Unit]): ArrayOps[Unit] = new ArrayOps.ofUnit(xs) + implicit def byteArrayOps(xs: Array[Byte]): ArrayOps[Byte] = new ArrayOps.ofByte(xs) + implicit def charArrayOps(xs: Array[Char]): ArrayOps[Char] = new ArrayOps.ofChar(xs) + implicit def doubleArrayOps(xs: Array[Double]): ArrayOps[Double] = new ArrayOps.ofDouble(xs) + implicit def floatArrayOps(xs: Array[Float]): ArrayOps[Float] = new ArrayOps.ofFloat(xs) + implicit def intArrayOps(xs: Array[Int]): ArrayOps[Int] = new ArrayOps.ofInt(xs) + implicit def longArrayOps(xs: Array[Long]): ArrayOps[Long] = new ArrayOps.ofLong(xs) + implicit def refArrayOps[T <: AnyRef](xs: Array[T]): ArrayOps[T] = new ArrayOps.ofRef[T](xs) + implicit def shortArrayOps(xs: Array[Short]): ArrayOps[Short] = new ArrayOps.ofShort(xs) + implicit def unitArrayOps(xs: Array[Unit]): ArrayOps[Unit] = new ArrayOps.ofUnit(xs) // Primitive Widenings -------------------------------------------------------------- @@ -409,29 +400,17 @@ object Predef extends LowPriorityImplicits { // Strings and CharSequences -------------------------------------------------------------- - implicit def any2stringadd(x: Any) = new runtime.StringAdd(x) @inline implicit def any2stringfmt(x: Any) = new runtime.StringFormat(x) @inline implicit def augmentString(x: String): StringOps = new StringOps(x) + implicit def any2stringadd(x: Any) = new runtime.StringAdd(x) implicit def unaugmentString(x: StringOps): String = x.repr - implicit def stringCanBuildFrom: CanBuildFrom[String, Char, String] = - new CanBuildFrom[String, Char, String] { - def apply(from: String) = apply() - def apply() = mutable.StringBuilder.newBuilder - } - - implicit def seqToCharSequence(xs: collection.IndexedSeq[Char]): CharSequence = new CharSequence { - def length: Int = xs.length - def charAt(index: Int): Char = xs(index) - def subSequence(start: Int, end: Int): CharSequence = seqToCharSequence(xs.slice(start, end)) - override def toString: String = xs.mkString("") - } + @deprecated("Use StringCanBuildFrom", "2.10.0") + def stringCanBuildFrom: CanBuildFrom[String, Char, String] = StringCanBuildFrom - implicit def arrayToCharSequence(xs: Array[Char]): CharSequence = new CharSequence { - def length: Int = xs.length - def charAt(index: Int): Char = xs(index) - def subSequence(start: Int, end: Int): CharSequence = arrayToCharSequence(xs.slice(start, end)) - override def toString: String = xs.mkString("") + implicit val StringCanBuildFrom: CanBuildFrom[String, Char, String] = new CanBuildFrom[String, Char, String] { + def apply(from: String) = apply() + def apply() = mutable.StringBuilder.newBuilder } // Type Constraints -------------------------------------------------------------- @@ -471,13 +450,6 @@ object Predef extends LowPriorityImplicits { implicit def tpEquals[A]: A =:= A = singleton_=:=.asInstanceOf[A =:= A] } - // less useful due to #2781 - @deprecated("Use From => To instead", "2.9.0") - sealed abstract class <%<[-From, +To] extends (From => To) with Serializable - object <%< { - implicit def conformsOrViewsAs[A <% B, B]: A <%< B = new (A <%< B) {def apply(x: A) = x} - } - /** A type for which there is always an implicit value. * @see fallbackCanBuildFrom in Array.scala */ diff --git a/src/library/scala/Product1.scala b/src/library/scala/Product1.scala index d268b35f60..edd095c5c6 100644 --- a/src/library/scala/Product1.scala +++ b/src/library/scala/Product1.scala @@ -28,7 +28,7 @@ trait Product1[@specialized(Int, Long, Double) +T1] extends Any with Product { * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product10.scala b/src/library/scala/Product10.scala index cae9e5a664..8daefde699 100644 --- a/src/library/scala/Product10.scala +++ b/src/library/scala/Product10.scala @@ -28,7 +28,7 @@ trait Product10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Any w * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product11.scala b/src/library/scala/Product11.scala index 0647b28414..90b4e8013e 100644 --- a/src/library/scala/Product11.scala +++ b/src/library/scala/Product11.scala @@ -28,7 +28,7 @@ trait Product11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product12.scala b/src/library/scala/Product12.scala index a080aafa7a..d5997ea05a 100644 --- a/src/library/scala/Product12.scala +++ b/src/library/scala/Product12.scala @@ -28,7 +28,7 @@ trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] e * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product13.scala b/src/library/scala/Product13.scala index 425aebf3e7..db8e0f3722 100644 --- a/src/library/scala/Product13.scala +++ b/src/library/scala/Product13.scala @@ -28,7 +28,7 @@ trait Product13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product14.scala b/src/library/scala/Product14.scala index 3d7e4896ef..113c07e8c4 100644 --- a/src/library/scala/Product14.scala +++ b/src/library/scala/Product14.scala @@ -28,7 +28,7 @@ trait Product14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product15.scala b/src/library/scala/Product15.scala index 7bca7a2a1b..a6ad9c7594 100644 --- a/src/library/scala/Product15.scala +++ b/src/library/scala/Product15.scala @@ -28,7 +28,7 @@ trait Product15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product16.scala b/src/library/scala/Product16.scala index c5042cbc90..cbf47ece94 100644 --- a/src/library/scala/Product16.scala +++ b/src/library/scala/Product16.scala @@ -28,7 +28,7 @@ trait Product16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product17.scala b/src/library/scala/Product17.scala index b5651ec712..f56836bfd8 100644 --- a/src/library/scala/Product17.scala +++ b/src/library/scala/Product17.scala @@ -28,7 +28,7 @@ trait Product17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product18.scala b/src/library/scala/Product18.scala index 088a48ae32..5b86bcff65 100644 --- a/src/library/scala/Product18.scala +++ b/src/library/scala/Product18.scala @@ -28,7 +28,7 @@ trait Product18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product19.scala b/src/library/scala/Product19.scala index 4f4a98c6a0..ed4bf36c93 100644 --- a/src/library/scala/Product19.scala +++ b/src/library/scala/Product19.scala @@ -28,7 +28,7 @@ trait Product19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product2.scala b/src/library/scala/Product2.scala index eb67e5d46e..e27e54eff9 100644 --- a/src/library/scala/Product2.scala +++ b/src/library/scala/Product2.scala @@ -28,7 +28,7 @@ trait Product2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, Doub * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product20.scala b/src/library/scala/Product20.scala index 80f63f1bb4..47437a20af 100644 --- a/src/library/scala/Product20.scala +++ b/src/library/scala/Product20.scala @@ -28,7 +28,7 @@ trait Product20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product21.scala b/src/library/scala/Product21.scala index 7056844271..319d2725c0 100644 --- a/src/library/scala/Product21.scala +++ b/src/library/scala/Product21.scala @@ -28,7 +28,7 @@ trait Product21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product22.scala b/src/library/scala/Product22.scala index 05e95f92dd..6ab3737acd 100644 --- a/src/library/scala/Product22.scala +++ b/src/library/scala/Product22.scala @@ -28,7 +28,7 @@ trait Product22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product3.scala b/src/library/scala/Product3.scala index 91556bb962..1cfbd7956b 100644 --- a/src/library/scala/Product3.scala +++ b/src/library/scala/Product3.scala @@ -28,7 +28,7 @@ trait Product3[+T1, +T2, +T3] extends Any with Product { * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product4.scala b/src/library/scala/Product4.scala index 1f9070c155..843571fd60 100644 --- a/src/library/scala/Product4.scala +++ b/src/library/scala/Product4.scala @@ -28,7 +28,7 @@ trait Product4[+T1, +T2, +T3, +T4] extends Any with Product { * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product5.scala b/src/library/scala/Product5.scala index 52dd284f55..df73bba3dd 100644 --- a/src/library/scala/Product5.scala +++ b/src/library/scala/Product5.scala @@ -28,7 +28,7 @@ trait Product5[+T1, +T2, +T3, +T4, +T5] extends Any with Product { * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product6.scala b/src/library/scala/Product6.scala index 9624bdbe3e..36906ca54e 100644 --- a/src/library/scala/Product6.scala +++ b/src/library/scala/Product6.scala @@ -28,7 +28,7 @@ trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Any with Product { * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product7.scala b/src/library/scala/Product7.scala index 36d4b149db..e7b2c13ad1 100644 --- a/src/library/scala/Product7.scala +++ b/src/library/scala/Product7.scala @@ -28,7 +28,7 @@ trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Any with Product { * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product8.scala b/src/library/scala/Product8.scala index 28c78f9c89..916e57ec39 100644 --- a/src/library/scala/Product8.scala +++ b/src/library/scala/Product8.scala @@ -28,7 +28,7 @@ trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Any with Product * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/library/scala/Product9.scala b/src/library/scala/Product9.scala index d69c550abe..d5e72edc0b 100644 --- a/src/library/scala/Product9.scala +++ b/src/library/scala/Product9.scala @@ -28,7 +28,7 @@ trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Any with Pro * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. + * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. * @throws IndexOutOfBoundsException */ diff --git a/src/dbc/scala/dbc/statement/Statement.scala b/src/library/scala/ScalaObject.scala index fc5374262d..7cd64becbe 100644 --- a/src/dbc/scala/dbc/statement/Statement.scala +++ b/src/library/scala/ScalaObject.scala @@ -6,11 +6,11 @@ ** |/ ** \* */ +package scala - -package scala.dbc -package statement - - -/** An ISO-9075:2003 (SQL) statement. */ -@deprecated(DbcIsDeprecated, "2.9.0") abstract class Statement +/** Until scala 2.10.0 this marker trait was added to + * scala-compiled classes. Now it only exists for backward + * compatibility. + */ +@deprecated("ScalaObject will be removed", "2.10.0") +trait ScalaObject diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala index 37ab564c3c..5e77127080 100644 --- a/src/library/scala/Tuple2.scala +++ b/src/library/scala/Tuple2.scala @@ -9,9 +9,6 @@ package scala -import scala.collection.{ TraversableLike => TLike, IterableLike => ILike } -import scala.collection.generic.{ CanBuildFrom => CBF } - /** A tuple of 2 elements; the canonical representation of a [[scala.Product2]]. * @@ -23,122 +20,11 @@ case class Tuple2[@specialized(Int, Long, Double, Char, Boolean, AnyRef) +T1, @s extends Product2[T1, T2] { override def toString() = "(" + _1 + "," + _2 + ")" - + /** Swaps the elements of this `Tuple`. * @return a new Tuple where the first element is the second element of this Tuple and the * second element is the first element of this Tuple. */ def swap: Tuple2[T2,T1] = Tuple2(_2, _1) - @deprecated("Use `zipped` instead.", "2.9.0") - def zip[Repr1, El1, El2, To](implicit w1: T1 => TLike[El1, Repr1], - w2: T2 => Iterable[El2], - cbf1: CBF[Repr1, (El1, El2), To]): To = { - zipped map ((x, y) => ((x, y))) - } - - /** Wraps a tuple in a `Zipped`, which supports 2-ary generalisations of `map`, `flatMap`, `filter`, etc. - * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]] - * or [[scala.collection.IterableLike]]. - * {{{ - * scala> val tuple = (List(1,2,3),List('a','b','c')) - * tuple: (List[Int], List[Char]) = (List(1, 2, 3),List(a, b, c)) - * - * scala> tuple.zipped map { (x,y) => x + ":" + y } - * res6: List[java.lang.String] = List(1:a, 2:b, 3:c) - * }}} - * - * @see Zipped - * Note: will not terminate for infinite-sized collections. - */ - def zipped[Repr1, El1, Repr2, El2](implicit w1: T1 => TLike[El1, Repr1], w2: T2 => ILike[El2, Repr2]): Zipped[Repr1, El1, Repr2, El2] - = new Zipped[Repr1, El1, Repr2, El2](_1, _2) - - /** - * @define coll zipped - * @define Coll Zipped - * @define orderDependent - * @define orderDependentFold - * @define mayNotTerminateInf - * @define willNotTerminateInf - * @define collectExample - * @define undefinedorder - */ - class Zipped[+Repr1, +El1, +Repr2, +El2](coll1: TLike[El1, Repr1], coll2: ILike[El2, Repr2]) { // coll2: ILike for filter - def map[B, To](f: (El1, El2) => B)(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - b.sizeHint(coll1) - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) - b += f(el1, elems2.next) - else - return b.result - } - - b.result - } - - def flatMap[B, To](f: (El1, El2) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) - b ++= f(el1, elems2.next) - else - return b.result - } - - b.result - } - - def filter[To1, To2](f: (El1, El2) => Boolean)(implicit cbf1: CBF[Repr1, El1, To1], cbf2: CBF[Repr2, El2, To2]): (To1, To2) = { - val b1 = cbf1(coll1.repr) - val b2 = cbf2(coll2.repr) - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) { - val el2 = elems2.next - if (f(el1, el2)) { - b1 += el1 - b2 += el2 - } - } - else return (b1.result, b2.result) - } - - (b1.result, b2.result) - } - - def exists(f: (El1, El2) => Boolean): Boolean = { - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) { - if (f(el1, elems2.next)) - return true - } - else return false - } - false - } - - def forall(f: (El1, El2) => Boolean): Boolean = - !exists((x, y) => !f(x, y)) - - def foreach[U](f: (El1, El2) => U): Unit = { - val elems2 = coll2.iterator - - for (el1 <- coll1) { - if (elems2.hasNext) - f(el1, elems2.next) - else - return - } - } - } - } diff --git a/src/library/scala/Tuple3.scala b/src/library/scala/Tuple3.scala index cd5ee23757..5ed13602e3 100644 --- a/src/library/scala/Tuple3.scala +++ b/src/library/scala/Tuple3.scala @@ -9,9 +9,6 @@ package scala -import scala.collection.{ TraversableLike => TLike, IterableLike => ILike } -import scala.collection.generic.{ CanBuildFrom => CBF } - /** A tuple of 3 elements; the canonical representation of a [[scala.Product3]]. * @@ -24,133 +21,5 @@ case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3) extends Product3[T1, T2, T3] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + ")" - - - @deprecated("Use `zipped` instead.", "2.9.0") - def zip[Repr1, El1, El2, El3, To](implicit w1: T1 => TLike[El1, Repr1], - w2: T2 => Iterable[El2], - w3: T3 => Iterable[El3], - cbf1: CBF[Repr1, (El1, El2, El3), To]): To = { - zipped map ((x, y, z) => ((x, y, z))) - } - - /** Wraps a tuple in a `Zipped`, which supports 3-ary generalisations of `map`, `flatMap`, `filter`, etc. - * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]] - * or [[scala.collection.IterableLike]]. - * {{{ - * scala> val tuple = (List(1,2,3),List('a','b','c'),List("x","y","z")) - * tuple: (List[Int], List[Char], List[java.lang.String]) = (List(1, 2, 3),List(a, b, c),List(x, y, z)) - * - * scala> tuple.zipped map { (x,y,z) => x + ":" + y + ":" + z} - * res8: List[java.lang.String] = List(1:a:x, 2:b:y, 3:c:z) - * }}} - * - * @see Zipped - * Note: will not terminate for infinite-sized collections. - */ - def zipped[Repr1, El1, Repr2, El2, Repr3, El3](implicit w1: T1 => TLike[El1, Repr1], - w2: T2 => ILike[El2, Repr2], - w3: T3 => ILike[El3, Repr3]): Zipped[Repr1, El1, Repr2, El2, Repr3, El3] - = new Zipped[Repr1, El1, Repr2, El2, Repr3, El3](_1, _2, _3) - - /** - * @define coll zipped - * @define Coll Zipped - * @define orderDependent - * @define orderDependentFold - * @define mayNotTerminateInf - * @define willNotTerminateInf - * @define collectExample - * @define undefinedorder - * @define thatInfo The class of the returned collection. - */ - class Zipped[+Repr1, +El1, +Repr2, +El2, +Repr3, +El3](coll1: TLike[El1, Repr1], - coll2: ILike[El2, Repr2], - coll3: ILike[El3, Repr3]) { - def map[B, To](f: (El1, El2, El3) => B)(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) - b += f(el1, elems2.next, elems3.next) - else - return b.result - } - b.result - } - - def flatMap[B, To](f: (El1, El2, El3) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = { - val b = cbf(coll1.repr) - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) - b ++= f(el1, elems2.next, elems3.next) - else - return b.result - } - b.result - } - - def filter[To1, To2, To3](f: (El1, El2, El3) => Boolean)( - implicit cbf1: CBF[Repr1, El1, To1], - cbf2: CBF[Repr2, El2, To2], - cbf3: CBF[Repr3, El3, To3]): (To1, To2, To3) = { - val b1 = cbf1(coll1.repr) - val b2 = cbf2(coll2.repr) - val b3 = cbf3(coll3.repr) - val elems2 = coll2.iterator - val elems3 = coll3.iterator - def result = (b1.result, b2.result, b3.result) - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) { - val el2 = elems2.next - val el3 = elems3.next - - if (f(el1, el2, el3)) { - b1 += el1 - b2 += el2 - b3 += el3 - } - } - else return result - } - - result - } - - def exists(f: (El1, El2, El3) => Boolean): Boolean = { - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) { - if (f(el1, elems2.next, elems3.next)) - return true - } - else return false - } - false - } - - def forall(f: (El1, El2, El3) => Boolean): Boolean = - !exists((x, y, z) => !f(x, y, z)) - - def foreach[U](f: (El1, El2, El3) => U): Unit = { - val elems2 = coll2.iterator - val elems3 = coll3.iterator - - for (el1 <- coll1) { - if (elems2.hasNext && elems3.hasNext) - f(el1, elems2.next, elems3.next) - else - return - } - } - } - + } diff --git a/src/library/scala/annotation/bridge.scala b/src/library/scala/annotation/bridge.scala index 690370854e..a56129fb96 100644 --- a/src/library/scala/annotation/bridge.scala +++ b/src/library/scala/annotation/bridge.scala @@ -10,4 +10,5 @@ package scala.annotation /** If this annotation is present on a method, it will be treated as a bridge method. */ +@deprecated("Reconsider whether using this annotation will accomplish anything", "2.10.0") private[scala] class bridge extends annotation.StaticAnnotation diff --git a/src/dbc/scala/dbc/statement/AccessMode.scala b/src/library/scala/annotation/unspecialized.scala index 885e0012f2..28d9aa169c 100644 --- a/src/dbc/scala/dbc/statement/AccessMode.scala +++ b/src/library/scala/annotation/unspecialized.scala @@ -1,26 +1,17 @@ /* __ *\ ** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** +** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ +package scala.annotation - -package scala.dbc -package statement - - -@deprecated(DbcIsDeprecated, "2.9.0") abstract class AccessMode { - def sqlString: String -} - -@deprecated(DbcIsDeprecated, "2.9.0") object AccessMode { - case object ReadOnly extends AccessMode { - def sqlString = "READ ONLY" - } - case object ReadWrite extends AccessMode { - def sqlString = "READ WRITE" - } -} +/** A method annotation which suppresses the creation of + * additional specialized forms based on enclosing specialized + * type parameters. + * + * @since 2.10 + */ +class unspecialized extends annotation.StaticAnnotation diff --git a/src/library/scala/collection/GenSeqLike.scala b/src/library/scala/collection/GenSeqLike.scala index 71316cefc9..fd7892c9f9 100644 --- a/src/library/scala/collection/GenSeqLike.scala +++ b/src/library/scala/collection/GenSeqLike.scala @@ -9,7 +9,6 @@ package scala.collection import generic._ -import annotation.bridge /** A template trait for all sequences which may be traversed * in parallel. @@ -228,9 +227,6 @@ trait GenSeqLike[+A, +Repr] extends Any with GenIterableLike[A, Repr] with Equal */ def startsWith[B](that: GenSeq[B]): Boolean = startsWith(that, 0) - @bridge - def startsWith[B](that: Seq[B]): Boolean = startsWith(that: GenSeq[B]) - /** Tests whether this $coll contains the given sequence at a given index. * * '''Note''': If the both the receiver object `this` and the argument @@ -413,10 +409,6 @@ trait GenSeqLike[+A, +Repr] extends Any with GenIterableLike[A, Repr] with Equal */ def union[B >: A, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = this ++ that - @bridge - def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = - union(that: GenSeq[B])(bf) - /** Computes the multiset difference between this $coll and another sequence. * * @param that the sequence of elements to remove diff --git a/src/library/scala/collection/GenSetLike.scala b/src/library/scala/collection/GenSetLike.scala index f729f82bb4..219374abc6 100644 --- a/src/library/scala/collection/GenSetLike.scala +++ b/src/library/scala/collection/GenSetLike.scala @@ -8,7 +8,6 @@ package scala.collection -import annotation.bridge /** A template trait for sets which may possibly * have their operations implemented in parallel. @@ -51,9 +50,6 @@ extends GenIterableLike[A, Repr] */ def intersect(that: GenSet[A]): Repr = this filter that - @bridge - def intersect(that: Set[A]): Repr = intersect(that: GenSet[A]) - /** Computes the intersection between this set and another set. * * '''Note:''' Same as `intersect`. @@ -63,9 +59,6 @@ extends GenIterableLike[A, Repr] */ def &(that: GenSet[A]): Repr = this intersect that - @bridge - def &(that: Set[A]): Repr = &(that: GenSet[A]) - /** Computes the union between of set and another set. * * @param that the set to form the union with. @@ -83,9 +76,6 @@ extends GenIterableLike[A, Repr] */ def | (that: GenSet[A]): Repr = this union that - @bridge - def | (that: Set[A]): Repr = | (that: GenSet[A]) - /** Computes the difference of this set and another set. * * @param that the set of elements to exclude. @@ -103,9 +93,6 @@ extends GenIterableLike[A, Repr] */ def &~(that: GenSet[A]): Repr = this diff that - @bridge - def &~(that: Set[A]): Repr = &~(that: GenSet[A]) - /** Tests whether this set is a subset of another set. * * @param that the set to test. @@ -114,9 +101,6 @@ extends GenIterableLike[A, Repr] */ def subsetOf(that: GenSet[A]): Boolean = this forall that - @bridge - def subsetOf(that: Set[A]): Boolean = subsetOf(that: GenSet[A]) - /** Compares this set with another object for equality. * * '''Note:''' This operation contains an unchecked cast: if `that` diff --git a/src/library/scala/collection/GenTraversableLike.scala b/src/library/scala/collection/GenTraversableLike.scala index fd03e0f446..4500a849b1 100644 --- a/src/library/scala/collection/GenTraversableLike.scala +++ b/src/library/scala/collection/GenTraversableLike.scala @@ -91,7 +91,7 @@ trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] with */ def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That - /** Produces a collection containing cummulative results of applying the + /** Produces a collection containing cumulative results of applying the * operator going left to right. * * $willNotTerminateInf @@ -106,8 +106,8 @@ trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] with */ def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That - /** Produces a collection containing cummulative results of applying the operator going right to left. - * The head of the collection is the last cummulative result. + /** Produces a collection containing cumulative results of applying the operator going right to left. + * The head of the collection is the last cumulative result. * $willNotTerminateInf * $orderDependent * diff --git a/src/library/scala/collection/GenTraversableOnce.scala b/src/library/scala/collection/GenTraversableOnce.scala index a7ec7618b7..fd8595ccb8 100644 --- a/src/library/scala/collection/GenTraversableOnce.scala +++ b/src/library/scala/collection/GenTraversableOnce.scala @@ -459,7 +459,7 @@ trait GenTraversableOnce[+A] extends Any { /** Converts this $coll to an array. * - * @tparam B the type of the elements of the array. A `ClassManifest` for + * @tparam B the type of the elements of the array. An `ArrayTag` for * this type must be available. * @return an array containing all elements of this $coll. * @@ -469,9 +469,9 @@ trait GenTraversableOnce[+A] extends Any { * $willNotTerminateInf * * @return an array containing all elements of this $coll. - * A `ClassManifest` must be available for the element type of this $coll. + * An `ArrayTag` must be available for the element type of this $coll. */ - def toArray[A1 >: A: ClassManifest]: Array[A1] + def toArray[A1 >: A: ArrayTag]: Array[A1] /** Converts this $coll to a list. * $willNotTerminateInf diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala index 3c4ad0612a..f4397f2167 100644 --- a/src/library/scala/collection/IterableLike.scala +++ b/src/library/scala/collection/IterableLike.scala @@ -12,7 +12,6 @@ package scala.collection import generic._ import immutable.{ List, Stream } import annotation.unchecked.uncheckedVariance -import annotation.bridge /** A template trait for iterable collections of type `Iterable[A]`. * $iterableInfo @@ -239,10 +238,6 @@ self => b.result } - @bridge - def zip[A1 >: A, B, That](that: Iterable[B])(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = - zip(that: GenIterable[B])(bf) - def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = { val b = bf(repr) val these = this.iterator @@ -256,10 +251,6 @@ self => b.result } - @bridge - def zipAll[B, A1 >: A, That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = - zipAll(that: GenIterable[B], thisElem, thatElem)(bf) - def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[Repr, (A1, Int), That]): That = { val b = bf(repr) var i = 0 @@ -280,9 +271,6 @@ self => !these.hasNext && !those.hasNext } - @bridge - def sameElements[B >: A](that: Iterable[B]): Boolean = sameElements(that: GenIterable[B]) - override /*TraversableLike*/ def toStream: Stream[A] = iterator.toStream /** Method called from equality methods, so that user-defined subclasses can diff --git a/src/library/scala/collection/MapLike.scala b/src/library/scala/collection/MapLike.scala index 8f88e62791..034c1a0c0c 100644 --- a/src/library/scala/collection/MapLike.scala +++ b/src/library/scala/collection/MapLike.scala @@ -297,9 +297,6 @@ self => def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): Map[A, B1] = ((repr: Map[A, B1]) /: xs.seq) (_ + _) - @bridge - def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): Map[A, B1] = ++(xs: GenTraversableOnce[(A, B1)]) - /** Returns a new map with all key/value pairs for which the predicate * `p` returns `true`. * diff --git a/src/library/scala/collection/SeqExtractors.scala b/src/library/scala/collection/SeqExtractors.scala index cb3cb27f18..de9ff93521 100644 --- a/src/library/scala/collection/SeqExtractors.scala +++ b/src/library/scala/collection/SeqExtractors.scala @@ -11,11 +11,13 @@ object +: { /** An extractor used to init/last deconstruct sequences. */ object :+ { /** Splits a sequence into init :+ tail. - * @returns Some(init, tail) if sequence is non-empty. - * None otherwise. + * @return Some(init, tail) if sequence is non-empty. None otherwise. */ def unapply[T,Coll <: SeqLike[T, Coll]]( t: Coll with SeqLike[T, Coll]): Option[(Coll, T)] = if(t.isEmpty) None else Some(t.init -> t.last) } + +// Dummy to fool ant +private abstract class SeqExtractors
\ No newline at end of file diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala index ced99e897f..a9535adc23 100644 --- a/src/library/scala/collection/SeqLike.scala +++ b/src/library/scala/collection/SeqLike.scala @@ -12,7 +12,6 @@ import mutable.{ ListBuffer, ArraySeq } import immutable.{ List, Range } import generic._ import parallel.ParSeq -import annotation.bridge import scala.math.Ordering /** A template trait for sequences of type `Seq[A]` @@ -296,9 +295,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ !j.hasNext } - @bridge - def startsWith[B](that: Seq[B], offset: Int): Boolean = startsWith(that: GenSeq[B], offset) - def endsWith[B](that: GenSeq[B]): Boolean = { val i = this.iterator.drop(length - that.length) val j = that.iterator @@ -309,10 +305,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ !j.hasNext } - @bridge - def endsWith[B](that: Seq[B]): Boolean = endsWith(that: GenSeq[B]) - - /** Finds first index where this $coll contains a given sequence as a slice. * $mayNotTerminateInf * @param that the sequence to test @@ -321,9 +313,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ */ def indexOfSlice[B >: A](that: GenSeq[B]): Int = indexOfSlice(that, 0) - @bridge - def indexOfSlice[B >: A](that: Seq[B]): Int = indexOfSlice(that: GenSeq[B]) - /** Finds first index after or at a start index where this $coll contains a given sequence as a slice. * $mayNotTerminateInf * @param that the sequence to test @@ -354,9 +343,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ -1 } - @bridge - def indexOfSlice[B >: A](that: Seq[B], from: Int): Int = indexOfSlice(that: GenSeq[B], from) - /** Finds last index where this $coll contains a given sequence as a slice. * $willNotTerminateInf * @param that the sequence to test @@ -365,9 +351,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ */ def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int = lastIndexOfSlice(that, length) - @bridge - def lastIndexOfSlice[B >: A](that: Seq[B]): Int = lastIndexOfSlice(that: GenSeq[B]) - /** Finds last index before or at a given end index where this $coll contains a given sequence as a slice. * @param that the sequence to test * @param end the end index @@ -385,9 +368,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ else SeqLike.kmpSearch(thisCollection, 0, clippedL+tl, that.seq, 0, tl, false) } - @bridge - def lastIndexOfSlice[B >: A](that: Seq[B], end: Int): Int = lastIndexOfSlice(that: GenSeq[B], end) - /** Tests whether this $coll contains a given sequence as a slice. * $mayNotTerminateInf * @param that the sequence to test @@ -396,9 +376,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ */ def containsSlice[B](that: GenSeq[B]): Boolean = indexOfSlice(that) != -1 - @bridge - def containsSlice[B](that: Seq[B]): Boolean = containsSlice(that: GenSeq[B]) - /** Tests whether this $coll contains a given value as an element. * $mayNotTerminateInf * @@ -463,9 +440,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ b.result } - @bridge - def diff[B >: A](that: Seq[B]): Repr = diff(that: GenSeq[B]) - /** Computes the multiset intersection between this $coll and another sequence. * * @param that the sequence of elements to intersect with. @@ -499,9 +473,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ b.result } - @bridge - def intersect[B >: A](that: Seq[B]): Repr = intersect(that: GenSeq[B]) - private def occCounts[B](sq: Seq[B]): mutable.Map[B, Int] = { val occ = new mutable.HashMap[B, Int] { override def default(k: B) = 0 } for (y <- sq.seq) occ(y) += 1 @@ -534,10 +505,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ b.result } - @bridge - def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[Repr, B, That]): That = - this.patch(from, patch: GenSeq[B], replaced)(bf) - def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { val b = bf(repr) val (prefix, rest) = this.splitAt(index) @@ -583,10 +550,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[ !i.hasNext && !j.hasNext } - @bridge - def corresponds[B](that: Seq[B])(p: (A,B) => Boolean): Boolean = - corresponds(that: GenSeq[B])(p) - /** Sorts this $coll according to a comparison function. * $willNotTerminateInf * diff --git a/src/library/scala/collection/SeqViewLike.scala b/src/library/scala/collection/SeqViewLike.scala index a32cad08e5..f64045c9f6 100644 --- a/src/library/scala/collection/SeqViewLike.scala +++ b/src/library/scala/collection/SeqViewLike.scala @@ -11,7 +11,6 @@ package scala.collection import generic._ import Seq.fill import TraversableView.NoBuilder -import annotation.bridge /** A template trait for non-strict views of sequences. * $seqViewInfo @@ -132,13 +131,9 @@ trait SeqViewLike[+A, override def diff[B >: A](that: GenSeq[B]): This = newForced(thisSeq diff that).asInstanceOf[This] - @bridge def diff[B >: A](that: Seq[B]): This = diff(that: GenSeq[B]) - override def intersect[B >: A](that: GenSeq[B]): This = newForced(thisSeq intersect that).asInstanceOf[This] - @bridge def intersect[B >: A](that: Seq[B]): This = intersect(that: GenSeq[B]) - override def sorted[B >: A](implicit ord: Ordering[B]): This = newForced(thisSeq sorted ord).asInstanceOf[This] diff --git a/src/library/scala/collection/SetLike.scala b/src/library/scala/collection/SetLike.scala index 7293f3775c..04ec4af830 100644 --- a/src/library/scala/collection/SetLike.scala +++ b/src/library/scala/collection/SetLike.scala @@ -127,9 +127,6 @@ self => */ def ++ (elems: GenTraversableOnce[A]): This = (repr /: elems.seq)(_ + _) - @bridge - def ++ (elems: TraversableOnce[A]): This = ++ (elems: GenTraversableOnce[A]) - /** Creates a new set with a given element removed from this set. * * @param elem the element to be removed @@ -152,9 +149,6 @@ self => */ def union(that: GenSet[A]): This = this ++ that - @bridge - def union(that: Set[A]): This = union(that: GenSet[A]) - /** Computes the difference of this set and another set. * * @param that the set of elements to exclude. @@ -163,9 +157,6 @@ self => */ def diff(that: GenSet[A]): This = this -- that - @bridge - def diff(that: Set[A]): This = diff(that: GenSet[A]) - /** An iterator over all subsets of this set of the given size. * If the requested size is impossible, an empty iterator is returned. * diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala index 3fba3dfa79..cd85ea4d2d 100644 --- a/src/library/scala/collection/Traversable.scala +++ b/src/library/scala/collection/Traversable.scala @@ -13,7 +13,6 @@ package scala.collection import generic._ import mutable.{Builder, Buffer, ArrayBuffer, ListBuffer} import scala.util.control.Breaks -import annotation.bridge /** A trait for traversable collections. * All operations are guaranteed to be performed in a single-threaded manner. @@ -28,12 +27,6 @@ trait Traversable[+A] extends TraversableLike[A, Traversable[A]] override def seq: Traversable[A] = this - @bridge - def flatten[B](implicit asTraversable: A => /*<:<!!!*/ GenTraversableOnce[B]): Traversable[B] = super.flatten(asTraversable) - - @bridge - def transpose[B](implicit asTraversable: A => /*<:<!!!*/ GenTraversableOnce[B]): Traversable[Traversable[B]] = super.transpose(asTraversable) - /* The following methods are inherited from TraversableLike * override def isEmpty: Boolean @@ -75,7 +68,7 @@ trait Traversable[+A] extends TraversableLike[A, Traversable[A]] override def copyToBuffer[B >: A](dest: Buffer[B]) override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) override def copyToArray[B >: A](xs: Array[B], start: Int) - override def toArray[B >: A : ClassManifest]: Array[B] + override def toArray[B >: A : ArrayTag]: Array[B] override def toList: List[A] override def toIterable: Iterable[A] override def toSeq: Seq[A] diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index a4f36d20c7..3ca4bfeee9 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -155,10 +155,6 @@ trait TraversableLike[+A, +Repr] extends Any b.result } - @bridge - def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = - ++(that: GenTraversableOnce[B])(bf) - /** As with `++`, returns a new collection containing the elements from the left operand followed by the * elements from the right operand. * diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala index e68ef9e4de..5b5cee7f1b 100644 --- a/src/library/scala/collection/TraversableOnce.scala +++ b/src/library/scala/collection/TraversableOnce.scala @@ -229,7 +229,7 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] { def copyToArray[B >: A](xs: Array[B]): Unit = copyToArray(xs, 0, xs.length) - def toArray[B >: A : ClassManifest]: Array[B] = { + def toArray[B >: A : ArrayTag]: Array[B] = { if (isTraversableAgain) { val result = new Array[B](size) copyToArray(result, 0) diff --git a/src/library/scala/collection/TraversableProxyLike.scala b/src/library/scala/collection/TraversableProxyLike.scala index e7e797391e..20880e369d 100644 --- a/src/library/scala/collection/TraversableProxyLike.scala +++ b/src/library/scala/collection/TraversableProxyLike.scala @@ -73,7 +73,7 @@ trait TraversableProxyLike[+A, +Repr <: TraversableLike[A, Repr] with Traversabl override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) = self.copyToArray(xs, start, len) override def copyToArray[B >: A](xs: Array[B], start: Int) = self.copyToArray(xs, start) override def copyToArray[B >: A](xs: Array[B]) = self.copyToArray(xs) - override def toArray[B >: A: ClassManifest]: Array[B] = self.toArray + override def toArray[B >: A: ArrayTag]: Array[B] = self.toArray override def toList: List[A] = self.toList override def toIterable: Iterable[A] = self.toIterable override def toSeq: Seq[A] = self.toSeq diff --git a/src/library/scala/collection/generic/ClassManifestTraversableFactory.scala b/src/library/scala/collection/generic/ArrayTagTraversableFactory.scala index e418ca623f..d9ab17559e 100644 --- a/src/library/scala/collection/generic/ClassManifestTraversableFactory.scala +++ b/src/library/scala/collection/generic/ArrayTagTraversableFactory.scala @@ -11,7 +11,7 @@ package generic import language.higherKinds -/** A template for companion objects of `ClassManifestTraversable` and +/** A template for companion objects of `ClassTagTraversable` and * subclasses thereof. * * @define coll collection @@ -21,11 +21,11 @@ import language.higherKinds * @author Aleksandar Prokopec * @since 2.8 */ -abstract class ClassManifestTraversableFactory[CC[X] <: Traversable[X] with GenericClassManifestTraversableTemplate[X, CC]] - extends GenericClassManifestCompanion[CC] { +abstract class ArrayTagTraversableFactory[CC[X] <: Traversable[X] with GenericArrayTagTraversableTemplate[X, CC]] + extends GenericArrayTagCompanion[CC] { - class GenericCanBuildFrom[A](implicit manif: ClassManifest[A]) extends CanBuildFrom[CC[_], A, CC[A]] { - def apply(from: CC[_]) = from.genericClassManifestBuilder[A] + class GenericCanBuildFrom[A](implicit tag: ArrayTag[A]) extends CanBuildFrom[CC[_], A, CC[A]] { + def apply(from: CC[_]) = from.genericArrayTagBuilder[A] def apply = newBuilder[A] } } diff --git a/src/library/scala/collection/generic/GenSeqFactory.scala b/src/library/scala/collection/generic/GenSeqFactory.scala index 3bd63c08b8..19eeba9b1d 100644 --- a/src/library/scala/collection/generic/GenSeqFactory.scala +++ b/src/library/scala/collection/generic/GenSeqFactory.scala @@ -11,7 +11,6 @@ package scala.collection package generic -import annotation.bridge import language.higherKinds /** A template for companion objects of Seq and subclasses thereof. @@ -19,9 +18,4 @@ import language.higherKinds * @since 2.8 */ abstract class GenSeqFactory[CC[X] <: GenSeq[X] with GenericTraversableTemplate[X, CC]] -extends GenTraversableFactory[CC] { - - @bridge - def unapplySeq[A](x: GenSeq[A]): Some[GenSeq[A]] = Some(x) - -} +extends GenTraversableFactory[CC] diff --git a/src/library/scala/collection/generic/GenericClassManifestCompanion.scala b/src/library/scala/collection/generic/GenericArrayTagCompanion.scala index f357091361..959adbce6d 100644 --- a/src/library/scala/collection/generic/GenericClassManifestCompanion.scala +++ b/src/library/scala/collection/generic/GenericArrayTagCompanion.scala @@ -12,19 +12,19 @@ package generic import mutable.Builder import language.higherKinds -/** This class represents companions of classes which require ClassManifests +/** This class represents companions of classes which require ArrayTags * for their element types. * * @author Aleksandar Prokopec */ -abstract class GenericClassManifestCompanion[+CC[X] <: Traversable[X]] { +abstract class GenericArrayTagCompanion[+CC[X] <: Traversable[X]] { type Coll = CC[_] - def newBuilder[A](implicit ord: ClassManifest[A]): Builder[A, CC[A]] + def newBuilder[A](implicit ord: ArrayTag[A]): Builder[A, CC[A]] - def empty[A: ClassManifest]: CC[A] = newBuilder[A].result + def empty[A: ArrayTag]: CC[A] = newBuilder[A].result - def apply[A](elems: A*)(implicit ord: ClassManifest[A]): CC[A] = { + def apply[A](elems: A*)(implicit ord: ArrayTag[A]): CC[A] = { val b = newBuilder[A] b ++= elems b.result diff --git a/src/library/scala/collection/generic/GenericArrayTagTraversableTemplate.scala b/src/library/scala/collection/generic/GenericArrayTagTraversableTemplate.scala new file mode 100644 index 0000000000..ac84683c59 --- /dev/null +++ b/src/library/scala/collection/generic/GenericArrayTagTraversableTemplate.scala @@ -0,0 +1,30 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2010-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.collection +package generic + +import mutable.Builder +import annotation.unchecked.uncheckedVariance +import language.higherKinds + +/** This trait represents collections classes which require array + * tags for their element types. + * + * @author Aleksandar Prokopec + * @since 2.8 + */ +trait GenericArrayTagTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBuilder[A, CC[A] @uncheckedVariance] { + implicit protected[this] val tag: ArrayTag[A] + def arrayTagCompanion: GenericArrayTagCompanion[CC] + def genericArrayTagBuilder[B](implicit tag: ArrayTag[B]): Builder[B, CC[B]] = arrayTagCompanion.newBuilder[B] + @deprecated("use arrayTagCompanion instead", "2.10.0") + def classManifestCompanion: GenericClassManifestCompanion[CC] = arrayTagCompanion + @deprecated("use genericArrayTagBuilder instead", "2.10.0") + def genericClassManifestBuilder[B](implicit manifest: ClassManifest[B]): Builder[B, CC[B]] = genericArrayTagBuilder[B](manifest) +} diff --git a/src/library/scala/collection/generic/GenericClassManifestTraversableTemplate.scala b/src/library/scala/collection/generic/GenericClassManifestTraversableTemplate.scala deleted file mode 100644 index 1a5db4bab2..0000000000 --- a/src/library/scala/collection/generic/GenericClassManifestTraversableTemplate.scala +++ /dev/null @@ -1,26 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2010-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package generic - -import mutable.Builder -import annotation.unchecked.uncheckedVariance -import language.higherKinds - -/** This trait represents collections classes which require class - * manifests for their element types. - * - * @author Aleksandar Prokopec - * @since 2.8 - */ -trait GenericClassManifestTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBuilder[A, CC[A] @uncheckedVariance] { - implicit protected[this] val manifest: ClassManifest[A] - def classManifestCompanion: GenericClassManifestCompanion[CC] - def genericClassManifestBuilder[B](implicit man: ClassManifest[B]): Builder[B, CC[B]] = classManifestCompanion.newBuilder[B] -} diff --git a/src/library/scala/collection/generic/GenericSeqCompanion.scala b/src/library/scala/collection/generic/GenericSeqCompanion.scala index 4c0c34733c..90063c1ca2 100644 --- a/src/library/scala/collection/generic/GenericSeqCompanion.scala +++ b/src/library/scala/collection/generic/GenericSeqCompanion.scala @@ -10,16 +10,7 @@ package scala.collection package generic -import annotation.bridge import language.higherKinds trait GenericSeqCompanion[CC[X] <: Traversable[X]] - extends GenericCompanion[CC] { - - @bridge - override def empty[A]: CC[A] = super.empty[A] - - @bridge - override def apply[A](elems: A*): CC[A] = super.apply(elems: _*) - -} + extends GenericCompanion[CC]
\ No newline at end of file diff --git a/src/library/scala/collection/generic/GenericTraversableTemplate.scala b/src/library/scala/collection/generic/GenericTraversableTemplate.scala index b26e07393c..69eab43150 100644 --- a/src/library/scala/collection/generic/GenericTraversableTemplate.scala +++ b/src/library/scala/collection/generic/GenericTraversableTemplate.scala @@ -147,11 +147,6 @@ trait GenericTraversableTemplate[+A, +CC[X] <: GenTraversable[X]] extends HasNew b.result } - // cannot have a bridge, because it would have the same signature as the target method after erasure - // @bridge - // def flatten[B](implicit asTraversable: A => /*<:<!!!*/ TraversableOnce[B]): CC[B] = - // flatten[B](asTraversable: A => GenTraversableOnce[B]) - /** Transposes this $coll of traversable collections into * a $coll of ${coll}s. * diff --git a/src/library/scala/collection/generic/MapFactory.scala b/src/library/scala/collection/generic/MapFactory.scala index e502c4067e..ce44ae9bf4 100644 --- a/src/library/scala/collection/generic/MapFactory.scala +++ b/src/library/scala/collection/generic/MapFactory.scala @@ -11,7 +11,6 @@ package generic import mutable.{Builder, MapBuilder} -import annotation.bridge import language.higherKinds /** A template for companion objects of `Map` and subclasses thereof. @@ -36,6 +35,4 @@ abstract class MapFactory[CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]] ex def empty[A, B]: CC[A, B] - @bridge - override def apply[A, B](elems: (A, B)*): CC[A, B] = super.apply(elems: _*) } diff --git a/src/library/scala/collection/generic/SetFactory.scala b/src/library/scala/collection/generic/SetFactory.scala index fb99f83ebb..646e99dd1e 100644 --- a/src/library/scala/collection/generic/SetFactory.scala +++ b/src/library/scala/collection/generic/SetFactory.scala @@ -12,15 +12,7 @@ package scala.collection package generic import mutable.Builder -import annotation.bridge import language.higherKinds abstract class SetFactory[CC[X] <: Set[X] with SetLike[X, CC[X]]] - extends GenSetFactory[CC] with GenericSeqCompanion[CC] { - - @bridge - override def empty[A]: CC[A] = super.empty[A] - - @bridge - override def apply[A](elems: A*): CC[A] = super.apply(elems: _*) -} + extends GenSetFactory[CC] with GenericSeqCompanion[CC]
\ No newline at end of file diff --git a/src/library/scala/collection/generic/Subtractable.scala b/src/library/scala/collection/generic/Subtractable.scala index 1ca9d706f0..cda71c0291 100644 --- a/src/library/scala/collection/generic/Subtractable.scala +++ b/src/library/scala/collection/generic/Subtractable.scala @@ -10,7 +10,6 @@ package scala.collection package generic -import annotation.bridge /** This trait represents collection-like objects that can be reduced * using a '+' operator. It defines variants of `-` and `--` @@ -58,7 +57,4 @@ trait Subtractable[A, +Repr <: Subtractable[A, Repr]] { self => * except one less occurrence of each of the elements of `elems`. */ def --(xs: GenTraversableOnce[A]): Repr = (repr /: xs.seq) (_ - _) - - @bridge - def --(xs: TraversableOnce[A]): Repr = --(xs: GenTraversableOnce[A]) } diff --git a/src/library/scala/collection/generic/TraversableFactory.scala b/src/library/scala/collection/generic/TraversableFactory.scala index 07da1bb5c2..254a6a224f 100644 --- a/src/library/scala/collection/generic/TraversableFactory.scala +++ b/src/library/scala/collection/generic/TraversableFactory.scala @@ -10,7 +10,6 @@ package scala.collection package generic -import annotation.bridge import language.higherKinds /** A template for companion objects of `Traversable` and subclasses thereof. @@ -37,48 +36,5 @@ import language.higherKinds * @see GenericCanBuildFrom */ trait TraversableFactory[CC[X] <: Traversable[X] with GenericTraversableTemplate[X, CC]] - extends GenTraversableFactory[CC] with GenericSeqCompanion[CC] { - - @bridge - override def concat[A](xss: Traversable[A]*): CC[A] = super.concat(xss: _*) - - @bridge - override def fill[A](n: Int)(elem: => A): CC[A] = super.fill(n)(elem) - - @bridge - override def fill[A](n1: Int, n2: Int)(elem: => A): CC[CC[A]] = super.fill(n1, n2)(elem) - - @bridge - override def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]]] = super.fill(n1, n2, n3)(elem) - - @bridge - override def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): CC[CC[CC[CC[A]]]] = super.fill(n1, n2, n3, n4)(elem) - - @bridge - override def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): CC[CC[CC[CC[CC[A]]]]] = super.fill(n1, n2, n3, n4, n5)(elem) - - @bridge - override def tabulate[A](n: Int)(f: Int => A): CC[A] = super.tabulate(n)(f) - - @bridge - override def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): CC[CC[A]] = super.tabulate(n1, n2)(f) - - @bridge - override def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): CC[CC[CC[A]]] = super.tabulate(n1, n2, n3)(f) - - @bridge - override def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): CC[CC[CC[CC[A]]]] = super.tabulate(n1, n2, n3, n4)(f) - - @bridge - override def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): CC[CC[CC[CC[CC[A]]]]] = super.tabulate(n1, n2, n3, n4, n5)(f) - - @bridge - override def range[T: Integral](start: T, end: T): CC[T] = super.range(start, end) - - @bridge - override def range[T: Integral](start: T, end: T, step: T): CC[T] = super.range(start, end, step) - - @bridge - override def iterate[A](start: A, len: Int)(f: A => A): CC[A] = super.iterate(start, len)(f) -} + extends GenTraversableFactory[CC] with GenericSeqCompanion[CC] diff --git a/src/library/scala/collection/generic/TraversableForwarder.scala b/src/library/scala/collection/generic/TraversableForwarder.scala index 3d723a1feb..3d5bc2704f 100644 --- a/src/library/scala/collection/generic/TraversableForwarder.scala +++ b/src/library/scala/collection/generic/TraversableForwarder.scala @@ -57,7 +57,7 @@ trait TraversableForwarder[+A] extends Traversable[A] { override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) = underlying.copyToArray(xs, start, len) override def copyToArray[B >: A](xs: Array[B], start: Int) = underlying.copyToArray(xs, start) override def copyToArray[B >: A](xs: Array[B]) = underlying.copyToArray(xs) - override def toArray[B >: A: ClassManifest]: Array[B] = underlying.toArray + override def toArray[B >: A: ArrayTag]: Array[B] = underlying.toArray override def toList: List[A] = underlying.toList override def toIterable: Iterable[A] = underlying.toIterable override def toSeq: Seq[A] = underlying.toSeq diff --git a/src/library/scala/collection/generic/package.scala b/src/library/scala/collection/generic/package.scala index 0457fef227..32006b4bf0 100644 --- a/src/library/scala/collection/generic/package.scala +++ b/src/library/scala/collection/generic/package.scala @@ -3,4 +3,13 @@ import generic.CanBuildFrom package object generic { type CanBuild[-Elem, +To] = CanBuildFrom[Nothing, Elem, To] + + @deprecated("use ArrayTagTraversableFactory instead", "2.10.0") + type ClassManifestTraversableFactory[CC[X] <: Traversable[X] with GenericClassManifestTraversableTemplate[X, CC]] = ArrayTagTraversableFactory[CC] + + @deprecated("use GenericArrayTagCompanion instead", "2.10.0") + type GenericClassManifestCompanion[+CC[X] <: Traversable[X]] = GenericArrayTagCompanion[CC] + + @deprecated("use GenericArrayTagTraversableTemplate instead", "2.10.0") + type GenericClassManifestTraversableTemplate[+A, +CC[X] <: Traversable[X]] = GenericArrayTagTraversableTemplate[A, CC] }
\ No newline at end of file diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala index e008fb86e3..9289b35632 100644 --- a/src/library/scala/collection/immutable/ListMap.scala +++ b/src/library/scala/collection/immutable/ListMap.scala @@ -105,9 +105,6 @@ extends AbstractMap[A, B] override def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): ListMap[A, B1] = ((repr: ListMap[A, B1]) /: xs.seq) (_ + _) - @bridge def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): ListMap[A, B1] = - ++(xs: GenTraversableOnce[(A, B1)]) - /** This creates a new mapping without the given `key`. * If the map does not contain a mapping for the given key, the * method returns the same map. diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala index b71071d3c0..0331e01f35 100644 --- a/src/library/scala/collection/immutable/ListSet.scala +++ b/src/library/scala/collection/immutable/ListSet.scala @@ -102,8 +102,6 @@ class ListSet[A] extends AbstractSet[A] if (xs.isEmpty) this else (new ListSet.ListSetBuilder(this) ++= xs.seq).result - @bridge def ++(xs: TraversableOnce[A]): ListSet[A] = ++(xs: GenTraversableOnce[A]): ListSet[A] - private[ListSet] def unchecked_+(e: A): ListSet[A] = new Node(e) private[ListSet] def unchecked_outer: ListSet[A] = throw new NoSuchElementException("Empty ListSet has no outer pointer") diff --git a/src/library/scala/collection/immutable/MapLike.scala b/src/library/scala/collection/immutable/MapLike.scala index 80da1ab010..84c87b4eae 100644 --- a/src/library/scala/collection/immutable/MapLike.scala +++ b/src/library/scala/collection/immutable/MapLike.scala @@ -11,7 +11,6 @@ package immutable import generic._ import parallel.immutable.ParMap -import annotation.bridge /** * A generic template for immutable maps from keys of type `A` @@ -86,8 +85,6 @@ trait MapLike[A, +B, +This <: MapLike[A, B, This] with Map[A, B]] override def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): immutable.Map[A, B1] = ((repr: immutable.Map[A, B1]) /: xs.seq) (_ + _) - @bridge def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): immutable.Map[A, B1] = ++(xs: GenTraversableOnce[(A, B1)]) - /** Filters this map by retaining only keys satisfying a predicate. * @param p the predicate used to test keys * @return an immutable map consisting only of those key value pairs of this map where the key satisfies diff --git a/src/library/scala/collection/immutable/PagedSeq.scala b/src/library/scala/collection/immutable/PagedSeq.scala index 97c7c789f8..68c75ee586 100644 --- a/src/library/scala/collection/immutable/PagedSeq.scala +++ b/src/library/scala/collection/immutable/PagedSeq.scala @@ -25,7 +25,7 @@ object PagedSeq { final val UndeterminedEnd = Int.MaxValue /** Constructs a paged sequence from an iterator */ - def fromIterator[T: ClassManifest](source: Iterator[T]): PagedSeq[T] = + def fromIterator[T: ArrayTag](source: Iterator[T]): PagedSeq[T] = new PagedSeq[T]((data: Array[T], start: Int, len: Int) => { var i = 0 while (i < len && source.hasNext) { @@ -36,7 +36,7 @@ object PagedSeq { }) /** Constructs a paged sequence from an iterable */ - def fromIterable[T: ClassManifest](source: Iterable[T]): PagedSeq[T] = + def fromIterable[T: ArrayTag](source: Iterable[T]): PagedSeq[T] = fromIterator(source.iterator) /** Constructs a paged character sequence from a string iterator */ @@ -115,7 +115,7 @@ import PagedSeq._ * It returns the number of elements produced, or -1 if end of logical input stream was reached * before reading any element. * - * @tparam T the type of the elements contained in this paged sequence, with a `ClassManifest` context bound. + * @tparam T the type of the elements contained in this paged sequence, with an `ArrayTag` context bound. * * @author Martin Odersky * @since 2.7 @@ -124,7 +124,7 @@ import PagedSeq._ * @define mayNotTerminateInf * @define willNotTerminateInf */ -class PagedSeq[T: ClassManifest] protected( +class PagedSeq[T: ArrayTag] protected( more: (Array[T], Int, Int) => Int, first1: Page[T], start: Int, @@ -205,7 +205,7 @@ extends scala.collection.AbstractSeq[T] /** Page containing up to PageSize characters of the input sequence. */ -private class Page[T: ClassManifest](val num: Int) { +private class Page[T: ArrayTag](val num: Int) { private final val PageSize = 4096 diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala index b72d83f896..5698d53b06 100644 --- a/src/library/scala/collection/immutable/Range.scala +++ b/src/library/scala/collection/immutable/Range.scala @@ -10,7 +10,6 @@ package scala.collection.immutable import scala.collection.parallel.immutable.ParRange -import annotation.bridge /** The `Range` class represents integer values in range * ''[start;end)'' with non-zero step value `step`. @@ -398,10 +397,4 @@ object Range { def apply(start: Int, end: Int, step: Int) = NumericRange(start, end, step) def inclusive(start: Int, end: Int, step: Int) = NumericRange.inclusive(start, end, step) } - - @deprecated("use Range instead", "2.9.0") - trait ByOne extends Range { -// @bridge override def foreach[@specialized(Unit) U](f: Int => U) = -// super.foreach(f) - } } diff --git a/src/library/scala/collection/immutable/SortedMap.scala b/src/library/scala/collection/immutable/SortedMap.scala index 902a0f8457..526f7a1ffe 100644 --- a/src/library/scala/collection/immutable/SortedMap.scala +++ b/src/library/scala/collection/immutable/SortedMap.scala @@ -14,7 +14,6 @@ package immutable import generic._ import mutable.Builder import annotation.unchecked.uncheckedVariance -import annotation.bridge /** A map whose keys are sorted. * @@ -77,8 +76,6 @@ trait SortedMap[A, +B] extends Map[A, B] */ override def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): SortedMap[A, B1] = ((repr: SortedMap[A, B1]) /: xs.seq) (_ + _) - - @bridge def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): SortedMap[A, B1] = ++(xs: GenTraversableOnce[(A, B1)]) } /** $factoryInfo diff --git a/src/library/scala/collection/immutable/StringLike.scala b/src/library/scala/collection/immutable/StringLike.scala index 06f09f359f..52032a1cde 100644 --- a/src/library/scala/collection/immutable/StringLike.scala +++ b/src/library/scala/collection/immutable/StringLike.scala @@ -239,7 +239,7 @@ self => else throw new IllegalArgumentException("For input string: \"null\"") - override def toArray[B >: Char : ClassManifest]: Array[B] = + override def toArray[B >: Char : ArrayTag]: Array[B] = toString.toCharArray.asInstanceOf[Array[B]] private def unwrapArg(arg: Any): AnyRef = arg match { diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala index dc4f79be35..4c1a5f2e03 100644 --- a/src/library/scala/collection/immutable/TreeMap.scala +++ b/src/library/scala/collection/immutable/TreeMap.scala @@ -14,7 +14,6 @@ package immutable import generic._ import immutable.{RedBlackTree => RB} import mutable.Builder -import annotation.bridge /** $factoryInfo * @define Coll immutable.TreeMap @@ -162,8 +161,6 @@ class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering: Orderi override def ++[B1 >: B] (xs: GenTraversableOnce[(A, B1)]): TreeMap[A, B1] = ((repr: TreeMap[A, B1]) /: xs.seq) (_ + _) - @bridge def ++[B1 >: B] (xs: TraversableOnce[(A, B1)]): TreeMap[A, B1] = ++(xs: GenTraversableOnce[(A, B1)]) - /** A new TreeMap with the entry added is returned, * assuming that key is <em>not</em> in the TreeMap. * diff --git a/src/library/scala/collection/interfaces/IterableMethods.scala b/src/library/scala/collection/interfaces/IterableMethods.scala index 2054922e59..8efc3fe6f9 100644 --- a/src/library/scala/collection/interfaces/IterableMethods.scala +++ b/src/library/scala/collection/interfaces/IterableMethods.scala @@ -11,7 +11,6 @@ package interfaces import generic._ import mutable.Buffer -import scala.reflect.ClassManifest import annotation.unchecked.uncheckedVariance /** diff --git a/src/library/scala/collection/interfaces/SeqMethods.scala b/src/library/scala/collection/interfaces/SeqMethods.scala index 1f5b08d036..4327073d21 100644 --- a/src/library/scala/collection/interfaces/SeqMethods.scala +++ b/src/library/scala/collection/interfaces/SeqMethods.scala @@ -11,7 +11,6 @@ package interfaces import generic._ import mutable.Buffer -import scala.reflect.ClassManifest /** * @since 2.8 diff --git a/src/library/scala/collection/interfaces/SetMethods.scala b/src/library/scala/collection/interfaces/SetMethods.scala index ffe141ed82..3b6214f45c 100644 --- a/src/library/scala/collection/interfaces/SetMethods.scala +++ b/src/library/scala/collection/interfaces/SetMethods.scala @@ -11,7 +11,6 @@ package interfaces import generic._ import mutable.Buffer -import scala.reflect.ClassManifest import annotation.unchecked.uncheckedVariance /** diff --git a/src/library/scala/collection/interfaces/TraversableOnceMethods.scala b/src/library/scala/collection/interfaces/TraversableOnceMethods.scala index 471e977134..543d59d118 100644 --- a/src/library/scala/collection/interfaces/TraversableOnceMethods.scala +++ b/src/library/scala/collection/interfaces/TraversableOnceMethods.scala @@ -46,7 +46,7 @@ trait TraversableOnceMethods[+A] { def copyToBuffer[B >: A](dest: mutable.Buffer[B]): Unit // conversions - def toArray[B >: A : ClassManifest]: Array[B] + def toArray[B >: A : ArrayTag]: Array[B] def toBuffer[B >: A]: mutable.Buffer[B] def toIndexedSeq: immutable.IndexedSeq[A] def toIterable: Iterable[A] diff --git a/src/library/scala/collection/mutable/ArrayBuilder.scala b/src/library/scala/collection/mutable/ArrayBuilder.scala index e396b0695e..293e85a97e 100644 --- a/src/library/scala/collection/mutable/ArrayBuilder.scala +++ b/src/library/scala/collection/mutable/ArrayBuilder.scala @@ -12,7 +12,8 @@ package scala.collection package mutable import generic._ -import scala.reflect.ClassManifest +import scala.reflect.ArrayTag +import scala.runtime.ScalaRunTime /** A builder class for arrays. * @@ -30,12 +31,12 @@ object ArrayBuilder { /** Creates a new arraybuilder of type `T`. * - * @tparam T type of the elements for the array builder, with a `ClassManifest` context bound. + * @tparam T type of the elements for the array builder, with a `ArrayTag` context bound. * @return a new empty array builder. */ - def make[T: ClassManifest](): ArrayBuilder[T] = { - val manifest = implicitly[ClassManifest[T]] - val erasure = manifest.erasure + def make[T: ArrayTag](): ArrayBuilder[T] = { + val tag = implicitly[ArrayTag[T]] + val erasure = ScalaRunTime.arrayElementClass(tag) erasure match { case java.lang.Byte.TYPE => new ArrayBuilder.ofByte().asInstanceOf[ArrayBuilder[T]] case java.lang.Short.TYPE => new ArrayBuilder.ofShort().asInstanceOf[ArrayBuilder[T]] @@ -46,15 +47,15 @@ object ArrayBuilder { case java.lang.Double.TYPE => new ArrayBuilder.ofDouble().asInstanceOf[ArrayBuilder[T]] case java.lang.Boolean.TYPE => new ArrayBuilder.ofBoolean().asInstanceOf[ArrayBuilder[T]] case java.lang.Void.TYPE => new ArrayBuilder.ofUnit().asInstanceOf[ArrayBuilder[T]] - case _ => new ArrayBuilder.ofRef[T with AnyRef]()(manifest.asInstanceOf[ClassManifest[T with AnyRef]]).asInstanceOf[ArrayBuilder[T]] + case _ => new ArrayBuilder.ofRef[T with AnyRef]()(tag.asInstanceOf[ArrayTag[T with AnyRef]]).asInstanceOf[ArrayBuilder[T]] } } /** A class for array builders for arrays of reference types. * - * @tparam T type of elements for the array builder, subtype of `AnyRef` with a `ClassManifest` context bound. + * @tparam T type of elements for the array builder, subtype of `AnyRef` with a `ArrayTag` context bound. */ - class ofRef[T <: AnyRef : ClassManifest] extends ArrayBuilder[T] { + class ofRef[T <: AnyRef : ArrayTag] extends ArrayBuilder[T] { private var elems: Array[T] = _ private var capacity: Int = 0 diff --git a/src/library/scala/collection/mutable/ArrayOps.scala b/src/library/scala/collection/mutable/ArrayOps.scala index 875030ade0..5f0e1e1071 100644 --- a/src/library/scala/collection/mutable/ArrayOps.scala +++ b/src/library/scala/collection/mutable/ArrayOps.scala @@ -12,7 +12,8 @@ package scala.collection package mutable import compat.Platform.arraycopy -import scala.reflect.ClassManifest +import scala.reflect.ArrayTag +import scala.runtime.ScalaRunTime._ import parallel.mutable.ParArray @@ -37,10 +38,8 @@ import parallel.mutable.ParArray */ abstract class ArrayOps[T] extends ArrayLike[T, Array[T]] with CustomParallelizable[T, ParArray[T]] { - private def rowBuilder[U]: Builder[U, Array[U]] = - Array.newBuilder( - ClassManifest[U]( - repr.getClass.getComponentType.getComponentType)) + private def elementClass: Class[_] = + arrayElementClass(repr.getClass) override def copyToArray[U >: T](xs: Array[U], start: Int, len: Int) { var l = math.min(len, repr.length) @@ -48,11 +47,13 @@ abstract class ArrayOps[T] extends ArrayLike[T, Array[T]] with CustomParalleliza Array.copy(repr, 0, xs, start, l) } - override def toArray[U >: T : ClassManifest]: Array[U] = - if (implicitly[ClassManifest[U]].erasure eq repr.getClass.getComponentType) + override def toArray[U >: T : ArrayTag]: Array[U] = { + val thatElementClass = arrayElementClass(implicitly[ArrayTag[U]]) + if (elementClass eq thatElementClass) repr.asInstanceOf[Array[U]] else super.toArray[U] + } override def par = ParArray.handoff(repr) @@ -63,7 +64,7 @@ abstract class ArrayOps[T] extends ArrayLike[T, Array[T]] with CustomParalleliza * @param asArray A function that converts elements of this array to rows - arrays of type `U`. * @return An array obtained by concatenating rows of this array. */ - def flatten[U, To](implicit asTrav: T => collection.Traversable[U], m: ClassManifest[U]): Array[U] = { + def flatten[U, To](implicit asTrav: T => collection.Traversable[U], m: ArrayTag[U]): Array[U] = { val b = Array.newBuilder[U] b.sizeHint(map{case is: collection.IndexedSeq[_] => is.size case _ => 0}.sum) for (xs <- this) @@ -78,7 +79,8 @@ abstract class ArrayOps[T] extends ArrayLike[T, Array[T]] with CustomParalleliza * @return An array obtained by replacing elements of this arrays with rows the represent. */ def transpose[U](implicit asArray: T => Array[U]): Array[Array[U]] = { - val bs = asArray(head) map (_ => rowBuilder[U]) + def mkRowBuilder() = Array.newBuilder(ClassTag[U](arrayElementClass(elementClass))) + val bs = asArray(head) map (_ => mkRowBuilder()) for (xs <- this) { var i = 0 for (x <- asArray(xs)) { @@ -86,9 +88,7 @@ abstract class ArrayOps[T] extends ArrayLike[T, Array[T]] with CustomParalleliza i += 1 } } - val bb: Builder[Array[U], Array[Array[U]]] = Array.newBuilder( - ClassManifest[Array[U]]( - repr.getClass.getComponentType)) + val bb: Builder[Array[U], Array[Array[U]]] = Array.newBuilder(ClassTag[Array[U]](elementClass)) for (b <- bs) bb += b.result bb.result } @@ -109,8 +109,7 @@ object ArrayOps { override protected[this] def thisCollection: WrappedArray[T] = new WrappedArray.ofRef[T](repr) override protected[this] def toCollection(repr: Array[T]): WrappedArray[T] = new WrappedArray.ofRef[T](repr) - override protected[this] def newBuilder = new ArrayBuilder.ofRef[T]()( - ClassManifest[T](repr.getClass.getComponentType)) + override protected[this] def newBuilder = new ArrayBuilder.ofRef[T]()(ClassTag[T](arrayElementClass(repr.getClass))) def length: Int = repr.length def apply(index: Int): T = repr(index) diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala index f5287312b9..b3a0534826 100644 --- a/src/library/scala/collection/mutable/ArrayStack.scala +++ b/src/library/scala/collection/mutable/ArrayStack.scala @@ -21,7 +21,7 @@ object ArrayStack extends SeqFactory[ArrayStack] { implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, ArrayStack[A]] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]] def newBuilder[A]: Builder[A, ArrayStack[A]] = new ArrayStack[A] def empty: ArrayStack[Nothing] = new ArrayStack() - def apply[A: ClassManifest](elems: A*): ArrayStack[A] = { + def apply[A: ArrayTag](elems: A*): ArrayStack[A] = { val els: Array[AnyRef] = elems.reverseMap(_.asInstanceOf[AnyRef])(breakOut) if (els.length == 0) new ArrayStack() else new ArrayStack[A](els, els.length) diff --git a/src/library/scala/collection/mutable/BufferLike.scala b/src/library/scala/collection/mutable/BufferLike.scala index 1dc2fc27d5..f82a596b32 100644 --- a/src/library/scala/collection/mutable/BufferLike.scala +++ b/src/library/scala/collection/mutable/BufferLike.scala @@ -223,9 +223,6 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] @migration("`++` creates a new buffer. Use `++=` to add an element from this buffer and return that buffer itself.", "2.8.0") def ++(xs: GenTraversableOnce[A]): This = clone() ++= xs.seq - @bridge - def ++(xs: TraversableOnce[A]): This = ++(xs: GenTraversableOnce[A]) - /** Creates a new collection with all the elements of this collection except `elem`. * * @param elem the element to remove. @@ -255,6 +252,4 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] */ @migration("`--` creates a new buffer. Use `--=` to remove an element from this buffer and return that buffer itself.", "2.8.0") override def --(xs: GenTraversableOnce[A]): This = clone() --= xs.seq - - @bridge def --(xs: TraversableOnce[A]): This = --(xs: GenTraversableOnce[A]) } diff --git a/src/library/scala/collection/mutable/FlatArray.scala b/src/library/scala/collection/mutable/FlatArray.scala deleted file mode 100644 index 3e43b66ecf..0000000000 --- a/src/library/scala/collection/mutable/FlatArray.scala +++ /dev/null @@ -1,157 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.collection -package mutable - -import scala.reflect.ClassManifest -import generic.CanBuildFrom - -/** - * A class representing `Array[T]`. - * - * @tparam T type of the elements in this wrapped array. - * - * @author Martin Odersky, Stephane Micheloud - * @version 1.0 - * @since 2.8 - * @define Coll WrappedArray - * @define coll wrapped array - * @define orderDependent - * @define orderDependentFold - * @define mayNotTerminateInf - * @define willNotTerminateInf - */ -abstract sealed class FlatArray[T] -extends AbstractSeq[T] - with IndexedSeq[T] - with IndexedSeqOptimized[T, FlatArray[T]] -{ - - override protected[this] def thisCollection: FlatArray[T] = this - override protected[this] def toCollection(repr: FlatArray[T]): FlatArray[T] = repr - - /** The length of the array */ - def length: Int - - /** The element at given index */ - def apply(index: Int): T - - /** Update element at given index */ - def update(index: Int, elem: T): Unit - - override def stringPrefix = "FlatArray" - - override protected[this] def newBuilder: Builder[T, FlatArray[T]] = ??? // implemented in FlatArray.Impl - - /** Clones this object, including the underlying Array. */ - override def clone: FlatArray[T] = ??? // implemented in FlatArray.Impl -} - - -/** A companion object used to create instances of `WrappedArray`. - */ -object FlatArray { - - def ofDim[Boxed, Unboxed](size:Int) - (implicit boxings: BoxingConversions[Boxed, Unboxed], - manifest: ClassManifest[Unboxed]): FlatArray[Boxed] = { - val elems = Array.ofDim[Unboxed](size) - new FlatArray.Impl(elems, boxings, manifest) - } - - def empty[Boxed, Unboxed](implicit boxings: BoxingConversions[Boxed, Unboxed], - elemManifest: ClassManifest[Unboxed]): FlatArray[Boxed] = apply() - - def apply[Boxed, Unboxed](elems: Boxed*) - (implicit boxings: BoxingConversions[Boxed, Unboxed], elemManifest: ClassManifest[Unboxed]): FlatArray[Boxed] = { - val b = newBuilder[Boxed, Unboxed] - b.sizeHint(elems.length) - b ++= elems - b.result - } - - def newBuilder[Boxed, Unboxed] - (implicit boxings: BoxingConversions[Boxed, Unboxed], elemManifest: ClassManifest[Unboxed]): Builder[Boxed, FlatArray[Boxed]] = - new Bldr[Boxed, Unboxed](boxings, elemManifest) - - implicit def canBuildFrom[Boxed, Unboxed]( - implicit - boxings: BoxingConversions[Boxed, Unboxed], - elemManifest: ClassManifest[Unboxed]): CanBuildFrom[FlatArray[_], Boxed, FlatArray[Boxed]] = - new CanBuildFrom[FlatArray[_], Boxed, FlatArray[Boxed]] { - def apply(from: FlatArray[_]): Builder[Boxed, FlatArray[Boxed]] = - newBuilder[Boxed, Unboxed] - def apply: Builder[Boxed, FlatArray[Boxed]] = - newBuilder[Boxed, Unboxed] - } - - private class Bldr[Boxed, Unboxed](boxings: BoxingConversions[Boxed, Unboxed], manifest: ClassManifest[Unboxed]) extends Builder[Boxed, FlatArray[Boxed]] { - - private var elems: Array[Unboxed] = _ - private var capacity: Int = 0 - private var size: Int = 0 - - private def resize(size: Int) { - val newelems = manifest.newArray(size) - if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) - elems = newelems - capacity = size - } - - override def sizeHint(size: Int) { - if (capacity < size) resize(size) - } - - private def ensureSize(size: Int) { - if (capacity < size) { - var newsize = if (capacity == 0) 16 else capacity * 2 - while (newsize < size) newsize *= 2 - resize(newsize) - } - } - - def +=(elem: Boxed): this.type = { - ensureSize(size + 1) - elems(size) = boxings.unbox(elem) - size += 1 - this - } - - def clear() { - size = 0 - } - - def result(): FlatArray[Boxed] = { - if (capacity == 0 || capacity != size) resize(size) - new FlatArray.Impl(elems, boxings, manifest) - } - } - - private class Impl[Boxed, Unboxed]( - elems: Array[Unboxed], - boxings: BoxingConversions[Boxed, Unboxed], - elemManifest: ClassManifest[Unboxed]) extends FlatArray[Boxed] { - - def length = elems.length - - def apply(idx: Int): Boxed = boxings.box(elems(idx)) - - def update(idx: Int, elem: Boxed) = elems(idx) = boxings.unbox(elem) - - /** Creates new builder for this collection ==> move to subclasses - */ - override protected[this] def newBuilder: Builder[Boxed, FlatArray[Boxed]] = - new Bldr[Boxed, Unboxed](boxings, elemManifest) - - /** Clones this object, including the underlying Array. */ - override def clone: FlatArray[Boxed] = new Impl[Boxed, Unboxed](elems.clone(), boxings, elemManifest) - } -} diff --git a/src/library/scala/collection/mutable/MapLike.scala b/src/library/scala/collection/mutable/MapLike.scala index b08a4b7bc9..b8b1152099 100644 --- a/src/library/scala/collection/mutable/MapLike.scala +++ b/src/library/scala/collection/mutable/MapLike.scala @@ -119,8 +119,6 @@ trait MapLike[A, B, +This <: MapLike[A, B, This] with Map[A, B]] override def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): Map[A, B1] = clone().asInstanceOf[Map[A, B1]] ++= xs.seq - @bridge def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): Map[A, B1] = ++(xs: GenTraversableOnce[(A, B1)]) - /** Removes a key from this map, returning the value associated previously * with that key as an option. * @param key the key to be removed @@ -224,6 +222,4 @@ trait MapLike[A, B, +This <: MapLike[A, B, This] with Map[A, B]] */ @migration("`--` creates a new map. Use `--=` to remove an element from this map and return that map itself.", "2.8.0") override def --(xs: GenTraversableOnce[A]): This = clone() --= xs.seq - - @bridge def --(xs: TraversableOnce[A]): This = --(xs: GenTraversableOnce[A]) } diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index 381cb09e18..12dee45bae 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -12,7 +12,6 @@ package scala.collection package mutable import generic._ -import annotation.bridge /** This class implements priority queues using a heap. * To prioritize elements of type A there must be an implicit @@ -113,9 +112,6 @@ class PriorityQueue[A](implicit val ord: Ordering[A]) */ def ++(xs: GenTraversableOnce[A]): PriorityQueue[A] = { this.clone() ++= xs.seq } - @bridge - def ++(xs: TraversableOnce[A]): PriorityQueue[A] = ++ (xs: GenTraversableOnce[A]) - /** Adds all elements to the queue. * * @param elems the elements to add. diff --git a/src/library/scala/collection/mutable/SetLike.scala b/src/library/scala/collection/mutable/SetLike.scala index 5e201d9959..37313c8ca3 100644 --- a/src/library/scala/collection/mutable/SetLike.scala +++ b/src/library/scala/collection/mutable/SetLike.scala @@ -170,8 +170,6 @@ trait SetLike[A, +This <: SetLike[A, This] with Set[A]] @migration("`++` creates a new set. Use `++=` to add elements to this set and return that set itself.", "2.8.0") override def ++(xs: GenTraversableOnce[A]): This = clone() ++= xs.seq - @bridge def ++(xs: TraversableOnce[A]): This = ++(xs: GenTraversableOnce[A]) - /** Creates a new set consisting of all the elements of this set except `elem`. * * @param elem the element to remove. @@ -203,8 +201,6 @@ trait SetLike[A, +This <: SetLike[A, This] with Set[A]] @migration("`--` creates a new set. Use `--=` to remove elements from this set and return that set itself.", "2.8.0") override def --(xs: GenTraversableOnce[A]): This = clone() --= xs.seq - @bridge def --(xs: TraversableOnce[A]): This = --(xs: GenTraversableOnce[A]) - /** Send a message to this scriptable object. * * @param cmd the message to send. diff --git a/src/library/scala/collection/mutable/UnrolledBuffer.scala b/src/library/scala/collection/mutable/UnrolledBuffer.scala index 09e6088782..889768d471 100644 --- a/src/library/scala/collection/mutable/UnrolledBuffer.scala +++ b/src/library/scala/collection/mutable/UnrolledBuffer.scala @@ -41,11 +41,11 @@ import annotation.tailrec * */ @SerialVersionUID(1L) -class UnrolledBuffer[T](implicit val manifest: ClassManifest[T]) +class UnrolledBuffer[T](implicit val tag: ArrayTag[T]) extends collection.mutable.AbstractBuffer[T] with collection.mutable.Buffer[T] with collection.mutable.BufferLike[T, UnrolledBuffer[T]] - with GenericClassManifestTraversableTemplate[T, UnrolledBuffer] + with GenericArrayTagTraversableTemplate[T, UnrolledBuffer] with collection.mutable.Builder[T, UnrolledBuffer[T]] with Serializable { @@ -67,7 +67,7 @@ extends collection.mutable.AbstractBuffer[T] private[collection] def calcNextLength(sz: Int) = sz - def classManifestCompanion = UnrolledBuffer + def arrayTagCompanion = UnrolledBuffer /** Concatenates the targer unrolled buffer to this unrolled buffer. * @@ -183,11 +183,11 @@ extends collection.mutable.AbstractBuffer[T] } -object UnrolledBuffer extends ClassManifestTraversableFactory[UnrolledBuffer] { +object UnrolledBuffer extends ArrayTagTraversableFactory[UnrolledBuffer] { /** $genericCanBuildFromInfo */ - implicit def canBuildFrom[T](implicit m: ClassManifest[T]): CanBuildFrom[Coll, T, UnrolledBuffer[T]] = + implicit def canBuildFrom[T](implicit t: ArrayTag[T]): CanBuildFrom[Coll, T, UnrolledBuffer[T]] = new GenericCanBuildFrom[T] - def newBuilder[T](implicit m: ClassManifest[T]): Builder[T, UnrolledBuffer[T]] = new UnrolledBuffer[T] + def newBuilder[T](implicit t: ArrayTag[T]): Builder[T, UnrolledBuffer[T]] = new UnrolledBuffer[T] val waterline = 50 val waterlineDelim = 100 @@ -195,7 +195,7 @@ object UnrolledBuffer extends ClassManifestTraversableFactory[UnrolledBuffer] { /** Unrolled buffer node. */ - class Unrolled[T: ClassManifest] private[collection] (var size: Int, var array: Array[T], var next: Unrolled[T], val buff: UnrolledBuffer[T] = null) { + class Unrolled[T: ArrayTag] private[collection] (var size: Int, var array: Array[T], var next: Unrolled[T], val buff: UnrolledBuffer[T] = null) { private[collection] def this() = this(0, new Array[T](unrolledlength), null, null) private[collection] def this(b: UnrolledBuffer[T]) = this(0, new Array[T](unrolledlength), null, b) diff --git a/src/library/scala/collection/mutable/WrappedArray.scala b/src/library/scala/collection/mutable/WrappedArray.scala index fac4eb77bb..9d170b2832 100644 --- a/src/library/scala/collection/mutable/WrappedArray.scala +++ b/src/library/scala/collection/mutable/WrappedArray.scala @@ -11,7 +11,8 @@ package scala.collection package mutable -import scala.reflect.ClassManifest +import scala.reflect.ArrayTag +import scala.runtime.ScalaRunTime._ import scala.collection.generic._ import scala.collection.parallel.mutable.ParArray @@ -40,8 +41,11 @@ extends AbstractSeq[T] override protected[this] def thisCollection: WrappedArray[T] = this override protected[this] def toCollection(repr: WrappedArray[T]): WrappedArray[T] = repr - /** The manifest of the element type */ - def elemManifest: ClassManifest[T] + /** The tag of the element type */ + def elemTag: ArrayTag[T] + + @deprecated("use elemTag instead", "2.10.0") + def elemManifest: ClassManifest[T] = ClassManifest.fromClass[T](arrayElementClass(elemTag).asInstanceOf[Class[T]]) /** The length of the array */ def length: Int @@ -57,11 +61,16 @@ extends AbstractSeq[T] override def par = ParArray.handoff(array) - override def toArray[U >: T : ClassManifest]: Array[U] = - if (implicitly[ClassManifest[U]].erasure eq array.getClass.getComponentType) + private def elementClass: Class[_] = + arrayElementClass(repr.getClass) + + override def toArray[U >: T : ArrayTag]: Array[U] = { + val thatElementClass = arrayElementClass(implicitly[ArrayTag[U]]) + if (elementClass eq thatElementClass) array.asInstanceOf[Array[U]] else super.toArray[U] + } override def stringPrefix = "WrappedArray" @@ -71,7 +80,7 @@ extends AbstractSeq[T] /** Creates new builder for this collection ==> move to subclasses */ override protected[this] def newBuilder: Builder[T, WrappedArray[T]] = - new WrappedArrayBuilder[T](elemManifest) + new WrappedArrayBuilder[T](elemTag) } @@ -101,7 +110,7 @@ object WrappedArray { case x: Array[Unit] => new ofUnit(x) }).asInstanceOf[WrappedArray[T]] - implicit def canBuildFrom[T](implicit m: ClassManifest[T]): CanBuildFrom[WrappedArray[_], T, WrappedArray[T]] = + implicit def canBuildFrom[T](implicit m: ArrayTag[T]): CanBuildFrom[WrappedArray[_], T, WrappedArray[T]] = new CanBuildFrom[WrappedArray[_], T, WrappedArray[T]] { def apply(from: WrappedArray[_]): Builder[T, WrappedArray[T]] = ArrayBuilder.make[T]()(m) mapResult WrappedArray.make[T] @@ -112,70 +121,70 @@ object WrappedArray { def newBuilder[A]: Builder[A, IndexedSeq[A]] = new ArrayBuffer final class ofRef[T <: AnyRef](val array: Array[T]) extends WrappedArray[T] with Serializable { - lazy val elemManifest = ClassManifest[T](array.getClass.getComponentType) + lazy val elemTag = ClassTag[T](arrayElementClass(array.getClass)) def length: Int = array.length def apply(index: Int): T = array(index).asInstanceOf[T] def update(index: Int, elem: T) { array(index) = elem } } final class ofByte(val array: Array[Byte]) extends WrappedArray[Byte] with Serializable { - def elemManifest = ClassManifest.Byte + def elemTag = ClassTag.Byte def length: Int = array.length def apply(index: Int): Byte = array(index) def update(index: Int, elem: Byte) { array(index) = elem } } final class ofShort(val array: Array[Short]) extends WrappedArray[Short] with Serializable { - def elemManifest = ClassManifest.Short + def elemTag = ClassTag.Short def length: Int = array.length def apply(index: Int): Short = array(index) def update(index: Int, elem: Short) { array(index) = elem } } final class ofChar(val array: Array[Char]) extends WrappedArray[Char] with Serializable { - def elemManifest = ClassManifest.Char + def elemTag = ClassTag.Char def length: Int = array.length def apply(index: Int): Char = array(index) def update(index: Int, elem: Char) { array(index) = elem } } final class ofInt(val array: Array[Int]) extends WrappedArray[Int] with Serializable { - def elemManifest = ClassManifest.Int + def elemTag = ClassTag.Int def length: Int = array.length def apply(index: Int): Int = array(index) def update(index: Int, elem: Int) { array(index) = elem } } final class ofLong(val array: Array[Long]) extends WrappedArray[Long] with Serializable { - def elemManifest = ClassManifest.Long + def elemTag = ClassTag.Long def length: Int = array.length def apply(index: Int): Long = array(index) def update(index: Int, elem: Long) { array(index) = elem } } final class ofFloat(val array: Array[Float]) extends WrappedArray[Float] with Serializable { - def elemManifest = ClassManifest.Float + def elemTag = ClassTag.Float def length: Int = array.length def apply(index: Int): Float = array(index) def update(index: Int, elem: Float) { array(index) = elem } } final class ofDouble(val array: Array[Double]) extends WrappedArray[Double] with Serializable { - def elemManifest = ClassManifest.Double + def elemTag = ClassTag.Double def length: Int = array.length def apply(index: Int): Double = array(index) def update(index: Int, elem: Double) { array(index) = elem } } final class ofBoolean(val array: Array[Boolean]) extends WrappedArray[Boolean] with Serializable { - def elemManifest = ClassManifest.Boolean + def elemTag = ClassTag.Boolean def length: Int = array.length def apply(index: Int): Boolean = array(index) def update(index: Int, elem: Boolean) { array(index) = elem } } final class ofUnit(val array: Array[Unit]) extends WrappedArray[Unit] with Serializable { - def elemManifest = ClassManifest.Unit + def elemTag = ClassTag.Unit def length: Int = array.length def apply(index: Int): Unit = array(index) def update(index: Int, elem: Unit) { array(index) = elem } diff --git a/src/library/scala/collection/mutable/WrappedArrayBuilder.scala b/src/library/scala/collection/mutable/WrappedArrayBuilder.scala index fce65468e9..99a0b0ede3 100644 --- a/src/library/scala/collection/mutable/WrappedArrayBuilder.scala +++ b/src/library/scala/collection/mutable/WrappedArrayBuilder.scala @@ -12,23 +12,27 @@ package scala.collection package mutable import generic._ -import scala.reflect.ClassManifest +import scala.reflect.ArrayTag +import scala.runtime.ScalaRunTime._ /** A builder class for arrays. * - * @tparam A type of elements that can be added to this builder. - * @param manifest class manifest for objects of type `A`. + * @tparam A type of elements that can be added to this builder. + * @param tag class tag for objects of type `A`. * * @since 2.8 */ -class WrappedArrayBuilder[A](manifest: ClassManifest[A]) extends Builder[A, WrappedArray[A]] { +class WrappedArrayBuilder[A](tag: ArrayTag[A]) extends Builder[A, WrappedArray[A]] { + + @deprecated("use tag instead", "2.10.0") + val manifest: ArrayTag[A] = tag private var elems: WrappedArray[A] = _ private var capacity: Int = 0 private var size: Int = 0 private def mkArray(size: Int): WrappedArray[A] = { - val erasure = manifest.erasure + val erasure = arrayElementClass(tag) val newelems = erasure match { case java.lang.Byte.TYPE => new WrappedArray.ofByte(new Array[Byte](size)).asInstanceOf[WrappedArray[A]] case java.lang.Short.TYPE => new WrappedArray.ofShort(new Array[Short](size)).asInstanceOf[WrappedArray[A]] @@ -39,7 +43,7 @@ class WrappedArrayBuilder[A](manifest: ClassManifest[A]) extends Builder[A, Wrap case java.lang.Double.TYPE => new WrappedArray.ofDouble(new Array[Double](size)).asInstanceOf[WrappedArray[A]] case java.lang.Boolean.TYPE => new WrappedArray.ofBoolean(new Array[Boolean](size)).asInstanceOf[WrappedArray[A]] case java.lang.Void.TYPE => new WrappedArray.ofUnit(new Array[Unit](size)).asInstanceOf[WrappedArray[A]] - case _ => new WrappedArray.ofRef[A with AnyRef](manifest.newArray(size).asInstanceOf[Array[A with AnyRef]]).asInstanceOf[WrappedArray[A]] + case _ => new WrappedArray.ofRef[A with AnyRef](tag.newArray(size).asInstanceOf[Array[A with AnyRef]]).asInstanceOf[WrappedArray[A]] } if (this.size > 0) Array.copy(elems.array, 0, newelems.array, 0, this.size) newelems diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala index 5bf338f560..014b9b1a42 100644 --- a/src/library/scala/collection/parallel/ParIterableLike.scala +++ b/src/library/scala/collection/parallel/ParIterableLike.scala @@ -155,15 +155,15 @@ extends GenIterableLike[T, Repr] with HasNewCombiner[T, Repr] { self: ParIterableLike[T, Repr, Sequential] => - + @transient @volatile private var _tasksupport = defaultTaskSupport - + protected def initTaskSupport() { _tasksupport = defaultTaskSupport } - + def tasksupport = { val ts = _tasksupport if (ts eq null) { @@ -171,9 +171,9 @@ self: ParIterableLike[T, Repr, Sequential] => defaultTaskSupport } else ts } - + def tasksupport_=(ts: TaskSupport) = _tasksupport = ts - + def seq: Sequential def repr: Repr = this.asInstanceOf[Repr] @@ -240,7 +240,7 @@ self: ParIterableLike[T, Repr, Sequential] => trait BuilderOps[Elem, To] { trait Otherwise[Cmb] { - def otherwise(notbody: => Unit)(implicit m: ClassManifest[Cmb]): Unit + def otherwise(notbody: => Unit)(implicit t: ClassTag[Cmb]): Unit } def ifIs[Cmb](isbody: Cmb => Unit): Otherwise[Cmb] @@ -282,8 +282,8 @@ self: ParIterableLike[T, Repr, Sequential] => protected implicit def builder2ops[Elem, To](cb: Builder[Elem, To]) = new BuilderOps[Elem, To] { def ifIs[Cmb](isbody: Cmb => Unit) = new Otherwise[Cmb] { - def otherwise(notbody: => Unit)(implicit m: ClassManifest[Cmb]) { - if (cb.getClass == m.erasure) isbody(cb.asInstanceOf[Cmb]) else notbody + def otherwise(notbody: => Unit)(implicit t: ClassTag[Cmb]) { + if (cb.getClass == t.erasure) isbody(cb.asInstanceOf[Cmb]) else notbody } } def isCombiner = cb.isInstanceOf[Combiner[_, _]] @@ -754,7 +754,7 @@ self: ParIterableLike[T, Repr, Sequential] => cntx.setIndexFlag(Int.MaxValue) tasksupport.executeAndWaitResult( new Span(0, pred, combinerFactory, combinerFactory, splitter assign cntx) mapResult { - _._2.resultWithTaskSupport + _._2.resultWithTaskSupport } ) } @@ -802,7 +802,7 @@ self: ParIterableLike[T, Repr, Sequential] => def size = splitter.remaining } - override def toArray[U >: T: ClassManifest]: Array[U] = { + override def toArray[U >: T: ArrayTag]: Array[U] = { val arr = new Array[U](size) copyToArray(arr) arr diff --git a/src/library/scala/collection/parallel/mutable/ParArray.scala b/src/library/scala/collection/parallel/mutable/ParArray.scala index 8cc0b95997..92ba701f7c 100644 --- a/src/library/scala/collection/parallel/mutable/ParArray.scala +++ b/src/library/scala/collection/parallel/mutable/ParArray.scala @@ -676,7 +676,7 @@ self => private def readObject(in: java.io.ObjectInputStream) { in.defaultReadObject - + // get raw array from arrayseq array = arrayseq.array.asInstanceOf[Array[Any]] } @@ -706,7 +706,7 @@ object ParArray extends ParFactory[ParArray] { case _ => new ParArray[T](new ExposedArraySeq[T](runtime.ScalaRunTime.toObjectArray(arr), sz)) } - def createFromCopy[T <: AnyRef : ClassManifest](arr: Array[T]): ParArray[T] = { + def createFromCopy[T <: AnyRef : ArrayTag](arr: Array[T]): ParArray[T] = { val newarr = new Array[T](arr.length) Array.copy(arr, 0, newarr, 0, arr.length) handoff(newarr) diff --git a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala index 410b542a68..43d40776bf 100644 --- a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala +++ b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala @@ -26,7 +26,7 @@ import scala.collection.parallel.Task -private[mutable] class DoublingUnrolledBuffer[T](implicit m: ClassManifest[T]) extends UnrolledBuffer[T]()(m) { +private[mutable] class DoublingUnrolledBuffer[T](implicit t: ArrayTag[T]) extends UnrolledBuffer[T]()(t) { override def calcNextLength(sz: Int) = if (sz < 10000) sz * 2 else sz protected override def newUnrolled = new Unrolled[T](0, new Array[T](4), null, this) } diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala index 9aaf05dbd6..def086bc03 100644 --- a/src/library/scala/concurrent/Future.scala +++ b/src/library/scala/concurrent/Future.scala @@ -134,26 +134,26 @@ trait Future[+T] extends Awaitable[T] { /** Creates a new promise. */ protected def newPromise[S]: Promise[S] - + /** Returns whether the future has already been completed with * a value or an exception. - * + * * $nonDeterministic - * + * * @return `true` if the future is already completed, `false` otherwise */ def isCompleted: Boolean - + /** The value of this `Future`. - * + * * If the future is not completed the returned value will be `None`. * If the future is completed the value will be `Some(Success(t))` * if it contains a valid result, or `Some(Failure(error))` if it contains * an exception. */ def value: Option[Either[Throwable, T]] - - + + /* Projections */ /** Returns a failed projection of this future. @@ -421,11 +421,11 @@ trait Future[+T] extends Awaitable[T] { } p.future } - + /** Creates a new `Future[S]` which is completed with this `Future`'s result if * that conforms to `S`'s erased type or a `ClassCastException` otherwise. */ - def mapTo[S](implicit m: Manifest[S]): Future[S] = { + def mapTo[S](implicit tag: ClassTag[S]): Future[S] = { import java.{ lang => jl } val toBoxed = Map[Class[_], Class[_]]( classOf[Boolean] -> classOf[jl.Boolean], @@ -444,20 +444,20 @@ trait Future[+T] extends Awaitable[T] { } val p = newPromise[S] - + onComplete { case l: Left[Throwable, _] => p complete l.asInstanceOf[Either[Throwable, S]] case Right(t) => p complete (try { - Right(boxedType(m.erasure).cast(t).asInstanceOf[S]) + Right(boxedType(tag.erasure).cast(t).asInstanceOf[S]) } catch { case e: ClassCastException => Left(e) }) } - + p.future } - + /** Applies the side-effecting function to the result of this future, and returns * a new future with the result of this future. * @@ -591,7 +591,7 @@ object Future { * The fold is performed on the thread where the last future is completed, * the result will be the first failure of any of the futures, or any failure in the actual fold, * or the result of the fold. - * + * * Example: * {{{ * val result = Await.result(Future.fold(futures)(0)(_ + _), 5 seconds) @@ -603,7 +603,7 @@ object Future { } /** Initiates a fold over the supplied futures where the fold-zero is the result value of the `Future` that's completed first. - * + * * Example: * {{{ * val result = Await.result(Futures.reduce(futures)(_ + _), 5 seconds) @@ -613,11 +613,11 @@ object Future { if (futures.isEmpty) Promise[R].failure(new NoSuchElementException("reduce attempted on empty collection")).future else sequence(futures).map(_ reduceLeft op) } - + /** Transforms a `Traversable[A]` into a `Future[Traversable[B]]` using the provided function `A => Future[B]`. * This is useful for performing a parallel map. For example, to apply a function to all items of a list * in parallel: - * + * * {{{ * val myFutureList = Future.traverse(myList)(x => Future(myFunc(x))) * }}} @@ -627,7 +627,7 @@ object Future { val fb = fn(a.asInstanceOf[A]) for (r <- fr; b <- fb) yield (r += b) }.map(_.result) - + } diff --git a/src/library/scala/language.scala b/src/library/scala/language.scala index 2837187d48..df2eb0b910 100644 --- a/src/library/scala/language.scala +++ b/src/library/scala/language.scala @@ -17,7 +17,7 @@ object language { * of programs. Furthermore, dynamic member selection often relies on reflection, * which is not available on all platforms. */ - implicit val dynamics: dynamics = ??? + implicit lazy val dynamics: dynamics = ??? /** Only where enabled, postfix operator notation `(expr op)` will be allowed. * @@ -26,7 +26,7 @@ object language { * _Why control it?_ Postfix operators interact poorly with semicolon inference. * Most programmers avoid them for this reason. */ - implicit val postfixOps: postfixOps = ??? + implicit lazy val postfixOps: postfixOps = ??? /** Only where enabled, accesses to members of structural types that need * reflection are supported. Reminder: A structural type is a type of the form @@ -42,7 +42,7 @@ object language { * such as ProGuard have problems dealing with it. Even where reflection is available, * reflective dispatch can lead to surprising performance degradations. */ - implicit val reflectiveCalls: reflectiveCalls = ??? + implicit lazy val reflectiveCalls: reflectiveCalls = ??? /** Only where enabled, definitions of implicit conversions are allowed. An * implicit conversion is an implicit value of unary function type `A => B`, @@ -53,7 +53,7 @@ object language { * implicit val conv = (s: String) => s.length * implicit def listToX(xs: List[T])(implicit f: T => X): X = … * - * Implicit values of other types are not affected, and neither are implicit + * implicit values of other types are not affected, and neither are implicit * classes. * * _Why keep the feature?_ Implicit conversions are central to many aspects @@ -65,7 +65,7 @@ object language { * most situations using implicit parameters leads to a better design than * implicit conversions. */ - implicit val implicitConversions: implicitConversions = ??? + implicit lazy val implicitConversions: implicitConversions = ??? /** Only where this flag is enabled, higher-kinded types can be written. * @@ -86,7 +86,7 @@ object language { * enabling also serves as a warning that code involving higher-kinded types * might have to be slightly revised in the future. */ - implicit val higherKinds: higherKinds = ??? + implicit lazy val higherKinds: higherKinds = ??? /** Only where enabled, existential types that cannot be expressed as wildcard * types can be written and are allowed in inferred types of values or return @@ -102,7 +102,7 @@ object language { * is generally perceived not to be a good idea. Also, complicated existential types * might be no longer supported in a future simplification of the language. */ - implicit val existentials: existentials = ??? + implicit lazy val existentials: existentials = ??? object experimental { @@ -119,6 +119,6 @@ object language { * _Why control it?_ For their very power, macros can lead to code that is hard * to debug and understand. */ - implicit val macros: macros = ??? + implicit lazy val macros: macros = ??? } } diff --git a/src/library/scala/math/Numeric.scala b/src/library/scala/math/Numeric.scala index 1f4e3c9865..ee62706e49 100644 --- a/src/library/scala/math/Numeric.scala +++ b/src/library/scala/math/Numeric.scala @@ -36,8 +36,8 @@ object Numeric { def fromInt(x: Int): BigInt = BigInt(x) def toInt(x: BigInt): Int = x.intValue def toLong(x: BigInt): Long = x.longValue - def toFloat(x: BigInt): Float = x.longValue.toFloat - def toDouble(x: BigInt): Double = x.longValue.toDouble + def toFloat(x: BigInt): Float = x.floatValue + def toDouble(x: BigInt): Double = x.doubleValue } implicit object BigIntIsIntegral extends BigIntIsIntegral with Ordering.BigIntOrdering diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala index 1ef1911fd3..e3890d7a9d 100644 --- a/src/library/scala/package.scala +++ b/src/library/scala/package.scala @@ -6,7 +6,6 @@ ** |/ ** \* */ -import annotation.bridge /** * Core Scala types. They are always available without an explicit import. @@ -80,15 +79,6 @@ package object scala { type Range = scala.collection.immutable.Range val Range = scala.collection.immutable.Range - // Migrated from Predef - @deprecated("Use Thread.currentThread instead", "2.9.0") - def currentThread = java.lang.Thread.currentThread() - - // Moved back into Predef to avoid unnecessary indirection by - // way of the scala package object within the standard library, - // but bridged for compatibility. - @bridge def $scope = scala.xml.TopScope - // Numeric types which were moved into scala.math.* type BigDecimal = scala.math.BigDecimal @@ -132,13 +122,4 @@ package object scala { type unchecked = annotation.unchecked.unchecked type volatile = annotation.volatile */ - - @deprecated("use scala.annotation.Annotation instead", "2.9.0") - type Annotation = scala.annotation.Annotation - @deprecated("use scala.annotation.ClassfileAnnotation instead", "2.9.0") - type ClassfileAnnotation = scala.annotation.ClassfileAnnotation - @deprecated("use scala.annotation.StaticAnnotation instead", "2.9.0") - type StaticAnnotation = scala.annotation.StaticAnnotation - @deprecated("use scala.annotation.TypeConstraint instead", "2.9.0") - type TypeConstraint = scala.annotation.TypeConstraint } diff --git a/src/library/scala/reflect/ArrayTag.scala b/src/library/scala/reflect/ArrayTag.scala index 8df7fe5f4e..ba0c075723 100644 --- a/src/library/scala/reflect/ArrayTag.scala +++ b/src/library/scala/reflect/ArrayTag.scala @@ -3,11 +3,17 @@ package scala.reflect /** An `ArrayTag[T]` is a descriptor that is requested by the compiler every time * when an array is instantiated, but the element type is unknown at compile time. * + * Implicit in the contract of `ArrayTag[T]` is the fact that `T` + * cannot contain unresolved references to type parameters or abstract types. + * * Scala library provides a standard implementation of this trait, - * `ClassTag[T]` that explicitly carries the `java.lang.Class` erasure of type T. + * `ClassTag[T]` that explicitly carries the `java.lang.Class` erasure of type T + * and uses Java reflection to instantiate arrays. * * However other platforms (e.g. a Scala -> JS crosscompiler) may reimplement this trait as they see fit * and then expose the implementation via an implicit macro. + * + * @see [[scala.reflect.api.TypeTags]] */ @annotation.implicitNotFound(msg = "No ArrayTag available for ${T}") trait ArrayTag[T] { diff --git a/src/library/scala/reflect/ClassManifest.scala b/src/library/scala/reflect/ClassManifest.scala new file mode 100644 index 0000000000..43e043fd40 --- /dev/null +++ b/src/library/scala/reflect/ClassManifest.scala @@ -0,0 +1,242 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2007-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.reflect + +import scala.collection.mutable.{ WrappedArray, ArrayBuilder } +import java.lang.{ Class => jClass } + +/** A `ClassManifest[T]` is an opaque descriptor for type `T`. + * It is used by the compiler to preserve information necessary + * for instantiating `Arrays` in those cases where the element type + * is unknown at compile time. + * + * The type-relation operators make an effort to present a more accurate + * picture than can be realized with erased types, but they should not be + * relied upon to give correct answers. In particular they are likely to + * be wrong when variance is involved or when a subtype has a different + * number of type arguments than a supertype. + */ +@deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0") +trait ClassManifest[T] extends OptManifest[T] with ClassTag[T] with Equals with Serializable { + /** A class representing the type `U` to which `T` would be erased. Note + * that there is no subtyping relationship between `T` and `U`. */ + def erasure: jClass[_] + + private def subtype(sub: jClass[_], sup: jClass[_]): Boolean = { + def loop(left: Set[jClass[_]], seen: Set[jClass[_]]): Boolean = { + left.nonEmpty && { + val next = left.head + val supers = next.getInterfaces.toSet ++ Option(next.getSuperclass) + supers(sup) || { + val xs = left ++ supers filterNot seen + loop(xs - next, seen + next) + } + } + } + loop(Set(sub), Set()) + } + + private def subargs(args1: List[OptManifest[_]], args2: List[OptManifest[_]]) = (args1 corresponds args2) { + // !!! [Martin] this is wrong, need to take variance into account + case (x: ClassManifest[_], y: ClassManifest[_]) => x <:< y + case (x, y) => (x eq NoManifest) && (y eq NoManifest) + } + + /** Tests whether the type represented by this manifest is a subtype + * of the type represented by `that` manifest, subject to the limitations + * described in the header. + */ + def <:<(that: ClassManifest[_]): Boolean = { + // All types which could conform to these types will override <:<. + def cannotMatch = { + import Manifest._ + that.isInstanceOf[AnyValManifest[_]] || (that eq AnyVal) || (that eq Nothing) || (that eq Null) + } + + // This is wrong, and I don't know how it can be made right + // without more development of Manifests, due to arity-defying + // relationships like: + // + // List[String] <: AnyRef + // Map[Int, Int] <: Iterable[(Int, Int)] + // + // Given the manifest for Map[A, B] how do I determine that a + // supertype has single type argument (A, B) ? I don't see how we + // can say whether X <:< Y when type arguments are involved except + // when the erasure is the same, even before considering variance. + !cannotMatch && { + // this part is wrong for not considering variance + if (this.erasure == that.erasure) + subargs(this.typeArguments, that.typeArguments) + // this part is wrong for punting unless the rhs has no type + // arguments, but it's better than a blindfolded pinata swing. + else + that.typeArguments.isEmpty && subtype(this.erasure, that.erasure) + } + } + + /** Tests whether the type represented by this manifest is a supertype + * of the type represented by `that` manifest, subject to the limitations + * described in the header. + */ + def >:>(that: ClassManifest[_]): Boolean = + that <:< this + + override def canEqual(other: Any) = other match { + case _: ClassManifest[_] => true + case _ => false + } + + /** Tests whether the type represented by this manifest is equal to + * the type represented by `that` manifest, subject to the limitations + * described in the header. + */ + override def equals(that: Any): Boolean = that match { + case m: ClassManifest[_] => (m canEqual this) && (this.erasure == m.erasure) + case _ => false + } + override def hashCode = this.erasure.## + + protected def arrayClass[T](tp: jClass[_]): jClass[Array[T]] = + java.lang.reflect.Array.newInstance(tp, 0).getClass.asInstanceOf[jClass[Array[T]]] + + def arrayManifest: ClassManifest[Array[T]] = + ClassManifest.classType[Array[T]](arrayClass[T](erasure), this) + + override def newArray(len: Int): Array[T] = + java.lang.reflect.Array.newInstance(erasure, len).asInstanceOf[Array[T]] + + def newArray2(len: Int): Array[Array[T]] = + java.lang.reflect.Array.newInstance(arrayClass[T](erasure), len) + .asInstanceOf[Array[Array[T]]] + + def newArray3(len: Int): Array[Array[Array[T]]] = + java.lang.reflect.Array.newInstance(arrayClass[Array[T]](arrayClass[T](erasure)), len) + .asInstanceOf[Array[Array[Array[T]]]] + + def newArray4(len: Int): Array[Array[Array[Array[T]]]] = + java.lang.reflect.Array.newInstance(arrayClass[Array[Array[T]]](arrayClass[Array[T]](arrayClass[T](erasure))), len) + .asInstanceOf[Array[Array[Array[Array[T]]]]] + + def newArray5(len: Int): Array[Array[Array[Array[Array[T]]]]] = + java.lang.reflect.Array.newInstance(arrayClass[Array[Array[Array[T]]]](arrayClass[Array[Array[T]]](arrayClass[Array[T]](arrayClass[T](erasure)))), len) + .asInstanceOf[Array[Array[Array[Array[Array[T]]]]]] + + def newWrappedArray(len: Int): WrappedArray[T] = + // it's safe to assume T <: AnyRef here because the method is overridden for all value type manifests + new WrappedArray.ofRef[T with AnyRef](newArray(len).asInstanceOf[Array[T with AnyRef]]).asInstanceOf[WrappedArray[T]] + + def newArrayBuilder(): ArrayBuilder[T] = + // it's safe to assume T <: AnyRef here because the method is overridden for all value type manifests + new ArrayBuilder.ofRef[T with AnyRef]()(this.asInstanceOf[ClassManifest[T with AnyRef]]).asInstanceOf[ArrayBuilder[T]] + + def typeArguments: List[OptManifest[_]] = List() + + protected def argString = + if (typeArguments.nonEmpty) typeArguments.mkString("[", ", ", "]") + else if (erasure.isArray) "["+ClassManifest.fromClass(erasure.getComponentType)+"]" + else "" +} + +/** The object `ClassManifest` defines factory methods for manifests. + * It is intended for use by the compiler and should not be used in client code. + */ +@deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0") +object ClassManifest { + val Byte = Manifest.Byte + val Short = Manifest.Short + val Char = Manifest.Char + val Int = Manifest.Int + val Long = Manifest.Long + val Float = Manifest.Float + val Double = Manifest.Double + val Boolean = Manifest.Boolean + val Unit = Manifest.Unit + val Any = Manifest.Any + val Object = Manifest.Object + val AnyVal = Manifest.AnyVal + val Nothing = Manifest.Nothing + val Null = Manifest.Null + + def fromClass[T](clazz: jClass[T]): ClassManifest[T] = clazz match { + case java.lang.Byte.TYPE => Byte.asInstanceOf[ClassManifest[T]] + case java.lang.Short.TYPE => Short.asInstanceOf[ClassManifest[T]] + case java.lang.Character.TYPE => Char.asInstanceOf[ClassManifest[T]] + case java.lang.Integer.TYPE => Int.asInstanceOf[ClassManifest[T]] + case java.lang.Long.TYPE => Long.asInstanceOf[ClassManifest[T]] + case java.lang.Float.TYPE => Float.asInstanceOf[ClassManifest[T]] + case java.lang.Double.TYPE => Double.asInstanceOf[ClassManifest[T]] + case java.lang.Boolean.TYPE => Boolean.asInstanceOf[ClassManifest[T]] + case java.lang.Void.TYPE => Unit.asInstanceOf[ClassManifest[T]] + case _ => classType[T with AnyRef](clazz).asInstanceOf[ClassManifest[T]] + } + + def singleType[T <: AnyRef](value: AnyRef): Manifest[T] = Manifest.singleType(value) + + /** ClassManifest for the class type `clazz`, where `clazz` is + * a top-level or static class. + * @note This no-prefix, no-arguments case is separate because we + * it's called from ScalaRunTime.boxArray itself. If we + * pass varargs as arrays into this, we get an infinitely recursive call + * to boxArray. (Besides, having a separate case is more efficient) + */ + def classType[T <: AnyRef](clazz: jClass[_]): ClassManifest[T] = + new ClassTypeManifest[T](None, clazz, Nil) + + /** ClassManifest for the class type `clazz[args]`, where `clazz` is + * a top-level or static class and `args` are its type arguments */ + def classType[T <: AnyRef](clazz: jClass[_], arg1: OptManifest[_], args: OptManifest[_]*): ClassManifest[T] = + new ClassTypeManifest[T](None, clazz, arg1 :: args.toList) + + /** ClassManifest for the class type `clazz[args]`, where `clazz` is + * a class with non-package prefix type `prefix` and type arguments `args`. + */ + def classType[T <: AnyRef](prefix: OptManifest[_], clazz: jClass[_], args: OptManifest[_]*): ClassManifest[T] = + new ClassTypeManifest[T](Some(prefix), clazz, args.toList) + + def arrayType[T](arg: OptManifest[_]): ClassManifest[Array[T]] = arg match { + case NoManifest => Object.asInstanceOf[ClassManifest[Array[T]]] + case m: ClassManifest[_] => m.asInstanceOf[ClassManifest[T]].arrayManifest + } + + /** ClassManifest for the abstract type `prefix # name`. `upperBound` is not + * strictly necessary as it could be obtained by reflection. It was + * added so that erasure can be calculated without reflection. */ + def abstractType[T](prefix: OptManifest[_], name: String, clazz: jClass[_], args: OptManifest[_]*): ClassManifest[T] = + new ClassManifest[T] { + def erasure = clazz + override val typeArguments = args.toList + override def toString = prefix.toString+"#"+name+argString + } + + /** ClassManifest for the abstract type `prefix # name`. `upperBound` is not + * strictly necessary as it could be obtained by reflection. It was + * added so that erasure can be calculated without reflection. + * todo: remove after next boostrap + */ + def abstractType[T](prefix: OptManifest[_], name: String, upperbound: ClassManifest[_], args: OptManifest[_]*): ClassManifest[T] = + new ClassManifest[T] { + def erasure = upperbound.erasure + override val typeArguments = args.toList + override def toString = prefix.toString+"#"+name+argString + } +} + +/** Manifest for the class type `clazz[args]`, where `clazz` is + * a top-level or static class */ +private class ClassTypeManifest[T <: AnyRef]( + prefix: Option[OptManifest[_]], + val erasure: jClass[_], + override val typeArguments: List[OptManifest[_]]) extends ClassManifest[T] +{ + override def toString = + (if (prefix.isEmpty) "" else prefix.get.toString+"#") + + (if (erasure.isArray) "Array" else erasure.getName) + + argString +}
\ No newline at end of file diff --git a/src/library/scala/reflect/ClassTag.scala b/src/library/scala/reflect/ClassTag.scala index 7138837f0d..e485691747 100644 --- a/src/library/scala/reflect/ClassTag.scala +++ b/src/library/scala/reflect/ClassTag.scala @@ -3,6 +3,7 @@ package scala.reflect import java.lang.{ Class => jClass } import scala.reflect.{ mirror => rm } import language.{implicitConversions, existentials} +import scala.runtime.ScalaRunTime.arrayClass /** A `ClassTag[T]` wraps a Java class, which can be accessed via the `erasure` method. * @@ -18,30 +19,17 @@ import language.{implicitConversions, existentials} * If the type T contains unresolved references to type parameters or abstract types, a static error results. * * A ConcreteTypeTag member of the reflect.mirror object is convertible to a ClassTag via an implicit conversion - * (this is not possible to do in all reflection universes because an operation that converts a type to a Java class might not be available). */ -// please, don't add any APIs here, like it was with `newWrappedArray` and `newArrayBuilder` -// class tags, and all tags in general, should be as minimalistic as possible + * (this is not possible to do in all reflection universes because an operation that converts a type to a Java class might not be available). + * + * @see [[scala.reflect.api.TypeTags]] + */ @annotation.implicitNotFound(msg = "No ClassTag available for ${T}") -abstract case class ClassTag[T](erasure: jClass[_]) extends ArrayTag[T] { - // quick and dirty fix to a deadlock in Predef: - // http://groups.google.com/group/scala-internals/browse_thread/thread/977de028a4e75d6f - // todo. fix that in a sane way - // assert(erasure != null) - - /** A Scala reflection type representing T. - * For ClassTags this representation is lossy (in their case tpe is retrospectively constructed from erasure). - * For TypeTags and ConcreteTypeTags the representation is almost precise, because they use reification - * (information is lost only when T refers to non-locatable symbols, which are then reified as free variables). */ - def tpe: rm.Type = rm.classToType(erasure) - - /** A Scala reflection symbol representing T. */ - def symbol: rm.Symbol = rm.classToSymbol(erasure) +trait ClassTag[T] extends ArrayTag[T] with ErasureTag[T] with Equals with Serializable { + // please, don't add any APIs here, like it was with `newWrappedArray` and `newArrayBuilder` + // class tags, and all tags in general, should be as minimalistic as possible /** Produces a `ClassTag` that knows how to build `Array[Array[T]]` */ - def wrap: ClassTag[Array[T]] = { - val arrayClazz = java.lang.reflect.Array.newInstance(erasure, 0).getClass.asInstanceOf[jClass[Array[T]]] - ClassTag[Array[T]](arrayClazz) - } + def wrap: ClassTag[Array[T]] = ClassTag[Array[T]](arrayClass(erasure)) /** Produces a new array with element type `T` and length `len` */ def newArray(len: Int): Array[T] = @@ -57,31 +45,39 @@ abstract case class ClassTag[T](erasure: jClass[_]) extends ArrayTag[T] { case java.lang.Void.TYPE => new Array[Unit](len).asInstanceOf[Array[T]] case _ => java.lang.reflect.Array.newInstance(erasure, len).asInstanceOf[Array[T]] } + + /** case class accessories */ + override def canEqual(x: Any) = x.isInstanceOf[ClassTag[_]] + override def equals(x: Any) = x.isInstanceOf[ClassTag[_]] && this.erasure == x.asInstanceOf[ClassTag[_]].erasure + override def hashCode = scala.runtime.ScalaRunTime.hash(erasure) + override def toString = "ClassTag[" + erasure + "]" } object ClassTag { + private val NothingTYPE = classOf[scala.runtime.Nothing$] + private val NullTYPE = classOf[scala.runtime.Null$] private val ObjectTYPE = classOf[java.lang.Object] private val StringTYPE = classOf[java.lang.String] - val Byte : ClassTag[scala.Byte] = new ClassTag[scala.Byte](java.lang.Byte.TYPE) { private def readResolve() = ClassTag.Byte } - val Short : ClassTag[scala.Short] = new ClassTag[scala.Short](java.lang.Short.TYPE) { private def readResolve() = ClassTag.Short } - val Char : ClassTag[scala.Char] = new ClassTag[scala.Char](java.lang.Character.TYPE) { private def readResolve() = ClassTag.Char } - val Int : ClassTag[scala.Int] = new ClassTag[scala.Int](java.lang.Integer.TYPE) { private def readResolve() = ClassTag.Int } - val Long : ClassTag[scala.Long] = new ClassTag[scala.Long](java.lang.Long.TYPE) { private def readResolve() = ClassTag.Long } - val Float : ClassTag[scala.Float] = new ClassTag[scala.Float](java.lang.Float.TYPE) { private def readResolve() = ClassTag.Float } - val Double : ClassTag[scala.Double] = new ClassTag[scala.Double](java.lang.Double.TYPE) { private def readResolve() = ClassTag.Double } - val Boolean : ClassTag[scala.Boolean] = new ClassTag[scala.Boolean](java.lang.Boolean.TYPE) { private def readResolve() = ClassTag.Boolean } - val Unit : ClassTag[scala.Unit] = new ClassTag[scala.Unit](java.lang.Void.TYPE) { private def readResolve() = ClassTag.Unit } - val Any : ClassTag[scala.Any] = new ClassTag[scala.Any](ObjectTYPE) { private def readResolve() = ClassTag.Any } - val Object : ClassTag[java.lang.Object] = new ClassTag[java.lang.Object](ObjectTYPE) { private def readResolve() = ClassTag.Object } - val AnyVal : ClassTag[scala.AnyVal] = new ClassTag[scala.AnyVal](ObjectTYPE) { private def readResolve() = ClassTag.AnyVal } - val AnyRef : ClassTag[scala.AnyRef] = new ClassTag[scala.AnyRef](ObjectTYPE) { private def readResolve() = ClassTag.AnyRef } - val Nothing : ClassTag[scala.Nothing] = new ClassTag[scala.Nothing](ObjectTYPE) { private def readResolve() = ClassTag.Nothing } - val Null : ClassTag[scala.Null] = new ClassTag[scala.Null](ObjectTYPE) { private def readResolve() = ClassTag.Null } - val String : ClassTag[java.lang.String] = new ClassTag[java.lang.String](StringTYPE) { private def readResolve() = ClassTag.String } - - def apply[T](clazz: jClass[_]): ClassTag[T] = - clazz match { + val Byte : ClassTag[scala.Byte] = new ClassTag[scala.Byte]{ def erasure = java.lang.Byte.TYPE; private def readResolve() = ClassTag.Byte } + val Short : ClassTag[scala.Short] = new ClassTag[scala.Short]{ def erasure = java.lang.Short.TYPE; private def readResolve() = ClassTag.Short } + val Char : ClassTag[scala.Char] = new ClassTag[scala.Char]{ def erasure = java.lang.Character.TYPE; private def readResolve() = ClassTag.Char } + val Int : ClassTag[scala.Int] = new ClassTag[scala.Int]{ def erasure = java.lang.Integer.TYPE; private def readResolve() = ClassTag.Int } + val Long : ClassTag[scala.Long] = new ClassTag[scala.Long]{ def erasure = java.lang.Long.TYPE; private def readResolve() = ClassTag.Long } + val Float : ClassTag[scala.Float] = new ClassTag[scala.Float]{ def erasure = java.lang.Float.TYPE; private def readResolve() = ClassTag.Float } + val Double : ClassTag[scala.Double] = new ClassTag[scala.Double]{ def erasure = java.lang.Double.TYPE; private def readResolve() = ClassTag.Double } + val Boolean : ClassTag[scala.Boolean] = new ClassTag[scala.Boolean]{ def erasure = java.lang.Boolean.TYPE; private def readResolve() = ClassTag.Boolean } + val Unit : ClassTag[scala.Unit] = new ClassTag[scala.Unit]{ def erasure = java.lang.Void.TYPE; private def readResolve() = ClassTag.Unit } + val Any : ClassTag[scala.Any] = new ClassTag[scala.Any]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.Any } + val Object : ClassTag[java.lang.Object] = new ClassTag[java.lang.Object]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.Object } + val AnyVal : ClassTag[scala.AnyVal] = new ClassTag[scala.AnyVal]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.AnyVal } + val AnyRef : ClassTag[scala.AnyRef] = new ClassTag[scala.AnyRef]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.AnyRef } + val Nothing : ClassTag[scala.Nothing] = new ClassTag[scala.Nothing]{ def erasure = NothingTYPE; private def readResolve() = ClassTag.Nothing } + val Null : ClassTag[scala.Null] = new ClassTag[scala.Null]{ def erasure = NullTYPE; private def readResolve() = ClassTag.Null } + val String : ClassTag[java.lang.String] = new ClassTag[java.lang.String]{ def erasure = StringTYPE; private def readResolve() = ClassTag.String } + + def apply[T](erasure1: jClass[_]): ClassTag[T] = + erasure1 match { case java.lang.Byte.TYPE => ClassTag.Byte.asInstanceOf[ClassTag[T]] case java.lang.Short.TYPE => ClassTag.Short.asInstanceOf[ClassTag[T]] case java.lang.Character.TYPE => ClassTag.Char.asInstanceOf[ClassTag[T]] @@ -93,76 +89,8 @@ object ClassTag { case java.lang.Void.TYPE => ClassTag.Unit.asInstanceOf[ClassTag[T]] case ObjectTYPE => ClassTag.Object.asInstanceOf[ClassTag[T]] case StringTYPE => ClassTag.String.asInstanceOf[ClassTag[T]] - case _ => new ClassTag[T](clazz) {} + case _ => new ClassTag[T]{ def erasure = erasure1 } } - def apply[T](tpe: rm.Type): ClassTag[T] = - tpe match { - case rm.ByteTpe => ClassTag.Byte.asInstanceOf[ClassTag[T]] - case rm.ShortTpe => ClassTag.Short.asInstanceOf[ClassTag[T]] - case rm.CharTpe => ClassTag.Char.asInstanceOf[ClassTag[T]] - case rm.IntTpe => ClassTag.Int.asInstanceOf[ClassTag[T]] - case rm.LongTpe => ClassTag.Long.asInstanceOf[ClassTag[T]] - case rm.FloatTpe => ClassTag.Float.asInstanceOf[ClassTag[T]] - case rm.DoubleTpe => ClassTag.Double.asInstanceOf[ClassTag[T]] - case rm.BooleanTpe => ClassTag.Boolean.asInstanceOf[ClassTag[T]] - case rm.UnitTpe => ClassTag.Unit.asInstanceOf[ClassTag[T]] - case rm.AnyTpe => ClassTag.Any.asInstanceOf[ClassTag[T]] - case rm.ObjectTpe => ClassTag.Object.asInstanceOf[ClassTag[T]] - case rm.AnyValTpe => ClassTag.AnyVal.asInstanceOf[ClassTag[T]] - case rm.AnyRefTpe => ClassTag.AnyRef.asInstanceOf[ClassTag[T]] - case rm.NothingTpe => ClassTag.Nothing.asInstanceOf[ClassTag[T]] - case rm.NullTpe => ClassTag.Null.asInstanceOf[ClassTag[T]] - case rm.StringTpe => ClassTag.String.asInstanceOf[ClassTag[T]] - case _ => apply[T](rm.typeToClass(tpe.erasure)) - } - - implicit def toDeprecatedClassManifestApis[T](ctag: ClassTag[T]): DeprecatedClassManifestApis[T] = new DeprecatedClassManifestApis[T](ctag) -} - -// this class should not be used directly in client code -class DeprecatedClassManifestApis[T](ctag: ClassTag[T]) { - import scala.collection.mutable.{ WrappedArray, ArrayBuilder } - - @deprecated("Use `tpe` to analyze the underlying type", "2.10.0") - def <:<(that: ClassManifest[_]): Boolean = ctag.tpe <:< that.tpe - - @deprecated("Use `tpe` to analyze the underlying type", "2.10.0") - def >:>(that: ClassManifest[_]): Boolean = that <:< ctag - - @deprecated("Use `wrap` instead", "2.10.0") - def arrayManifest: ClassManifest[Array[T]] = ctag.wrap - - @deprecated("Use a combination of `wrap` and `newArray` instead", "2.10.0") - def newArray2(len: Int): Array[Array[T]] = ctag.wrap.newArray(len) - - @deprecated("Use a combination of `wrap` and `newArray` instead", "2.10.0") - def newArray3(len: Int): Array[Array[Array[T]]] = ctag.wrap.wrap.newArray(len) - - @deprecated("Use a combination of `wrap` and `newArray` instead", "2.10.0") - def newArray4(len: Int): Array[Array[Array[Array[T]]]] = ctag.wrap.wrap.wrap.newArray(len) - - @deprecated("Use a combination of `wrap` and `newArray` instead", "2.10.0") - def newArray5(len: Int): Array[Array[Array[Array[Array[T]]]]] = ctag.wrap.wrap.wrap.wrap.newArray(len) - - @deprecated("Use `@scala.collection.mutable.WrappedArray` object instead", "2.10.0") - def newWrappedArray(len: Int): WrappedArray[T] = - ctag.erasure match { - case java.lang.Byte.TYPE => new WrappedArray.ofByte(new Array[Byte](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Short.TYPE => new WrappedArray.ofShort(new Array[Short](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Character.TYPE => new WrappedArray.ofChar(new Array[Char](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Integer.TYPE => new WrappedArray.ofInt(new Array[Int](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Long.TYPE => new WrappedArray.ofLong(new Array[Long](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Float.TYPE => new WrappedArray.ofFloat(new Array[Float](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Double.TYPE => new WrappedArray.ofDouble(new Array[Double](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Boolean.TYPE => new WrappedArray.ofBoolean(new Array[Boolean](len)).asInstanceOf[WrappedArray[T]] - case java.lang.Void.TYPE => new WrappedArray.ofUnit(new Array[Unit](len)).asInstanceOf[WrappedArray[T]] - case _ => new WrappedArray.ofRef[T with AnyRef](ctag.newArray(len).asInstanceOf[Array[T with AnyRef]]).asInstanceOf[WrappedArray[T]] - } - - @deprecated("Use `@scala.collection.mutable.ArrayBuilder` object instead", "2.10.0") - def newArrayBuilder(): ArrayBuilder[T] = ArrayBuilder.make[T]()(ctag) - - @deprecated("`typeArguments` is no longer supported, and will always return an empty list. Use `@scala.reflect.TypeTag` or `@scala.reflect.ConcreteTypeTag` to capture and analyze type arguments", "2.10.0") - def typeArguments: List[OptManifest[_]] = List() -} + def unapply[T](ctag: ClassTag[T]): Option[Class[_]] = Some(ctag.erasure) +}
\ No newline at end of file diff --git a/src/library/scala/reflect/DummyMirror.scala b/src/library/scala/reflect/DummyMirror.scala new file mode 100644 index 0000000000..422598caef --- /dev/null +++ b/src/library/scala/reflect/DummyMirror.scala @@ -0,0 +1,784 @@ +package scala.reflect + +import scala.reflect.api.AbsTreeGen +import scala.reflect.api.Attachment +import scala.reflect.api.Modifier +import scala.reflect.api.Universe + +// todo. make Dummy objects not equal to themselves +class DummyMirror(cl: ClassLoader) extends api.Mirror { + // Members declared in scala.reflect.api.AnnotationInfos + implicit def classfileAnnotArgTag: scala.reflect.ClassTag[ClassfileAnnotArg] = notSupported() + type AnnotationInfo = DummyAnnotationInfo.type + object DummyAnnotationInfo + val AnnotationInfo: AnnotationInfoExtractor = DummyAnnotationInfoExtractor + object DummyAnnotationInfoExtractor extends AnnotationInfoExtractor { + def apply(atp: Type, args: List[Tree], assocs: List[(Name, ClassfileAnnotArg)]): AnnotationInfo = DummyAnnotationInfo + def unapply(info: AnnotationInfo): Option[(Type, List[Tree], List[(Name, ClassfileAnnotArg)])] = notSupported() + } + type ClassfileAnnotArg = AnyRef + type LiteralAnnotArg = DummyLiteralAnnotArg.type + object DummyLiteralAnnotArg + val LiteralAnnotArg: LiteralAnnotArgExtractor = DummyLiteralAnnotArgExtractor + type ArrayAnnotArg = DummyArrayAnnotArg.type + object DummyArrayAnnotArg + val ArrayAnnotArg: ArrayAnnotArgExtractor = DummyArrayAnnotArgExtractor + type NestedAnnotArg = DummyNestedAnnotArg.type + object DummyNestedAnnotArg + val NestedAnnotArg: NestedAnnotArgExtractor = DummyNestedAnnotArgExtractor + object DummyLiteralAnnotArgExtractor extends LiteralAnnotArgExtractor { + def apply(const: Constant): LiteralAnnotArg = DummyLiteralAnnotArg + def unapply(arg: LiteralAnnotArg): Option[Constant] = notSupported() + } + object DummyArrayAnnotArgExtractor extends ArrayAnnotArgExtractor { + def apply(const: Array[ClassfileAnnotArg]): ArrayAnnotArg = DummyArrayAnnotArg + def unapply(arg: ArrayAnnotArg): Option[Array[ClassfileAnnotArg]] = notSupported() + } + object DummyNestedAnnotArgExtractor extends NestedAnnotArgExtractor { + def apply(anninfo: AnnotationInfo): NestedAnnotArg = DummyNestedAnnotArg + def unapply(arg: NestedAnnotArg): Option[AnnotationInfo] = notSupported() + } + + // Members declared in scala.reflect.api.Constants + type Constant = DummyConstant.type + object DummyConstant extends AbsConstant { + val value: Any = notSupported() + def tpe: Type = notSupported() + def isNaN: Boolean = notSupported() + def booleanValue: Boolean = notSupported() + def byteValue: Byte = notSupported() + def shortValue: Short = notSupported() + def charValue: Char = notSupported() + def intValue: Int = notSupported() + def longValue: Long = notSupported() + def floatValue: Float = notSupported() + def doubleValue: Double = notSupported() + def stringValue: String = notSupported() + def typeValue: Type = notSupported() + def symbolValue: Symbol = notSupported() + def convertTo(pt: Type): Constant = notSupported() + } + val Constant: ConstantExtractor = DummyConstantExtractor + object DummyConstantExtractor extends ConstantExtractor { + def apply(const: Any): Constant = DummyConstant + def unapply(arg: Constant): Option[Any] = notSupported() + } + + // Members declared in scala.reflect.api.FreeVars + type FreeTerm = DummyFreeTerm.type + val DummyFreeTerm = DummySymbol + val FreeTerm: FreeTermExtractor = DummyFreeTermExtractor + object DummyFreeTermExtractor extends FreeTermExtractor { + def unapply(freeTerm: FreeTerm): Option[(TermName, Type, Any, String)] = notSupported() + } + type FreeType = DummyFreeType.type + val DummyFreeType = DummySymbol + val FreeType: FreeTypeExtractor = DummyFreeTypeExtractor + object DummyFreeTypeExtractor extends FreeTypeExtractor { + def unapply(freeType: FreeType): Option[(TypeName, Type, String)] = notSupported() + } + def freeTerms(tree: Tree): List[FreeTerm] = notSupported() + def freeTypes(tree: Tree): List[FreeType] = notSupported() + def substituteFreeTypes(tpe: Type,subs: Map[FreeType,Type]): Type = notSupported() + def substituteFreeTypes(tree: Tree,subs: Map[FreeType,Type]): Tree = notSupported() + + // Members declared in scala.reflect.api.Importers + def mkImporter(from0: scala.reflect.api.Universe): Importer{val from: from0.type} = notSupported() + + // Members declared in scala.reflect.api.Mirror + def classLoader: ClassLoader = cl + def classLoader_=(x$1: ClassLoader): Unit = notSupported() + def classToSymbol(clazz: Class[_]): Symbol = notSupported() + def classToType(clazz: Class[_]): Type = notSupported() + def companionInstance(clazz: Symbol): AnyRef = notSupported() + def getValueOfField(receiver: AnyRef,field: Symbol): Any = notSupported() + def invoke(receiver: AnyRef,meth: Symbol)(args: Any*): Any = notSupported() + def setValueOfField(receiver: AnyRef,field: Symbol,value: Any): Unit = notSupported() + def symbolForName(name: String): Symbol = notSupported() + def symbolOfInstance(instance: Any): Symbol = notSupported() + def symbolToClass(sym: Symbol): Class[_] = notSupported() + def typeOfInstance(instance: Any): Type = notSupported() + def typeToClass(tpe: Type): Class[_] = notSupported() + + // Members declared in scala.reflect.api.Names + type Name = DummyName.type + type TypeName = DummyName.type + type TermName = DummyName.type + object DummyName extends AbsName { + def isTermName: Boolean = notSupported() + def isTypeName: Boolean = notSupported() + def toTermName: TermName = notSupported() + def toTypeName: TypeName = notSupported() + def decoded: String = notSupported() + def encoded: String = notSupported() + def decodedName: Name = notSupported() + def encodedName: Name = notSupported() + } + def newTermName(s: String): TermName = notSupported() + def newTypeName(s: String): TypeName = notSupported() + + // Members declared in scala.reflect.api.Positions + type Position = DummyPosition.type + object DummyPosition extends api.Position { + def pos: Position = notSupported() + def withPos(newPos: scala.reflect.api.Position): Attachment = notSupported() + def payload: Any = notSupported() + def withPayload(newPayload: Any): Attachment = notSupported() + def fileInfo: java.io.File = notSupported() + def fileContent: Array[Char] = notSupported() + def isDefined: Boolean = notSupported() + def isTransparent: Boolean = notSupported() + def isRange: Boolean = notSupported() + def isOpaqueRange: Boolean = notSupported() + def makeTransparent: Position = notSupported() + def start: Int = notSupported() + def startOrPoint: Int = notSupported() + def point: Int = notSupported() + def pointOrElse(default: Int): Int = notSupported() + def end: Int = notSupported() + def endOrPoint: Int = notSupported() + def withStart(off: Int): Position = notSupported() + def withEnd(off: Int): Position = notSupported() + def withPoint(off: Int): Position = notSupported() + def union(pos: scala.reflect.api.Position): Position = notSupported() + def focusStart: Position = notSupported() + def focus: Position = notSupported() + def focusEnd: Position = notSupported() + def includes(pos: scala.reflect.api.Position): Boolean = notSupported() + def properlyIncludes(pos: scala.reflect.api.Position): Boolean = notSupported() + def precedes(pos: scala.reflect.api.Position): Boolean = notSupported() + def properlyPrecedes(pos: scala.reflect.api.Position): Boolean = notSupported() + def overlaps(pos: scala.reflect.api.Position): Boolean = notSupported() + def sameRange(pos: scala.reflect.api.Position): Boolean = notSupported() + def line: Int = notSupported() + def column: Int = notSupported() + def toSingleLine: Position = notSupported() + def lineContent: String = notSupported() + def show: String = notSupported() + } + val NoPosition: Position = DummyPosition + def atPos[T <: Tree](pos: Position)(tree: T): T = tree + def ensureNonOverlapping(tree: Tree,others: List[Tree]): Unit = notSupported() + def wrappingPos(trees: List[Tree]): Position = notSupported() + def wrappingPos(default: Position,trees: List[Tree]): Position = notSupported() + + // Members declared in scala.reflect.api.FrontEnds + def mkConsoleFrontEnd(minSeverity: Int): FrontEnd = notSupported() + + // Members declared in scala.reflect.api.Scopes + type Scope = DummyScope.type + object DummyScope extends Iterable[Symbol] { + def iterator: Iterator[Symbol] = notSupported() + } + def newScope: Scope = DummyScope + def newScopeWith(elems: Symbol*): Scope = DummyScope + def newNestedScope(outer: Scope): Scope = DummyScope + + // Members declared in scala.reflect.api.StandardDefinitions + val AnyRefTpe: Type = DummyType + val AnyTpe: Type = DummyType + val AnyValTpe: Type = DummyType + val BooleanTpe: Type = DummyType + val ByteTpe: Type = DummyType + val CharTpe: Type = DummyType + val DoubleTpe: Type = DummyType + val FloatTpe: Type = DummyType + val IntTpe: Type = DummyType + val LongTpe: Type = DummyType + val NothingTpe: Type = DummyType + val NullTpe: Type = DummyType + val ObjectTpe: Type = DummyType + val ShortTpe: Type = DummyType + val StringTpe: Type = DummyType + val UnitTpe: Type = DummyType + val definitions: AbsDefinitions = DummyDefinitions + object DummyDefinitions extends AbsDefinitions { + def ByNameParamClass = DummySymbol + def JavaRepeatedParamClass = DummySymbol + def RepeatedParamClass = DummySymbol + def AnyClass = DummyClassSymbol + def AnyRefClass = DummyTypeSymbol + def AnyValClass = DummyClassSymbol + def ArrayClass = DummyClassSymbol + def ArrayModule = DummySymbol + def ArrayModule_overloadedApply = DummySymbol + def Array_apply = DummySymbol + def Array_clone = DummySymbol + def Array_length = DummySymbol + def Array_update = DummySymbol + def BooleanClass = DummyClassSymbol + def ByteClass = DummyClassSymbol + def CharClass = DummyClassSymbol + def ClassClass = DummyClassSymbol + def ClassTagClass = DummyClassSymbol + def ClassTagModule = DummySymbol + def ConcreteTypeTagClass = DummyClassSymbol + def ConcreteTypeTagModule = DummySymbol + def ConsClass = DummySymbol + def DoubleClass = DummyClassSymbol + def EmptyPackage = DummyPackageSymbol + def EmptyPackageClass = DummySymbol + def FloatClass = DummyClassSymbol + def FunctionClass: Array[Symbol] = Array() + def IntClass = DummyClassSymbol + def IterableClass = DummySymbol + def IteratorClass = DummySymbol + def IteratorModule = DummySymbol + def Iterator_apply = DummySymbol + def JavaLangPackage = DummyPackageSymbol + def JavaLangPackageClass = DummySymbol + def ListClass = DummyClassSymbol + def ListModule = DummyModuleSymbol + def List_apply = DummySymbol + def LongClass = DummyClassSymbol + def NilModule = DummySymbol + def NoneModule = DummySymbol + def NothingClass = DummyClassSymbol + def NullClass = DummyClassSymbol + def ObjectClass = DummyClassSymbol + def OptionClass = DummySymbol + def PredefModule = DummyModuleSymbol + def ProductClass: Array[Symbol] = Array() + def RootClass = DummyClassSymbol + def RootPackage = DummyPackageSymbol + def ScalaPackage = DummyPackageSymbol + def ScalaPackageClass = DummySymbol + def ScalaPrimitiveValueClasses = Nil + def SeqClass = DummySymbol + def SeqModule = DummySymbol + def ShortClass = DummyClassSymbol + def SomeClass = DummySymbol + def SomeModule = DummySymbol + def StringBuilderClass = DummySymbol + def StringClass = DummyClassSymbol + def SymbolClass = DummySymbol + def TraversableClass = DummySymbol + def TupleClass: Array[Symbol] = Array() + def TypeTagClass = DummyClassSymbol + def TypeTagModule = DummySymbol + def UnitClass = DummyClassSymbol + def isNumericValueClass(sym: Symbol): Boolean = notSupported() + def isPrimitiveValueClass(sym: Symbol): Boolean = notSupported() + def vmClassType(arg: Type): Type = DummyType + def vmSignature(sym: Symbol,info: Type): String = notSupported() + } + + // Members declared in scala.reflect.api.StandardNames + val nme: AbsTermNames = DummyAbsTermNames + val tpnme: AbsTypeNames = DummyAbsTypeNames + object DummyAbsTermNames extends AbsTermNames { + type NameType = TermName + val EMPTY: NameType = DummyName + val ANON_FUN_NAME: NameType = DummyName + val ANON_CLASS_NAME: NameType = DummyName + val EMPTY_PACKAGE_NAME: NameType = DummyName + val IMPORT: NameType = DummyName + val MODULE_VAR_SUFFIX: NameType = DummyName + val ROOT: NameType = DummyName + val PACKAGE: NameType = DummyName + val SPECIALIZED_SUFFIX: NameType = DummyName + val ERROR: NameType = DummyName + val NO_NAME: NameType = DummyName + val WILDCARD: NameType = DummyName + def flattenedName(segments: Name*): NameType = notSupported() + val EXPAND_SEPARATOR_STRING: String = "" + val ANYNAME: TermName = DummyName + val CONSTRUCTOR: TermName = DummyName + val FAKE_LOCAL_THIS: TermName = DummyName + val INITIALIZER: TermName = DummyName + val LAZY_LOCAL: TermName = DummyName + val LOCAL_SUFFIX_STRING: String = "" + val MIRROR_PREFIX: TermName = DummyName + val MIRROR_SHORT: TermName = DummyName + val MIRROR_FREE_PREFIX: TermName = DummyName + val MIRROR_FREE_THIS_SUFFIX: TermName = DummyName + val MIRROR_FREE_VALUE_SUFFIX: TermName = DummyName + val MIRROR_SYMDEF_PREFIX: TermName = DummyName + val MIXIN_CONSTRUCTOR: TermName = DummyName + val MODULE_INSTANCE_FIELD: TermName = DummyName + val OUTER: TermName = DummyName + val OUTER_LOCAL: TermName = DummyName + val OUTER_SYNTH: TermName = DummyName + val SELECTOR_DUMMY: TermName = DummyName + val SELF: TermName = DummyName + val SPECIALIZED_INSTANCE: TermName = DummyName + val STAR: TermName = DummyName + val THIS: TermName = DummyName + val BITMAP_NORMAL: TermName = DummyName + val BITMAP_TRANSIENT: TermName = DummyName + val BITMAP_PRIVATE: TermName = DummyName + val BITMAP_CHECKINIT: TermName = DummyName + val BITMAP_CHECKINIT_TRANSIENT: TermName = DummyName + val INTERPRETER_IMPORT_WRAPPER: String = "" + val INTERPRETER_LINE_PREFIX: String = "" + val INTERPRETER_VAR_PREFIX: String = "" + val INTERPRETER_WRAPPER_SUFFIX: String = "" + val ROOTPKG: TermName = DummyName + val ADD: TermName = DummyName + val AND: TermName = DummyName + val ASR: TermName = DummyName + val DIV: TermName = DummyName + val EQ: TermName = DummyName + val EQL: TermName = DummyName + val GE: TermName = DummyName + val GT: TermName = DummyName + val HASHHASH: TermName = DummyName + val LE: TermName = DummyName + val LSL: TermName = DummyName + val LSR: TermName = DummyName + val LT: TermName = DummyName + val MINUS: TermName = DummyName + val MOD: TermName = DummyName + val MUL: TermName = DummyName + val NE: TermName = DummyName + val OR: TermName = DummyName + val PLUS : TermName = DummyName + val SUB: TermName = DummyName + val XOR: TermName = DummyName + val ZAND: TermName = DummyName + val ZOR: TermName = DummyName + val UNARY_~ : TermName = DummyName + val UNARY_+ : TermName = DummyName + val UNARY_- : TermName = DummyName + val UNARY_! : TermName = DummyName + val ??? : TermName = DummyName + val MODULE_SUFFIX_NAME: TermName = DummyName + val NAME_JOIN_NAME: TermName = DummyName + val IMPL_CLASS_SUFFIX: String = "" + val LOCALDUMMY_PREFIX: String = "" + val PROTECTED_PREFIX: String = "" + val PROTECTED_SET_PREFIX: String = "" + val SINGLETON_SUFFIX: String = "" + val SUPER_PREFIX_STRING: String = "" + val TRAIT_SETTER_SEPARATOR_STRING: String = "" + val SETTER_SUFFIX: TermName = DummyName + def isConstructorName(name: Name): Boolean = notSupported() + def isExceptionResultName(name: Name): Boolean = notSupported() + def isImplClassName(name: Name): Boolean = notSupported() + def isLocalDummyName(name: Name): Boolean = notSupported() + def isLocalName(name: Name): Boolean = notSupported() + def isLoopHeaderLabel(name: Name): Boolean = notSupported() + def isProtectedAccessorName(name: Name): Boolean = notSupported() + def isSuperAccessorName(name: Name): Boolean = notSupported() + def isReplWrapperName(name: Name): Boolean = notSupported() + def isSetterName(name: Name): Boolean = notSupported() + def isTraitSetterName(name: Name): Boolean = notSupported() + def isSingletonName(name: Name): Boolean = notSupported() + def isModuleName(name: Name): Boolean = notSupported() + def isOpAssignmentName(name: Name): Boolean = notSupported() + def segments(name: String, assumeTerm: Boolean): List[Name] = notSupported() + def originalName(name: Name): Name = notSupported() + def stripModuleSuffix(name: Name): Name = notSupported() + def unspecializedName(name: Name): Name = notSupported() + def splitSpecializedName(name: Name): (Name, String, String) = notSupported() + def dropLocalSuffix(name: Name): Name = notSupported() + def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName = notSupported() + def expandedSetterName(name: TermName, base: Symbol): TermName = notSupported() + def protName(name: Name): TermName = notSupported() + def protSetterName(name: Name): TermName = notSupported() + def getterName(name: TermName): TermName = notSupported() + def getterToLocal(name: TermName): TermName = notSupported() + def getterToSetter(name: TermName): TermName = notSupported() + def localToGetter(name: TermName): TermName = notSupported() + def setterToGetter(name: TermName): TermName = notSupported() + def defaultGetterName(name: Name, pos: Int): TermName = notSupported() + def defaultGetterToMethod(name: Name): TermName = notSupported() + def localDummyName(clazz: Symbol): TermName = notSupported() + def superName(name: Name): TermName = notSupported() + } + object DummyAbsTypeNames extends AbsTypeNames { + type NameType = TypeName + val EMPTY: NameType = DummyName + val ANON_FUN_NAME: NameType = DummyName + val ANON_CLASS_NAME: NameType = DummyName + val EMPTY_PACKAGE_NAME: NameType = DummyName + val IMPORT: NameType = DummyName + val MODULE_VAR_SUFFIX: NameType = DummyName + val ROOT: NameType = DummyName + val PACKAGE: NameType = DummyName + val SPECIALIZED_SUFFIX: NameType = DummyName + val ERROR: NameType = DummyName + val NO_NAME: NameType = DummyName + val WILDCARD: NameType = DummyName + def flattenedName(segments: Name*): NameType = notSupported() + val REFINE_CLASS_NAME: TypeName = DummyName + val BYNAME_PARAM_CLASS_NAME: TypeName = DummyName + val EQUALS_PATTERN_NAME: TypeName = DummyName + val JAVA_REPEATED_PARAM_CLASS_NAME: TypeName = DummyName + val LOCAL_CHILD: TypeName = DummyName + val REPEATED_PARAM_CLASS_NAME: TypeName = DummyName + val WILDCARD_STAR: TypeName = DummyName + + def dropSingletonName(name: Name): TypeName = notSupported() + def singletonName(name: Name): TypeName = notSupported() + def implClassName(name: Name): TypeName = notSupported() + def interfaceName(implname: Name): TypeName = notSupported() + } + + // Members declared in scala.reflect.api.Symbols + val NoSymbol = DummySymbol + type Symbol = DummySymbolApi + object DummySymbol extends DummySymbolApi + type TypeSymbol = DummyTypeSymbolApi + object DummyTypeSymbol extends DummyTypeSymbolApi + type TermSymbol = DummyTermSymbolApi + object DummyTermSymbol extends DummyTermSymbolApi + type MethodSymbol = DummyMethodSymbolApi + object DummyMethodSymbol extends DummyMethodSymbolApi + type ModuleSymbol = DummyModuleSymbolApi + object DummyModuleSymbol extends DummyModuleSymbolApi + type PackageSymbol = DummyPackageSymbolApi + object DummyPackageSymbol extends DummyPackageSymbolApi + type ClassSymbol = DummyClassSymbolApi + object DummyClassSymbol extends DummyClassSymbolApi + trait DummySymbolApi extends AbsSymbol { + this: Symbol => + + def pos: Position = notSupported() + def modifiers: Set[Modifier] = notSupported() + def hasModifier(mod: Modifier): Boolean = notSupported() + def annotations: List[AnnotationInfo] = notSupported() + def hasAnnotation(sym: Symbol): Boolean = notSupported() + def owner: Symbol = notSupported() + def name: Name = notSupported() + def fullName: String = notSupported() + def id: Int = notSupported() + def orElse(alt: => Symbol): Symbol = notSupported() + def filter(cond: Symbol => Boolean): Symbol = notSupported() + def suchThat(cond: Symbol => Boolean): Symbol = notSupported() + def privateWithin: Symbol = notSupported() + def companionSymbol: Symbol = notSupported() + def moduleClass: Symbol = notSupported() + def enclosingTopLevelClass: Symbol = notSupported() + def enclosingClass: Symbol = notSupported() + def enclosingMethod: Symbol = notSupported() + def enclosingPackageClass: Symbol = notSupported() + def isTerm : Boolean = notSupported() + def isPackage : Boolean = notSupported() + def isMethod : Boolean = notSupported() + def isOverloaded : Boolean = notSupported() + def isFreeTerm : Boolean = notSupported() + def isType : Boolean = notSupported() + def isClass : Boolean = notSupported() + def isPackageClass : Boolean = notSupported() + def isPrimitiveValueClass: Boolean = notSupported() + def isDerivedValueClass: Boolean = notSupported() + def isAliasType : Boolean = notSupported() + def isAbstractType : Boolean = notSupported() + def isSkolem : Boolean = notSupported() + def isExistential : Boolean = notSupported() + def isFreeType : Boolean = notSupported() + def isContravariant : Boolean = notSupported() + def isCovariant : Boolean = notSupported() + def isErroneous : Boolean = notSupported() + def typeSignature: Type = notSupported() + def typeSignatureIn(site: Type): Type = notSupported() + def asType: Type = notSupported() + def asTypeIn(site: Type): Type = notSupported() + def asTypeConstructor: Type = notSupported() + def thisPrefix: Type = notSupported() + def selfType: Type = notSupported() + def alternatives: List[Symbol] = notSupported() + def resolveOverloaded(pre: Type = NoPrefix, targs: Seq[Type] = List(), actuals: Seq[Type]): Symbol = notSupported() + def newNestedSymbol(name: Name, pos: Position, flags: Long, isClass: Boolean): Symbol = notSupported() + def setInternalFlags(flags: Long): this.type = notSupported() + def setTypeSignature(tpe: Type): this.type = notSupported() + def setAnnotations(annots: AnnotationInfo*): this.type = notSupported() + def kind: String = notSupported() + } + trait DummyTypeSymbolApi extends DummySymbolApi with TypeSymbolApi { + this: TypeSymbol => + } + trait DummyTermSymbolApi extends DummySymbolApi with TermSymbolApi { + this: TermSymbol => + } + trait DummyMethodSymbolApi extends DummyTermSymbolApi with MethodSymbolApi { + this: MethodSymbol => + } + trait DummyModuleSymbolApi extends DummyTermSymbolApi with ModuleSymbolApi { + this: ModuleSymbol => + } + trait DummyPackageSymbolApi extends DummyModuleSymbolApi with PackageSymbolApi { + this: PackageSymbol => + } + trait DummyClassSymbolApi extends DummyTypeSymbolApi with ClassSymbolApi { + this: ClassSymbol => + } + + // Members declared in scala.reflect.api.ToolBoxes + def mkToolBox(frontEnd: FrontEnd, options: String): AbsToolBox = notSupported() + + // Members declared in scala.reflect.api.TreeBuildUtil + // type TreeGen = DummyTreeGen.type // [Eugene] cannot compile if uncomment this + val gen: TreeGen{val global: DummyMirror.this.type} = DummyTreeGen.asInstanceOf[TreeGen{val global: DummyMirror.this.type}] + def modifiersFromInternalFlags(flags: Long,privateWithin: Name,annotations: List[Tree]): Modifiers = DummyModifiers + def newFreeExistential(name: String,info: Type,value: => Any,flags: Long,origin: String) = DummySymbol + def newFreeTerm(name: String,info: Type,value: => Any,flags: Long,origin: String) = DummySymbol + def newFreeType(name: String,info: Type,value: => Any,flags: Long,origin: String) = DummySymbol + def selectOverloadedMethod(owner: Symbol,name: String,index: Int) = DummySymbol + def selectOverloadedMethodIfDefined(owner: Symbol,name: String,index: Int) = DummySymbol + def selectTerm(owner: Symbol,name: String) = DummySymbol + def selectTermIfDefined(owner: Symbol,name: String) = DummySymbol + def selectType(owner: Symbol,name: String) = DummySymbol + def selectTypeIfDefined(owner: Symbol,name: String) = DummySymbol + def staticClass(fullName: String) = DummySymbol + def staticClassIfDefined(fullName: String) = DummySymbol + def staticModule(fullName: String) = DummySymbol + def staticModuleIfDefined(fullName: String) = DummySymbol + def thisModuleType(fullName: String): Type = DummyType + object DummyTreeGen extends AbsTreeGen { + val global: Universe = DummyMirror.this + type TreeGenTree = global.Tree + type TreeGenType = global.Type + type TreeGenSymbol = global.Symbol + type TreeGenName = global.Name + def mkAttributedQualifier(tpe: TreeGenType): TreeGenTree = notSupported() + def mkAttributedQualifier(tpe: TreeGenType, termSym: TreeGenSymbol): TreeGenTree = notSupported() + def mkAttributedRef(pre: TreeGenType, sym: TreeGenSymbol): TreeGenTree = notSupported() + def mkAttributedRef(sym: TreeGenSymbol): TreeGenTree = notSupported() + def mkAttributedThis(sym: TreeGenSymbol): TreeGenTree = notSupported() + def mkAttributedIdent(sym: TreeGenSymbol): TreeGenTree = notSupported() + def mkAttributedSelect(qual: TreeGenTree, sym: TreeGenSymbol): TreeGenTree = notSupported() + def mkMethodCall(target: TreeGenTree,targs: List[TreeGenType],args: List[TreeGenTree]): TreeGenTree = notSupported() + def mkMethodCall(receiver: TreeGenTree,method: TreeGenSymbol,targs: List[TreeGenType],args: List[TreeGenTree]): TreeGenTree = notSupported() + def mkMethodCall(receiver: TreeGenSymbol,methodName: TreeGenName,args: List[TreeGenTree]): TreeGenTree = notSupported() + def mkMethodCall(target: TreeGenTree,args: List[TreeGenTree]): TreeGenTree = notSupported() + def mkMethodCall(method: TreeGenSymbol,args: List[TreeGenTree]): TreeGenTree = notSupported() + def mkMethodCall(method: TreeGenSymbol,targs: List[TreeGenType],args: List[TreeGenTree]): TreeGenTree = notSupported() + def mkMethodCall(receiver: TreeGenSymbol,methodName: TreeGenName,targs: List[TreeGenType],args: List[TreeGenTree]): TreeGenTree = notSupported() + def mkNullaryCall(method: TreeGenSymbol,targs: List[TreeGenType]): TreeGenTree = notSupported() + } + + // Members declared in scala.reflect.api.TreePrinters + def newTreePrinter(out: java.io.PrintWriter): TreePrinter = notSupported() + + // Members declared in scala.reflect.api.Trees + def Apply(sym: Symbol,args: Tree*): Tree = Apply(EmptyTree, Nil) + def Bind(sym: Symbol,body: Tree): Bind = Bind(DummyName, EmptyTree) + def Block(stats: Tree*): Block = Block() + def CaseDef(pat: Tree,body: Tree): CaseDef = CaseDef(EmptyTree, EmptyTree, EmptyTree) + def ClassDef(sym: Symbol,impl: Template): ClassDef = ClassDef(DummyModifiers, DummyName, Nil, Template(Nil, emptyValDef, Nil)) + def DefDef(sym: Symbol,rhs: List[List[Symbol]] => Tree): DefDef = DefDef(DummyModifiers, DummyName, Nil, Nil, EmptyTree, EmptyTree) + def DefDef(sym: Symbol,rhs: Tree): DefDef = DefDef(DummyModifiers, DummyName, Nil, Nil, EmptyTree, EmptyTree) + def DefDef(sym: Symbol,mods: Modifiers,rhs: Tree): DefDef = DefDef(DummyModifiers, DummyName, Nil, Nil, EmptyTree, EmptyTree) + def DefDef(sym: Symbol,vparamss: List[List[ValDef]],rhs: Tree): DefDef = DefDef(DummyModifiers, DummyName, Nil, Nil, EmptyTree, EmptyTree) + def DefDef(sym: Symbol,mods: Modifiers,vparamss: List[List[ValDef]],rhs: Tree): DefDef = DefDef(DummyModifiers, DummyName, Nil, Nil, EmptyTree, EmptyTree) + def Ident(sym: Symbol): Ident = Ident(DummyName) + def Ident(name: String): Ident = Ident(DummyName) + def LabelDef(sym: Symbol,params: List[Symbol],rhs: Tree): LabelDef = LabelDef(DummyName, Nil, EmptyTree) + type Modifiers = DummyModifiers.type + val NoMods: Modifiers = DummyModifiers + object DummyModifiers extends AbsModifiers { + def modifiers: Set[Modifier] = notSupported() + def hasModifier(mod: Modifier): Boolean = notSupported() + def privateWithin: Name = notSupported() + def annotations: List[Tree] = notSupported() + def mapAnnotations(f: List[Tree] => List[Tree]): Modifiers = notSupported() + } + def Modifiers(mods: Set[scala.reflect.api.Modifier],privateWithin: Name,annotations: List[Tree]): Modifiers = DummyModifiers + def ModuleDef(sym: Symbol,impl: Template): ModuleDef = ModuleDef(DummyModifiers, DummyName, Template(Nil, emptyValDef, Nil)) + def New(sym: Symbol,args: Tree*): Tree = New(EmptyTree) + def New(tpe: Type,args: Tree*): Tree = New(EmptyTree) + def New(tpt: Tree,argss: List[List[Tree]]): Tree = New(EmptyTree) + def Select(qualifier: Tree,sym: Symbol): Select = Select(EmptyTree, DummyName) + def Select(qualifier: Tree,name: String): Select = Select(EmptyTree, DummyName) + def Super(sym: Symbol,mix: TypeName): Tree = Super(EmptyTree, DummyName) + def This(sym: Symbol): Tree = This(DummyName) + def Throw(tpe: Type,args: Tree*): Throw = Throw(EmptyTree) + def Try(body: Tree,cases: (Tree, Tree)*): Try = Try(EmptyTree) + def TypeDef(sym: Symbol): TypeDef = TypeDef(DummyModifiers, DummyName, Nil, EmptyTree) + def TypeDef(sym: Symbol,rhs: Tree): TypeDef = TypeDef(DummyModifiers, DummyName, Nil, EmptyTree) + def ValDef(sym: Symbol): ValDef = ValDef(DummyModifiers, DummyName, EmptyTree, EmptyTree) + def ValDef(sym: Symbol,rhs: Tree): ValDef = ValDef(DummyModifiers, DummyName, EmptyTree, EmptyTree) + protected def duplicateTree(tree: Tree): Tree = notSupported() + object emptyValDef extends ValDef(DummyModifiers, DummyName, EmptyTree, EmptyTree) { override def isEmpty = true } + type TreeCopier = DummyTreeCopier.type + def newStrictTreeCopier: TreeCopier = DummyTreeCopier + def newLazyTreeCopier: TreeCopier = DummyTreeCopier + object DummyTreeCopier extends TreeCopierOps { + def ClassDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[TypeDef], impl: Template): ClassDef = notSupported() + def PackageDef(tree: Tree, pid: RefTree, stats: List[Tree]): PackageDef = notSupported() + def ModuleDef(tree: Tree, mods: Modifiers, name: Name, impl: Template): ModuleDef = notSupported() + def ValDef(tree: Tree, mods: Modifiers, name: Name, tpt: Tree, rhs: Tree): ValDef = notSupported() + def DefDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = notSupported() + def TypeDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[TypeDef], rhs: Tree): TypeDef = notSupported() + def LabelDef(tree: Tree, name: Name, params: List[Ident], rhs: Tree): LabelDef = notSupported() + def Import(tree: Tree, expr: Tree, selectors: List[ImportSelector]): Import = notSupported() + def Template(tree: Tree, parents: List[Tree], self: ValDef, body: List[Tree]): Template = notSupported() + def Block(tree: Tree, stats: List[Tree], expr: Tree): Block = notSupported() + def CaseDef(tree: Tree, pat: Tree, guard: Tree, body: Tree): CaseDef = notSupported() + def Alternative(tree: Tree, trees: List[Tree]): Alternative = notSupported() + def Star(tree: Tree, elem: Tree): Star = notSupported() + def Bind(tree: Tree, name: Name, body: Tree): Bind = notSupported() + def UnApply(tree: Tree, fun: Tree, args: List[Tree]): UnApply = notSupported() + def ArrayValue(tree: Tree, elemtpt: Tree, trees: List[Tree]): ArrayValue = notSupported() + def Function(tree: Tree, vparams: List[ValDef], body: Tree): Function = notSupported() + def Assign(tree: Tree, lhs: Tree, rhs: Tree): Assign = notSupported() + def AssignOrNamedArg(tree: Tree, lhs: Tree, rhs: Tree): AssignOrNamedArg = notSupported() + def If(tree: Tree, cond: Tree, thenp: Tree, elsep: Tree): If = notSupported() + def Match(tree: Tree, selector: Tree, cases: List[CaseDef]): Match = notSupported() + def Return(tree: Tree, expr: Tree): Return = notSupported() + def Try(tree: Tree, block: Tree, catches: List[CaseDef], finalizer: Tree): Try = notSupported() + def Throw(tree: Tree, expr: Tree): Throw = notSupported() + def New(tree: Tree, tpt: Tree): New = notSupported() + def Typed(tree: Tree, expr: Tree, tpt: Tree): Typed = notSupported() + def TypeApply(tree: Tree, fun: Tree, args: List[Tree]): TypeApply = notSupported() + def Apply(tree: Tree, fun: Tree, args: List[Tree]): Apply = notSupported() + def ApplyDynamic(tree: Tree, qual: Tree, args: List[Tree]): ApplyDynamic = notSupported() + def Super(tree: Tree, qual: Tree, mix: TypeName): Super = notSupported() + def This(tree: Tree, qual: Name): This = notSupported() + def Select(tree: Tree, qualifier: Tree, selector: Name): Select = notSupported() + def Ident(tree: Tree, name: Name): Ident = notSupported() + def ReferenceToBoxed(tree: Tree, idt: Ident): ReferenceToBoxed = notSupported() + def Literal(tree: Tree, value: Constant): Literal = notSupported() + def TypeTree(tree: Tree): TypeTree = notSupported() + def Annotated(tree: Tree, annot: Tree, arg: Tree): Annotated = notSupported() + def SingletonTypeTree(tree: Tree, ref: Tree): SingletonTypeTree = notSupported() + def SelectFromTypeTree(tree: Tree, qualifier: Tree, selector: Name): SelectFromTypeTree = notSupported() + def CompoundTypeTree(tree: Tree, templ: Template): CompoundTypeTree = notSupported() + def AppliedTypeTree(tree: Tree, tpt: Tree, args: List[Tree]): AppliedTypeTree = notSupported() + def TypeBoundsTree(tree: Tree, lo: Tree, hi: Tree): TypeBoundsTree = notSupported() + def ExistentialTypeTree(tree: Tree, tpt: Tree, whereClauses: List[Tree]): ExistentialTypeTree = notSupported() + } + + // Members declared in scala.reflect.api.Types + type Type = DummyType.type + type SingletonType = DummyType.type + type CompoundType = DummyType.type + type AnnotatedType = DummyType.type + val AnnotatedType: AnnotatedTypeExtractor = DummyAnnotatedTypeExtractor + type BoundedWildcardType = DummyType.type + val BoundedWildcardType: BoundedWildcardTypeExtractor = DummyBoundedWildcardTypeExtractor + type ClassInfoType = DummyType.type + val ClassInfoType: ClassInfoTypeExtractor = DummyClassInfoTypeExtractor + type ConstantType = DummyType.type + val ConstantType: ConstantTypeExtractor = DummyConstantTypeExtractor + type ExistentialType = DummyType.type + val ExistentialType: ExistentialTypeExtractor = DummyExistentialTypeExtractor + type MethodType = DummyType.type + val MethodType: MethodTypeExtractor = DummyMethodTypeExtractor + val NoPrefix: Type = DummyType + val NoType: Type = DummyType + type NullaryMethodType = DummyType.type + val NullaryMethodType: NullaryMethodTypeExtractor = DummyNullaryMethodTypeExtractor + type PolyType = DummyType.type + val PolyType: PolyTypeExtractor = DummyPolyTypeExtractor + type RefinedType = DummyType.type + val RefinedType: RefinedTypeExtractor = DummyRefinedTypeExtractor + type SingleType = DummyType.type + val SingleType: SingleTypeExtractor = DummySingleTypeExtractor + type SuperType = DummyType.type + val SuperType: SuperTypeExtractor = DummySuperTypeExtractor + type ThisType = DummyType.type + val ThisType: ThisTypeExtractor = DummyThisTypeExtractor + type TypeBounds = DummyType.type + val TypeBounds: TypeBoundsExtractor = DummyTypeBoundsExtractor + type TypeRef = DummyType.type + val TypeRef: TypeRefExtractor = DummyTypeRefExtractor + val WildcardType: Type = DummyType + def appliedType(tycon: Type,args: List[Type]): Type = DummyType + def existentialAbstraction(tparams: List[Symbol],tpe0: Type): Type = DummyType + def glb(ts: List[Type]): Type = DummyType + def intersectionType(tps: List[Type],owner: Symbol): Type = DummyType + def intersectionType(tps: List[Type]): Type = DummyType + def lub(xs: List[Type]): Type = DummyType + def polyType(tparams: List[Symbol],tpe: Type): Type = DummyType + def refinedType(parents: List[Type],owner: Symbol): Type = DummyType + def refinedType(parents: List[Type],owner: Symbol,decls: Scope,pos: Position): Type = DummyType + def singleType(pre: Type,sym: Symbol): Type = DummyType + def typeRef(pre: Type,sym: Symbol,args: List[Type]): Type = DummyType + object DummyType extends AbsType { + def =:=(that: Type): Boolean = notSupported() + def <:<(that: Type): Boolean = notSupported() + def asSeenFrom(pre: Type,clazz: Symbol): Type = notSupported() + def baseClasses: List[Symbol] = notSupported() + def baseType(clazz: Symbol): Type = notSupported() + def contains(sym: Symbol): Boolean = notSupported() + def declaration(name: Name): Symbol = notSupported() + def declarations: Iterable[Symbol] = notSupported() + def erasure: Type = notSupported() + def exists(p: Type => Boolean): Boolean = notSupported() + def find(p: Type => Boolean): Option[Type] = notSupported() + def foreach(f: Type => Unit): Unit = notSupported() + def isConcrete: Boolean = notSupported() + def isHigherKinded: Boolean = notSupported() + def isSpliceable: Boolean = notSupported() + def kind: String = notSupported() + def map(f: Type => Type): Type = notSupported() + def member(name: Name): Symbol = notSupported() + def members: Iterable[Symbol] = notSupported() + def nonPrivateMember(name: Name): Symbol = notSupported() + def nonPrivateMembers: Iterable[Symbol] = notSupported() + def normalize: Type = notSupported() + def parents: List[Type] = notSupported() + def substituteTypes(from: List[Symbol],to: List[Type]): Type = notSupported() + def typeArguments: List[Type] = notSupported() + def typeConstructor: Type = notSupported() + def typeParams: List[Symbol] = notSupported() + def typeSymbol: Symbol = notSupported() + def underlying: Type = notSupported() + def widen: Type = notSupported() + } + object DummyAnnotatedTypeExtractor extends AnnotatedTypeExtractor { + def apply(annotations: List[AnnotationInfo], underlying: Type, selfsym: Symbol): AnnotatedType = DummyType + def unapply(tpe: AnnotatedType): Option[(List[AnnotationInfo], Type, Symbol)] = notSupported() + } + object DummyBoundedWildcardTypeExtractor extends BoundedWildcardTypeExtractor { + def apply(bounds: TypeBounds): BoundedWildcardType = DummyType + def unapply(tpe: BoundedWildcardType): Option[TypeBounds] = notSupported() + } + object DummyClassInfoTypeExtractor extends ClassInfoTypeExtractor { + def apply(parents: List[Type], decls: Scope, clazz: Symbol): ClassInfoType = DummyType + def unapply(tpe: ClassInfoType): Option[(List[Type], Scope, Symbol)] = notSupported() + } + object DummyConstantTypeExtractor extends ConstantTypeExtractor { + def apply(value: Constant): ConstantType = DummyType + def unapply(tpe: ConstantType): Option[Constant] = notSupported() + } + object DummyExistentialTypeExtractor extends ExistentialTypeExtractor { + def apply(quantified: List[Symbol], underlying: Type): ExistentialType = DummyType + def unapply(tpe: ExistentialType): Option[(List[Symbol], Type)] = notSupported() + } + object DummyMethodTypeExtractor extends MethodTypeExtractor { + def apply(params: List[Symbol], resultType: Type): MethodType = DummyType + def unapply(tpe: MethodType): Option[(List[Symbol], Type)] = notSupported() + } + object DummyNullaryMethodTypeExtractor extends NullaryMethodTypeExtractor { + def apply(resultType: Type): NullaryMethodType = DummyType + def unapply(tpe: NullaryMethodType): Option[(Type)] = notSupported() + } + object DummyPolyTypeExtractor extends PolyTypeExtractor { + def apply(typeParams: List[Symbol], resultType: Type): PolyType = DummyType + def unapply(tpe: PolyType): Option[(List[Symbol], Type)] = notSupported() + } + object DummyRefinedTypeExtractor extends RefinedTypeExtractor { + def apply(parents: List[Type], decls: Scope): RefinedType = DummyType + def apply(parents: List[Type], decls: Scope, clazz: Symbol): RefinedType = DummyType + def unapply(tpe: RefinedType): Option[(List[Type], Scope)] = notSupported() + } + object DummySingleTypeExtractor extends SingleTypeExtractor { + def apply(pre: Type, sym: Symbol): Type = DummyType + def unapply(tpe: SingleType): Option[(Type, Symbol)] = notSupported() + } + object DummySuperTypeExtractor extends SuperTypeExtractor { + def apply(thistpe: Type, supertpe: Type): Type = DummyType + def unapply(tpe: SuperType): Option[(Type, Type)] = notSupported() + } + object DummyThisTypeExtractor extends ThisTypeExtractor { + def apply(sym: Symbol): Type = DummyType + def unapply(tpe: ThisType): Option[Symbol] = notSupported() + } + object DummyTypeBoundsExtractor extends TypeBoundsExtractor { + def apply(lo: Type, hi: Type): TypeBounds = DummyType + def unapply(tpe: TypeBounds): Option[(Type, Type)] = notSupported() + } + object DummyTypeRefExtractor extends TypeRefExtractor { + def apply(pre: Type, sym: Symbol, args: List[Type]): Type = DummyType + def unapply(tpe: TypeRef): Option[(Type, Symbol, List[Type])] = notSupported() + } + + // Utils + def notSupported() = { + throw new UnsupportedOperationException("Scala reflection not available on this platform." + mirrorDiagnostics(cl)) + } +}
\ No newline at end of file diff --git a/src/library/scala/reflect/DynamicProxy.scala b/src/library/scala/reflect/DynamicProxy.scala index ffd1e7a39f..3ed17fea41 100644 --- a/src/library/scala/reflect/DynamicProxy.scala +++ b/src/library/scala/reflect/DynamicProxy.scala @@ -2,13 +2,13 @@ package scala.reflect /** * A dynamic proxy which redirects method calls and attribute access to a given * target object at runtime using reflection. - * + * * Usage example: - * + * * object x{ def hello = "hello world" } * val d = new DynamicProxy{ val dynamicProxyTarget = x } * assert( d.hello == "hello world" ) - * + * * Not supported (yet): * - implicit conversions and parameters * - multiple arguments lists @@ -26,7 +26,7 @@ trait DynamicProxy extends Dynamic{ object DynamicReflectBoxed{ implicit def box[@specialized T]( v:T ) = DynamicReflectBoxed( v.getClass, v ) } - + def selectDynamic( method:String ) = { val symbol = classToType( dynamicProxyTarget.getClass ).member( newTermName(method).encodedName ) invoke( dynamicProxyTarget, symbol )() @@ -38,37 +38,37 @@ trait DynamicProxy extends Dynamic{ } def applyDynamic( method:String )( args:DynamicReflectBoxed* ) : Any - = applyDynamicNamed( method )( args.map( value => ("",value) ) :_* ) + = applyDynamicNamed( method )( args.map( value => ("",value) ) :_* ) def applyDynamicNamed( method:String )( args:(String,DynamicReflectBoxed)* ) : Any = { val class_ = dynamicProxyTarget.getClass var i = 0 - val toolbox = mkToolBox(mkConsoleReporter(),"") + val toolbox = mkToolBox(mkConsoleFrontEnd(),"") val symbol = classToType( dynamicProxyTarget.getClass ).member( newTermName(method).encodedName ) if(args.size == 0){ invoke( dynamicProxyTarget, symbol )() } else { - val call = + val call = Apply( Select( TypeApply( Select( Select( - Ident(newFreeTerm("__this", symbolForName("scala.reflect.DynamicProxy").asType, this, null)) + Ident(newFreeTerm("__this", symbolForName("scala.reflect.DynamicProxy").asType, this)) , newTermName("dynamicProxyTarget") - ), + ), newTermName("asInstanceOf") ) , List(TypeTree().setType(classToType(class_))) ) ,newTermName(method).encodedName ) ,args.map{ case(name,box) => - val value = Ident(newFreeTerm("__arg"+({i+=1;i}.toString), classToType(box.class_), box.value, null)) + val value = Ident(newFreeTerm("__arg"+({i+=1;i}.toString), classToType(box.class_), box.value)) if( name == "" ) value else AssignOrNamedArg( Ident(name), value ) }.toList ) toolbox.runExpr( call ) - } + } } } diff --git a/src/library/scala/reflect/ErasureTag.scala b/src/library/scala/reflect/ErasureTag.scala new file mode 100644 index 0000000000..f95451fab2 --- /dev/null +++ b/src/library/scala/reflect/ErasureTag.scala @@ -0,0 +1,23 @@ +package scala.reflect + +import java.lang.{Class => jClass} + +/** An `ErasureTag[T]` is a descriptor that is requested by the compiler every time + * when it needs to persist an erasure of a type. + * + * Scala library provides a standard implementation of this trait, + * `TypeTag[T]` that carries the `java.lang.Class` erasure for arbitrary types. + * + * However other platforms may reimplement this trait as they see fit + * and then expose the implementation via an implicit macro. + * + * If you need to guarantee that the type does not contain + * references to type parameters or abstract types, use `ClassTag[T]`. + * + * @see [[scala.reflect.api.TypeTags]] + */ +@annotation.implicitNotFound(msg = "No ErasureTag available for ${T}") +trait ErasureTag[T] { + /** Returns an erasure of type `T` */ + def erasure: jClass[_] +} diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala new file mode 100644 index 0000000000..da029f046d --- /dev/null +++ b/src/library/scala/reflect/Manifest.scala @@ -0,0 +1,259 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2007-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.reflect + +import scala.collection.mutable.{ ArrayBuilder, WrappedArray } +import mirror._ + +/** A `Manifest[T]` is an opaque descriptor for type T. Its supported use + * is to give access to the erasure of the type as a `Class` instance, as + * is necessary for the creation of native `Arrays` if the class is not + * known at compile time. + * + * The type-relation operators `<:<` and `=:=` should be considered + * approximations only, as there are numerous aspects of type conformance + * which are not yet adequately represented in manifests. + * + * Example usages: +{{{ + def arr[T] = new Array[T](0) // does not compile + def arr[T](implicit m: Manifest[T]) = new Array[T](0) // compiles + def arr[T: Manifest] = new Array[T](0) // shorthand for the preceding + + // Methods manifest, classManifest, and optManifest are in [[scala.Predef]]. + def isApproxSubType[T: Manifest, U: Manifest] = manifest[T] <:< manifest[U] + isApproxSubType[List[String], List[AnyRef]] // true + isApproxSubType[List[String], List[Int]] // false + + def methods[T: ClassManifest] = classManifest[T].erasure.getMethods + def retType[T: ClassManifest](name: String) = + methods[T] find (_.getName == name) map (_.getGenericReturnType) + + retType[Map[_, _]]("values") // Some(scala.collection.Iterable<B>) +}}} + * + */ +@annotation.implicitNotFound(msg = "No Manifest available for ${T}.") +@deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0") +trait Manifest[T] extends ClassManifest[T] with Equals { + override def typeArguments: List[Manifest[_]] = Nil + + override def arrayManifest: Manifest[Array[T]] = + Manifest.classType[Array[T]](arrayClass[T](erasure), this) + + override def canEqual(that: Any): Boolean = that match { + case _: Manifest[_] => true + case _ => false + } + /** Note: testing for erasure here is important, as it is many times + * faster than <:< and rules out most comparisons. + */ + override def equals(that: Any): Boolean = that match { + case m: Manifest[_] => (m canEqual this) && (this.erasure == m.erasure) && (this <:< m) && (m <:< this) + case _ => false + } + override def hashCode = this.erasure.## +} + +@deprecated("Use type tags and manually check the corresponding class or type instead", "2.10.0") +abstract class AnyValManifest[T <: AnyVal](override val toString: String) extends Manifest[T] with Equals { + override def <:<(that: ClassManifest[_]): Boolean = + (that eq this) || (that eq Manifest.Any) || (that eq Manifest.AnyVal) + override def canEqual(other: Any) = other match { + case _: AnyValManifest[_] => true + case _ => false + } + override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef] + override val hashCode = System.identityHashCode(this) +} + +/** The object `Manifest` defines factory methods for manifests. + * It is intended for use by the compiler and should not be used + * in client code. + */ +@deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0") +object Manifest { + def valueManifests: List[AnyValManifest[_]] = + List(Byte, Short, Char, Int, Long, Float, Double, Boolean, Unit) + + val Byte: AnyValManifest[Byte] = new AnyValManifest[scala.Byte]("Byte") { + def erasure = java.lang.Byte.TYPE + override def newArray(len: Int): Array[Byte] = new Array[Byte](len) + override def newWrappedArray(len: Int): WrappedArray[Byte] = new WrappedArray.ofByte(new Array[Byte](len)) + override def newArrayBuilder(): ArrayBuilder[Byte] = new ArrayBuilder.ofByte() + private def readResolve(): Any = Manifest.Byte + } + + val Short: AnyValManifest[Short] = new AnyValManifest[scala.Short]("Short") { + def erasure = java.lang.Short.TYPE + override def newArray(len: Int): Array[Short] = new Array[Short](len) + override def newWrappedArray(len: Int): WrappedArray[Short] = new WrappedArray.ofShort(new Array[Short](len)) + override def newArrayBuilder(): ArrayBuilder[Short] = new ArrayBuilder.ofShort() + private def readResolve(): Any = Manifest.Short + } + + val Char: AnyValManifest[Char] = new AnyValManifest[scala.Char]("Char") { + def erasure = java.lang.Character.TYPE + override def newArray(len: Int): Array[Char] = new Array[Char](len) + override def newWrappedArray(len: Int): WrappedArray[Char] = new WrappedArray.ofChar(new Array[Char](len)) + override def newArrayBuilder(): ArrayBuilder[Char] = new ArrayBuilder.ofChar() + private def readResolve(): Any = Manifest.Char + } + + val Int: AnyValManifest[Int] = new AnyValManifest[scala.Int]("Int") { + def erasure = java.lang.Integer.TYPE + override def newArray(len: Int): Array[Int] = new Array[Int](len) + override def newWrappedArray(len: Int): WrappedArray[Int] = new WrappedArray.ofInt(new Array[Int](len)) + override def newArrayBuilder(): ArrayBuilder[Int] = new ArrayBuilder.ofInt() + private def readResolve(): Any = Manifest.Int + } + + val Long: AnyValManifest[Long] = new AnyValManifest[scala.Long]("Long") { + def erasure = java.lang.Long.TYPE + override def newArray(len: Int): Array[Long] = new Array[Long](len) + override def newWrappedArray(len: Int): WrappedArray[Long] = new WrappedArray.ofLong(new Array[Long](len)) + override def newArrayBuilder(): ArrayBuilder[Long] = new ArrayBuilder.ofLong() + private def readResolve(): Any = Manifest.Long + } + + val Float: AnyValManifest[Float] = new AnyValManifest[scala.Float]("Float") { + def erasure = java.lang.Float.TYPE + override def newArray(len: Int): Array[Float] = new Array[Float](len) + override def newWrappedArray(len: Int): WrappedArray[Float] = new WrappedArray.ofFloat(new Array[Float](len)) + override def newArrayBuilder(): ArrayBuilder[Float] = new ArrayBuilder.ofFloat() + private def readResolve(): Any = Manifest.Float + } + + val Double: AnyValManifest[Double] = new AnyValManifest[scala.Double]("Double") { + def erasure = java.lang.Double.TYPE + override def newArray(len: Int): Array[Double] = new Array[Double](len) + override def newWrappedArray(len: Int): WrappedArray[Double] = new WrappedArray.ofDouble(new Array[Double](len)) + override def newArrayBuilder(): ArrayBuilder[Double] = new ArrayBuilder.ofDouble() + private def readResolve(): Any = Manifest.Double + } + + val Boolean: AnyValManifest[Boolean] = new AnyValManifest[scala.Boolean]("Boolean") { + def erasure = java.lang.Boolean.TYPE + override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len) + override def newWrappedArray(len: Int): WrappedArray[Boolean] = new WrappedArray.ofBoolean(new Array[Boolean](len)) + override def newArrayBuilder(): ArrayBuilder[Boolean] = new ArrayBuilder.ofBoolean() + private def readResolve(): Any = Manifest.Boolean + } + + val Unit: AnyValManifest[Unit] = new AnyValManifest[scala.Unit]("Unit") { + def erasure = java.lang.Void.TYPE + override def newArray(len: Int): Array[Unit] = new Array[Unit](len) + override def newWrappedArray(len: Int): WrappedArray[Unit] = new WrappedArray.ofUnit(new Array[Unit](len)) + override def newArrayBuilder(): ArrayBuilder[Unit] = new ArrayBuilder.ofUnit() + private def readResolve(): Any = Manifest.Unit + } + + val Any: Manifest[scala.Any] = new PhantomManifest[scala.Any]("Any") { + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) + private def readResolve(): Any = Manifest.Any + } + + val Object: Manifest[java.lang.Object] = new PhantomManifest[java.lang.Object]("Object") { + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.Object + } + + val AnyVal: Manifest[scala.AnyVal] = new PhantomManifest[scala.AnyVal]("AnyVal") { + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.AnyVal + } + + val Null: Manifest[scala.Null] = new PhantomManifest[scala.Null]("Null") { + override def <:<(that: ClassManifest[_]): Boolean = + (that ne null) && (that ne Nothing) && !(that <:< AnyVal) + private def readResolve(): Any = Manifest.Null + } + + val Nothing: Manifest[scala.Nothing] = new PhantomManifest[scala.Nothing]("Nothing") { + override def <:<(that: ClassManifest[_]): Boolean = (that ne null) + private def readResolve(): Any = Manifest.Nothing + } + + private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { + lazy val erasure = value.getClass + override lazy val toString = value.toString + ".type" + } + + /** Manifest for the singleton type `value.type`. */ + def singleType[T <: AnyRef](value: AnyRef): Manifest[T] = + new SingletonTypeManifest[T](value) + + /** Manifest for the class type `clazz[args]`, where `clazz` is + * a top-level or static class. + * @note This no-prefix, no-arguments case is separate because we + * it's called from ScalaRunTime.boxArray itself. If we + * pass varargs as arrays into this, we get an infinitely recursive call + * to boxArray. (Besides, having a separate case is more efficient) + */ + def classType[T](clazz: Predef.Class[_]): Manifest[T] = + new ClassTypeManifest[T](None, clazz, Nil) + + /** Manifest for the class type `clazz`, where `clazz` is + * a top-level or static class and args are its type arguments. */ + def classType[T](clazz: Predef.Class[T], arg1: Manifest[_], args: Manifest[_]*): Manifest[T] = + new ClassTypeManifest[T](None, clazz, arg1 :: args.toList) + + /** Manifest for the class type `clazz[args]`, where `clazz` is + * a class with non-package prefix type `prefix` and type arguments `args`. + */ + def classType[T](prefix: Manifest[_], clazz: Predef.Class[_], args: Manifest[_]*): Manifest[T] = + new ClassTypeManifest[T](Some(prefix), clazz, args.toList) + + private abstract class PhantomManifest[T](override val toString: String) extends ClassTypeManifest[T](None, classOf[java.lang.Object], Nil) { + override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef] + override val hashCode = System.identityHashCode(this) + } + + /** Manifest for the class type `clazz[args]`, where `clazz` is + * a top-level or static class. */ + private class ClassTypeManifest[T](prefix: Option[Manifest[_]], + val erasure: Predef.Class[_], + override val typeArguments: List[Manifest[_]]) extends Manifest[T] { + override def toString = + (if (prefix.isEmpty) "" else prefix.get.toString+"#") + + (if (erasure.isArray) "Array" else erasure.getName) + + argString + } + + def arrayType[T](arg: Manifest[_]): Manifest[Array[T]] = + arg.asInstanceOf[Manifest[T]].arrayManifest + + /** Manifest for the abstract type `prefix # name'. `upperBound` is not + * strictly necessary as it could be obtained by reflection. It was + * added so that erasure can be calculated without reflection. */ + def abstractType[T](prefix: Manifest[_], name: String, upperBound: Predef.Class[_], args: Manifest[_]*): Manifest[T] = + new Manifest[T] { + def erasure = upperBound + override val typeArguments = args.toList + override def toString = prefix.toString+"#"+name+argString + } + + /** Manifest for the unknown type `_ >: L <: U` in an existential. + */ + def wildcardType[T](lowerBound: Manifest[_], upperBound: Manifest[_]): Manifest[T] = + new Manifest[T] { + def erasure = upperBound.erasure + override def toString = + "_" + + (if (lowerBound eq Nothing) "" else " >: "+lowerBound) + + (if (upperBound eq Nothing) "" else " <: "+upperBound) + } + + /** Manifest for the intersection type `parents_0 with ... with parents_n'. */ + def intersectionType[T](parents: Manifest[_]*): Manifest[T] = + new Manifest[T] { + def erasure = parents.head.erasure + override def toString = parents.mkString(" with ") + } +}
\ No newline at end of file diff --git a/src/dbc/scala/dbc/statement/SetClause.scala b/src/library/scala/reflect/NoManifest.scala index 3af509c026..7b8037272c 100644 --- a/src/dbc/scala/dbc/statement/SetClause.scala +++ b/src/library/scala/reflect/NoManifest.scala @@ -1,21 +1,16 @@ /* __ *\ ** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** +** / __/ __// _ | / / / _ | (c) 2007-2011, LAMP/EPFL ** ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ +package scala.reflect - -package scala.dbc -package statement - - -import scala.dbc.statement.expression._ - -/** Data to be inserted into a table in an <code>Insert</code>. */ -@deprecated(DbcIsDeprecated, "2.9.0") case class SetClause(name: String, expr: Expression) { - val value: Pair[String,Expression] = (name, expr) - def sqlString: String = value._1 + " = " + value._2.sqlInnerString -} +/** One of the branches of an [[scala.reflect.OptManifest]]. + */ +@deprecated("Use `@scala.reflect.TypeTag` instead", "2.10.0") +object NoManifest extends OptManifest[Nothing] with Serializable { + override def toString = "<?>" +}
\ No newline at end of file diff --git a/src/library/scala/reflect/OptManifest.scala b/src/library/scala/reflect/OptManifest.scala new file mode 100644 index 0000000000..46f23c4e22 --- /dev/null +++ b/src/library/scala/reflect/OptManifest.scala @@ -0,0 +1,18 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2007-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.reflect + +/** A `OptManifest[T]` is an optional [[scala.reflect.Manifest]]. + * + * It is either a `Manifest` or the value `NoManifest`. + * + * @author Martin Odersky + */ +@deprecated("Use `@scala.reflect.TypeTag` instead", "2.10.0") +trait OptManifest[+T] extends Serializable
\ No newline at end of file diff --git a/src/library/scala/reflect/ReflectionUtils.scala b/src/library/scala/reflect/ReflectionUtils.scala index 1be46eac55..6ea69cb80d 100644 --- a/src/library/scala/reflect/ReflectionUtils.scala +++ b/src/library/scala/reflect/ReflectionUtils.scala @@ -5,6 +5,7 @@ package scala.reflect +import java.lang.{Class => jClass} import java.lang.reflect.{ InvocationTargetException, UndeclaredThrowableException } /** A few java-reflection oriented utility functions useful during reflection bootstrapping. @@ -27,6 +28,28 @@ object ReflectionUtils { case ex if pf isDefinedAt unwrapThrowable(ex) => pf(unwrapThrowable(ex)) } + private def systemProperties: Iterator[(String, String)] = { + import scala.collection.JavaConverters._ + System.getProperties.asScala.iterator + } + + private def searchForBootClasspath = ( + systemProperties find (_._1 endsWith ".boot.class.path") map (_._2) getOrElse "" + ) + + def show(cl: ClassLoader) = { + def inferClasspath(cl: ClassLoader) = cl match { + case cl: java.net.URLClassLoader => "[" + (cl.getURLs mkString ",") + "]" + case _ => "<unknown>" + } + cl match { + case cl if cl != null => + "%s of type %s with classpath %s".format(cl, cl.getClass, inferClasspath(cl)) + case null => + "primordial classloader with boot classpath [%s]".format(searchForBootClasspath) + } + } + def defaultReflectionClassLoader() = { // say no to non-determinism of mirror classloaders // default classloader will be instantiated using current system classloader diff --git a/src/library/scala/reflect/TagInterop.scala b/src/library/scala/reflect/TagInterop.scala new file mode 100644 index 0000000000..6c6bfcc2f2 --- /dev/null +++ b/src/library/scala/reflect/TagInterop.scala @@ -0,0 +1,34 @@ +package scala.reflect + +import scala.runtime.ScalaRunTime._ +import mirror._ +import definitions._ + +object TagInterop { + def arrayTagToClassManifest[T](tag: ArrayTag[T]): ClassManifest[T] = { + val erasure = arrayElementClass(tag) + if (erasure.isArray) { + val elementClass = arrayElementClass(erasure) + val elementManifest = arrayTagToClassManifest(ClassTag(elementClass)) + ClassManifest.arrayType(elementManifest).asInstanceOf[ClassManifest[T]] + } else { + ClassManifest.fromClass(erasure.asInstanceOf[Class[T]]) + } + } + + def concreteTypeTagToManifest[T](tag: ConcreteTypeTag[T]): Manifest[T] = { + // todo. reproduce manifest generation code here. toolboxes are too slow. + val implicitly = PredefModule.typeSignature.member(newTermName("implicitly")) + val taggedTpe = appliedType(staticClass("scala.reflect.Manifest").asTypeConstructor, List(tag.tpe)) + val materializer = TypeApply(Ident(implicitly), List(TypeTree(taggedTpe))) + try mkToolBox().runExpr(materializer).asInstanceOf[Manifest[T]] + catch { case ex: Throwable => Manifest.classType(tag.erasure).asInstanceOf[Manifest[T]] } + } + + def manifestToConcreteTypeTag[T](tag: Manifest[T]): ConcreteTypeTag[T] = { + val tpe = + if (tag.typeArguments.isEmpty) classToType(tag.erasure) + else appliedType(classToType(tag.erasure).typeConstructor, tag.typeArguments map (manifestToConcreteTypeTag(_)) map (_.tpe)) + ConcreteTypeTag(tpe, tag.erasure) + } +}
\ No newline at end of file diff --git a/src/library/scala/reflect/TagMaterialization.scala b/src/library/scala/reflect/TagMaterialization.scala deleted file mode 100644 index aede00020f..0000000000 --- a/src/library/scala/reflect/TagMaterialization.scala +++ /dev/null @@ -1,155 +0,0 @@ -package scala.reflect - -import api.Universe -import makro.Context -import language.implicitConversions - -// todo. unfortunately, current type inferencer doesn't infer type parameters of implicit values -// this means that during macro expansion these macros will get Nothing instead of real T -// Oh how much I'd love to implement this now, but I have to postpone this until we have a solution for type inference - -/** This object is required by the compiler and <b>should not be used in client code</b>. */ -object TagMaterialization { - def materializeClassTag[T: c.TypeTag](c: Context): c.Expr[ClassTag[T]] = { - import c.mirror._ - val tpe = implicitly[c.TypeTag[T]].tpe - c.materializeClassTag(tpe) - } - - def materializeTypeTag[T: c.TypeTag](c: Context { type PrefixType = Universe }): c.Expr[c.prefix.value.TypeTag[T]] = { - import c.mirror._ - val tpe = implicitly[c.TypeTag[T]].tpe - c.materializeTypeTag(tpe, requireConcreteTypeTag = false) - } - - def materializeConcreteTypeTag[T: c.TypeTag](c: Context { type PrefixType = Universe }): c.Expr[c.prefix.value.ConcreteTypeTag[T]] = { - import c.mirror._ - val tpe = implicitly[c.TypeTag[T]].tpe - c.materializeTypeTag(tpe, requireConcreteTypeTag = true) - } - - private implicit def context2utils(c0: Context) : Utils { val c: c0.type } = new { val c: c0.type = c0 } with Utils - - private abstract class Utils { - val c: Context - - import c.mirror._ - import definitions._ - - val coreTags = Map( - ByteClass.asType -> newTermName("Byte"), - ShortClass.asType -> newTermName("Short"), - CharClass.asType -> newTermName("Char"), - IntClass.asType -> newTermName("Int"), - LongClass.asType -> newTermName("Long"), - FloatClass.asType -> newTermName("Float"), - DoubleClass.asType -> newTermName("Double"), - BooleanClass.asType -> newTermName("Boolean"), - UnitClass.asType -> newTermName("Unit"), - AnyClass.asType -> newTermName("Any"), - ObjectClass.asType -> newTermName("Object"), - AnyValClass.asType -> newTermName("AnyVal"), - AnyRefClass.asType -> newTermName("AnyRef"), - NothingClass.asType -> newTermName("Nothing"), - NullClass.asType -> newTermName("Null")) - - val ReflectPackage = staticModule("scala.reflect.package") - val Reflect_mirror = selectTerm(ReflectPackage, "mirror") - val ClassTagClass = staticClass("scala.reflect.ClassTag") - val ClassTagErasure = selectTerm(ClassTagClass, "erasure") - val ClassTagModule = staticModule("scala.reflect.ClassTag") - val TypeTagsClass = staticClass("scala.reflect.api.TypeTags") - val TypeTagClass = selectType(TypeTagsClass, "TypeTag") - val TypeTagTpe = selectTerm(TypeTagClass, "tpe") - val TypeTagModule = selectTerm(TypeTagsClass, "TypeTag") - val ConcreteTypeTagClass = selectType(TypeTagsClass, "ConcreteTypeTag") - val ConcreteTypeTagModule = selectTerm(TypeTagsClass, "ConcreteTypeTag") - - def materializeClassTag(tpe: Type): Tree = { - val prefix = gen.mkAttributedRef(Reflect_mirror) setType singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror) - materializeClassTag(prefix, tpe) - } - - def materializeClassTag(prefix: Tree, tpe: Type): Tree = { - val typetagInScope = c.inferImplicitValue(appliedType(typeRef(prefix.tpe, ConcreteTypeTagClass, Nil), List(tpe))) - def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == ConcreteTypeTagModule)) - typetagInScope match { - case success if !success.isEmpty && !typetagIsSynthetic(success) => - val factory = TypeApply(Select(Ident(ClassTagModule), newTermName("apply")), List(TypeTree(tpe))) - Apply(factory, List(Select(typetagInScope, newTermName("tpe")))) - case _ => - val result = - tpe match { - case coreTpe if coreTags contains coreTpe => - Select(Ident(ClassTagModule), coreTags(coreTpe)) - case _ => - if (tpe.typeSymbol == ArrayClass) { - val componentTpe = tpe.typeArguments(0) - val classtagInScope = c.inferImplicitValue(appliedType(typeRef(NoPrefix, ClassTagClass, Nil), List(componentTpe))) - val componentTag = classtagInScope orElse materializeClassTag(prefix, componentTpe) - Select(componentTag, newTermName("wrap")) - } else { - // [Eugene] what's the intended behavior? there's no spec on ClassManifests - // for example, should we ban Array[T] or should we tag them with Array[AnyRef]? - // if its the latter, what should be the result of tagging Array[T] where T <: Int? - if (tpe.typeSymbol.isAbstractType) fail("tpe is an abstract type") - val erasure = - if (tpe.typeSymbol.isDerivedValueClass) tpe // [Eugene to Martin] is this correct? - else tpe.erasure.normalize // necessary to deal with erasures of HK types - val factory = TypeApply(Select(Ident(ClassTagModule), newTermName("apply")), List(TypeTree(tpe))) - Apply(factory, List(TypeApply(Ident(newTermName("classOf")), List(TypeTree(erasure))))) - } - } - try c.typeCheck(result) - catch { case terr @ c.TypeError(pos, msg) => fail(terr) } - } - } - - def materializeTypeTag(tpe: Type, requireConcreteTypeTag: Boolean): Tree = { - def prefix: Tree = ??? // todo. needs to be synthesized from c.prefix - materializeTypeTag(prefix, tpe, requireConcreteTypeTag) - } - - def materializeTypeTag(prefix: Tree, tpe: Type, requireConcreteTypeTag: Boolean): Tree = { - val tagModule = if (requireConcreteTypeTag) ConcreteTypeTagModule else TypeTagModule - val result = - tpe match { - case coreTpe if coreTags contains coreTpe => - Select(Select(prefix, tagModule.name), coreTags(coreTpe)) - case _ => - try c.reifyType(prefix, tpe, dontSpliceAtTopLevel = true, requireConcreteTypeTag = requireConcreteTypeTag) - catch { - case ex: Throwable => - // [Eugene] cannot pattern match on an abstract type, so had to do this - val ex1 = ex - if (ex.getClass.toString.endsWith("$ReificationError")) { - ex match { - case c.ReificationError(pos, msg) => - c.error(pos, msg) - EmptyTree - } - } else if (ex.getClass.toString.endsWith("$UnexpectedReificationError")) { - ex match { - case c.UnexpectedReificationError(pos, err, cause) => - if (cause != null) throw cause else throw ex - } - } else { - throw ex - } - } - } - try c.typeCheck(result) - catch { case terr @ c.TypeError(pos, msg) => fail(terr) } - } - - private def fail(reason: Any): Nothing = { - val Apply(TypeApply(fun, List(tpeTree)), _) = c.macroApplication - val tpe = tpeTree.tpe - val PolyType(_, MethodType(_, tagTpe)) = fun.tpe - val tagModule = tagTpe.typeSymbol.companionSymbol - if (c.compilerSettings.contains("-Xlog-implicits")) - c.echo(c.enclosingPosition, "cannot materialize " + tagModule.name + "[" + tpe + "] because:\n" + reason) - c.abort(c.enclosingPosition, "No %s available for %s".format(tagModule.name, tpe)) - } - } -} diff --git a/src/library/scala/reflect/api/AnnotationInfos.scala b/src/library/scala/reflect/api/AnnotationInfos.scala index 96a65606e5..cc1c4d2b6b 100755 --- a/src/library/scala/reflect/api/AnnotationInfos.scala +++ b/src/library/scala/reflect/api/AnnotationInfos.scala @@ -12,7 +12,7 @@ trait AnnotationInfos { self: Universe => } type ClassfileAnnotArg <: AnyRef - implicit def classfileAnnotArgManifest: ClassManifest[ClassfileAnnotArg] // need a precise manifest to pass to UnPickle's toArray call + implicit def classfileAnnotArgTag: ArrayTag[ClassfileAnnotArg] // need a precise tag to pass to UnPickle's toArray call type LiteralAnnotArg <: ClassfileAnnotArg val LiteralAnnotArg: LiteralAnnotArgExtractor diff --git a/src/library/scala/reflect/api/Attachment.scala b/src/library/scala/reflect/api/Attachment.scala index 9fa5ceb0fb..50f55b4aa5 100644 --- a/src/library/scala/reflect/api/Attachment.scala +++ b/src/library/scala/reflect/api/Attachment.scala @@ -7,8 +7,6 @@ package api * Attachments have to carry positions, because we don't want to introduce even a single additional field in Tree * imposing an unnecessary memory tax because of something that will not be used in most cases. */ -// [Eugene] with the introduction of `attach` and `payload[T]` users don't need to create custom attachments anymore -// however, we cannot move attachments to scala.reflect.internal, because they are used in Trees, which are implemented completely in scala.reflect.api trait Attachment { /** Gets the underlying position */ def pos: Position @@ -22,3 +20,10 @@ trait Attachment { /** Creates a copy of this attachment with its payload updated */ def withPayload(newPayload: Any): Attachment } + +// [Eugene] with the introduction of `attach` and `attachment[T]` users don't need to create custom attachments anymore +// however, we cannot move attachments to scala.reflect.internal, because they are used in Trees, which are implemented completely in scala.reflect.api +private[scala] case class NontrivialAttachment(pos: api.Position, payload: collection.mutable.ListBuffer[Any]) extends Attachment { + def withPos(newPos: api.Position) = copy(pos = newPos, payload = payload) + def withPayload(newPayload: Any) = copy(pos = pos, payload = newPayload.asInstanceOf[collection.mutable.ListBuffer[Any]]) +}
\ No newline at end of file diff --git a/src/library/scala/reflect/api/Exprs.scala b/src/library/scala/reflect/api/Exprs.scala index ff89a1cd48..b8db64422e 100644 --- a/src/library/scala/reflect/api/Exprs.scala +++ b/src/library/scala/reflect/api/Exprs.scala @@ -16,36 +16,4 @@ trait Exprs { self: Universe => lazy val value: T = eval override def toString = "Expr["+tpe+"]("+tree+")" } - - // [Eugene] had to move this to the companion of Tree to make stuff compile. weirdo! -// object Expr { -// // would be great if in future this generated an Expr[Magic] -// // where Magic is a magic untyped type that propagates through the entire quasiquote -// // and turns off typechecking whenever it's involved -// // that'd allow us to splice trees into quasiquotes and still have these qqs to be partially typechecked -// // see some exploration of these ideas here: https://github.com/xeno-by/alphakeplerdemo -// implicit def tree2expr(tree: Tree): Expr[Nothing] = Expr[Nothing](tree) -// implicit def expr2tree(expr: Expr[_]): Tree = expr.tree -// -// // [Eugene] good idea? -// implicit def trees2exprs(trees: List[Tree]): List[Expr[Nothing]] = trees map tree2expr -// implicit def exprs2trees(exprs: List[Expr[_]]): List[Tree] = exprs map expr2tree -// } - - // [Eugene] even weirder - implicits didn't feel at home in Trees :( - - // would be great if in future this generated an Expr[Magic] - // where Magic is a magic untyped type that propagates through the entire quasiquote - // and turns off typechecking whenever it's involved - // that'd allow us to splice trees into quasiquotes and still have these qqs to be partially typechecked - // see some exploration of these ideas here: https://github.com/xeno-by/alphakeplerdemo - // [Martin] I have some doubts whether it's god to have implicit conversions. - implicit def tree2expr(tree: Tree): Expr[Nothing] = Expr[Nothing](tree)(TypeTag.Nothing) - implicit def expr2tree(expr: Expr[_]): Tree = expr.tree - - // [Eugene] good idea? - // [Martin] probably not. - implicit def trees2exprs(trees: List[Tree]): List[Expr[Nothing]] = trees map tree2expr - implicit def exprs2trees(exprs: List[Expr[_]]): List[Tree] = exprs map expr2tree -} - +}
\ No newline at end of file diff --git a/src/library/scala/reflect/api/Reporters.scala b/src/library/scala/reflect/api/FrontEnds.scala index b7428e1599..2c1f3feff6 100644 --- a/src/library/scala/reflect/api/Reporters.scala +++ b/src/library/scala/reflect/api/FrontEnds.scala @@ -1,9 +1,9 @@ package scala.reflect package api -trait Reporters { self: Universe => +trait FrontEnds { self: Universe => - trait Reporter { + trait FrontEnd { object severity extends Enumeration class Severity(val id: Int) extends severity.Value { var count: Int = 0 @@ -18,6 +18,9 @@ trait Reporters { self: Universe => val WARNING = new Severity(1) val ERROR = new Severity(2) + def hasErrors = ERROR.count > 0 + def hasWarnings = WARNING.count > 0 + case class Info(val pos: Position, val msg: String, val severity: Severity) val infos = new collection.mutable.LinkedHashSet[Info] @@ -46,14 +49,14 @@ trait Reporters { self: Universe => } } - class SilentReporter extends Reporter { + class SilentFrontEnd extends FrontEnd { def display(info: Info) {} def interactive() {} } /** Creates a UI-less reporter that simply accumulates all the messages */ - def mkSilentReporter(): Reporter = new SilentReporter() + def mkSilentFrontEnd(): FrontEnd = new SilentFrontEnd() /** Creates a reporter that prints messages to the console according to the settings. * @@ -61,5 +64,5 @@ trait Reporters { self: Universe => * 0 stands for INFO, 1 stands for WARNING and 2 stands for ERROR. */ // todo. untangle warningsAsErrors from Reporters. I don't feel like moving this flag here! - def mkConsoleReporter(minSeverity: Int = 1): Reporter + def mkConsoleFrontEnd(minSeverity: Int = 1): FrontEnd }
\ No newline at end of file diff --git a/src/library/scala/reflect/api/Names.scala b/src/library/scala/reflect/api/Names.scala index d92d056751..96651ffa88 100755 --- a/src/library/scala/reflect/api/Names.scala +++ b/src/library/scala/reflect/api/Names.scala @@ -33,13 +33,13 @@ trait Names { /** Returns a type name that represents the same string as this name */ def toTypeName: TypeName - /** Replaces all occurrences of $op_names in this name by corresponding operator symbols. - * Example: `foo_$plus$eq` becomes `foo_+=` + /** Replaces all occurrences of \$op_names in this name by corresponding operator symbols. + * Example: `foo_\$plus\$eq` becomes `foo_+=` */ def decoded: String - /** Replaces all occurrences of operator symbols in this name by corresponding $op_names. - * Example: `foo_+=` becomes `foo_$plus$eq`. + /** Replaces all occurrences of operator symbols in this name by corresponding \$op_names. + * Example: `foo_+=` becomes `foo_\$plus\$eq`. */ def encoded: String diff --git a/src/library/scala/reflect/api/StandardDefinitions.scala b/src/library/scala/reflect/api/StandardDefinitions.scala index e457bb73e0..21f7c9283b 100755 --- a/src/library/scala/reflect/api/StandardDefinitions.scala +++ b/src/library/scala/reflect/api/StandardDefinitions.scala @@ -6,7 +6,8 @@ package scala.reflect package api -trait StandardDefinitions { self: Universe => +trait StandardTypes { + self: Universe => val ByteTpe: Type val ShortTpe: Type @@ -17,110 +18,119 @@ trait StandardDefinitions { self: Universe => val DoubleTpe: Type val BooleanTpe: Type val UnitTpe: Type + val AnyTpe: Type - val ObjectTpe: Type val AnyValTpe: Type val AnyRefTpe: Type + val ObjectTpe: Type + val NothingTpe: Type val NullTpe: Type val StringTpe: Type +} + +trait StandardDefinitions extends StandardTypes { + self: Universe => val definitions: AbsDefinitions - abstract class AbsDefinitions { - // packages - def RootPackage: Symbol - def RootClass: Symbol - def EmptyPackage: Symbol + // I intend to pull everything in here out of the public API. + trait AbsDefinitionsInternal { + def ArrayModule: Symbol + def ArrayModule_overloadedApply: Symbol + def Array_apply: Symbol + def Array_clone: Symbol + def Array_length: Symbol + def Array_update: Symbol + def ByNameParamClass: Symbol + def ClassTagModule: Symbol + def ConcreteTypeTagModule: Symbol + def ConsClass: Symbol def EmptyPackageClass: Symbol - def ScalaPackage: Symbol - def ScalaPackageClass: Symbol - def JavaLangPackage: Symbol + def FunctionClass : Array[Symbol] + def IterableClass: Symbol + def IteratorClass: Symbol + def IteratorModule: Symbol + def Iterator_apply: Symbol def JavaLangPackageClass: Symbol + def JavaRepeatedParamClass: Symbol + def ListModule: Symbol + def List_apply: Symbol + def NilModule: Symbol + def NoneModule: Symbol + def OptionClass: Symbol + def ProductClass : Array[Symbol] + def RepeatedParamClass: Symbol + def ScalaPackageClass: Symbol + def SeqClass: Symbol + def SeqModule: Symbol + def SomeClass: Symbol + def SomeModule: Symbol + def StringBuilderClass: Symbol + def SymbolClass : Symbol + def TraversableClass: Symbol + def TupleClass : Array[Symbol] + def TypeTagModule: Symbol + def ScalaPrimitiveValueClasses: List[ClassSymbol] + } + + trait AbsDefinitions extends AbsDefinitionsInternal { + // packages + def RootClass: ClassSymbol + def RootPackage: PackageSymbol + def EmptyPackage: PackageSymbol + def ScalaPackage: PackageSymbol + def JavaLangPackage: PackageSymbol // top types - def AnyClass : Symbol - def AnyValClass: Symbol - def AnyRefClass: Symbol - def ObjectClass: Symbol + def AnyClass : ClassSymbol + def AnyValClass: ClassSymbol + def ObjectClass: ClassSymbol + def AnyRefClass: TypeSymbol // bottom types - def NullClass : Symbol - def NothingClass: Symbol + def NullClass : ClassSymbol + def NothingClass: ClassSymbol // the scala value classes - def UnitClass : Symbol - def ByteClass : Symbol - def ShortClass : Symbol - def CharClass : Symbol - def IntClass : Symbol - def LongClass : Symbol - def FloatClass : Symbol - def DoubleClass : Symbol - def BooleanClass: Symbol - def ScalaPrimitiveValueClasses: List[Symbol] - - // fundamental reference classes - def SymbolClass : Symbol - def StringClass : Symbol - def ClassClass : Symbol - - // product, tuple, function - def TupleClass : Array[Symbol] - def ProductClass : Array[Symbol] - def FunctionClass : Array[Symbol] - - // Option classes - def OptionClass: Symbol - def SomeClass: Symbol - def NoneModule: Symbol - def SomeModule: Symbol + def UnitClass : ClassSymbol + def ByteClass : ClassSymbol + def ShortClass : ClassSymbol + def CharClass : ClassSymbol + def IntClass : ClassSymbol + def LongClass : ClassSymbol + def FloatClass : ClassSymbol + def DoubleClass : ClassSymbol + def BooleanClass: ClassSymbol + + // some special classes + def StringClass : ClassSymbol + def ClassClass : ClassSymbol + def ArrayClass: ClassSymbol // collections classes - def ConsClass: Symbol - def IterableClass: Symbol - def IteratorClass: Symbol - def ListClass: Symbol - def SeqClass: Symbol - def StringBuilderClass: Symbol - def TraversableClass: Symbol + def ListClass: ClassSymbol + def ListModule: ModuleSymbol // collections modules - def PredefModule: Symbol - def ListModule: Symbol - def List_apply: Symbol - def NilModule: Symbol - def SeqModule: Symbol - def IteratorModule: Symbol - def Iterator_apply: Symbol - - // arrays and their members - def ArrayModule: Symbol - def ArrayModule_overloadedApply: Symbol - def ArrayClass: Symbol - def Array_apply: Symbol - def Array_update: Symbol - def Array_length: Symbol - def Array_clone: Symbol - - // special parameter types - def ByNameParamClass: Symbol - def JavaRepeatedParamClass: Symbol - def RepeatedParamClass: Symbol + def PredefModule: ModuleSymbol // type tags - def ClassTagClass: Symbol - def ClassTagModule: Symbol - def TypeTagClass: Symbol - def TypeTagModule: Symbol - def ConcreteTypeTagClass: Symbol - def ConcreteTypeTagModule: Symbol + def ClassTagClass: ClassSymbol + def TypeTagClass: ClassSymbol + def ConcreteTypeTagClass: ClassSymbol /** Given a type T, returns the type corresponding to the VM's * representation: ClassClass's type constructor applied to `arg`. */ def vmClassType(arg: Type): Type // !!! better name? - // [Eugene] we already have arg.erasure, right? + // [Eugene] we already have arg.erasure, right? + // + // [Paul] You misunderstand the method (it could be better named). + // Given List[String], it returns java.lang.Class[List[String]] + // (or the .Net equivalent), not the erasure of List[String]. + // See def ClassType in definitions - that's what it was called before, + // and obviously that name has to go. /** The string representation used by the given type in the VM. */ diff --git a/src/library/scala/reflect/api/StandardNames.scala b/src/library/scala/reflect/api/StandardNames.scala index d39d44dd86..60c64f947a 100644 --- a/src/library/scala/reflect/api/StandardNames.scala +++ b/src/library/scala/reflect/api/StandardNames.scala @@ -1,49 +1,64 @@ /* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Martin Odersky - */ +* Copyright 2005-2011 LAMP/EPFL +* @author Martin Odersky +*/ package scala.reflect package api -trait StandardNames { self: Universe => +trait StandardNames { + self: Universe => - abstract class AbsNames { + val nme: AbsTermNames + val tpnme: AbsTypeNames + + trait AbsNames { type NameType <: Name - val EMPTY: NameType - val ANON_FUN_NAME: NameType val ANON_CLASS_NAME: NameType + val ANON_FUN_NAME: NameType + val EMPTY: NameType val EMPTY_PACKAGE_NAME: NameType + val ERROR: NameType val IMPORT: NameType val MODULE_VAR_SUFFIX: NameType - val ROOT: NameType + val NO_NAME: NameType val PACKAGE: NameType + val ROOT: NameType val SPECIALIZED_SUFFIX: NameType - - val ERROR: NameType - val NO_NAME: NameType val WILDCARD: NameType def flattenedName(segments: Name*): NameType } - val nme: AbsTermNames - - abstract class AbsTermNames extends AbsNames { + trait AbsTermNames extends AbsNames { val EXPAND_SEPARATOR_STRING: String + val IMPL_CLASS_SUFFIX: String + val INTERPRETER_IMPORT_WRAPPER: String + val INTERPRETER_LINE_PREFIX: String + val INTERPRETER_VAR_PREFIX: String + val INTERPRETER_WRAPPER_SUFFIX: String + val LOCALDUMMY_PREFIX: String + val LOCAL_SUFFIX_STRING: String + val MODULE_SUFFIX_NAME: TermName + val NAME_JOIN_NAME: TermName + val PROTECTED_PREFIX: String + val PROTECTED_SET_PREFIX: String + val SETTER_SUFFIX: TermName + val SINGLETON_SUFFIX: String + val SUPER_PREFIX_STRING: String + val TRAIT_SETTER_SEPARATOR_STRING: String val ANYNAME: TermName val CONSTRUCTOR: TermName val FAKE_LOCAL_THIS: TermName val INITIALIZER: TermName val LAZY_LOCAL: TermName - val LOCAL_SUFFIX_STRING: String - val MIRROR_PREFIX: TermName - val MIRROR_SHORT: TermName val MIRROR_FREE_PREFIX: TermName val MIRROR_FREE_THIS_SUFFIX: TermName val MIRROR_FREE_VALUE_SUFFIX: TermName + val MIRROR_PREFIX: TermName + val MIRROR_SHORT: TermName val MIRROR_SYMDEF_PREFIX: TermName val MIXIN_CONSTRUCTOR: TermName val MODULE_INSTANCE_FIELD: TermName @@ -62,11 +77,6 @@ trait StandardNames { self: Universe => val BITMAP_CHECKINIT: TermName val BITMAP_CHECKINIT_TRANSIENT: TermName - val INTERPRETER_IMPORT_WRAPPER: String - val INTERPRETER_LINE_PREFIX: String - val INTERPRETER_VAR_PREFIX: String - val INTERPRETER_WRAPPER_SUFFIX: String - val ROOTPKG: TermName val ADD: TermName @@ -93,77 +103,62 @@ trait StandardNames { self: Universe => val ZAND: TermName val ZOR: TermName - // [Eugene] this doesn't compile. why?! - val UNARY_~ : TermName - val UNARY_+ : TermName - val UNARY_- : TermName - val UNARY_! : TermName + val UNARY_~ : TermName + val UNARY_+ : TermName + val UNARY_- : TermName + val UNARY_! : TermName - // [Eugene] this doesn't compile. why?! val ??? : TermName - val MODULE_SUFFIX_NAME: TermName - val NAME_JOIN_NAME: TermName - val IMPL_CLASS_SUFFIX: String - val LOCALDUMMY_PREFIX: String - val PROTECTED_PREFIX: String - val PROTECTED_SET_PREFIX: String - val SINGLETON_SUFFIX: String - val SUPER_PREFIX_STRING: String - val TRAIT_SETTER_SEPARATOR_STRING: String - val SETTER_SUFFIX: TermName - def isConstructorName(name: Name): Boolean def isExceptionResultName(name: Name): Boolean def isImplClassName(name: Name): Boolean def isLocalDummyName(name: Name): Boolean def isLocalName(name: Name): Boolean def isLoopHeaderLabel(name: Name): Boolean + def isModuleName(name: Name): Boolean + def isOpAssignmentName(name: Name): Boolean def isProtectedAccessorName(name: Name): Boolean - def isSuperAccessorName(name: Name): Boolean def isReplWrapperName(name: Name): Boolean def isSetterName(name: Name): Boolean - def isTraitSetterName(name: Name): Boolean def isSingletonName(name: Name): Boolean - def isModuleName(name: Name): Boolean - def isOpAssignmentName(name: Name): Boolean - - def segments(name: String, assumeTerm: Boolean): List[Name] - def originalName(name: Name): Name - def stripModuleSuffix(name: Name): Name - def unspecializedName(name: Name): Name - def splitSpecializedName(name: Name): (Name, String, String) - def dropLocalSuffix(name: Name): Name + def isSuperAccessorName(name: Name): Boolean + def isTraitSetterName(name: Name): Boolean - def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName + def defaultGetterName(name: Name, pos: Int): TermName + def defaultGetterToMethod(name: Name): TermName + def expandedName(name: TermName, base: Symbol, separator: String): TermName def expandedSetterName(name: TermName, base: Symbol): TermName - def protName(name: Name): TermName - def protSetterName(name: Name): TermName def getterName(name: TermName): TermName def getterToLocal(name: TermName): TermName def getterToSetter(name: TermName): TermName + def localDummyName(clazz: Symbol): TermName def localToGetter(name: TermName): TermName + def protName(name: Name): TermName + def protSetterName(name: Name): TermName def setterToGetter(name: TermName): TermName - def defaultGetterName(name: Name, pos: Int): TermName - def defaultGetterToMethod(name: Name): TermName - - def dropSingletonName(name: Name): TypeName - def singletonName(name: Name): TypeName - def implClassName(name: Name): TypeName - def interfaceName(implname: Name): TypeName - def localDummyName(clazz: Symbol): TermName def superName(name: Name): TermName - } - val tpnme: AbsTypeNames + def dropLocalSuffix(name: Name): Name + def originalName(name: Name): Name + def stripModuleSuffix(name: Name): Name + def unspecializedName(name: Name): Name + def segments(name: String, assumeTerm: Boolean): List[Name] + def splitSpecializedName(name: Name): (Name, String, String) + } - abstract class AbsTypeNames extends AbsNames { - val REFINE_CLASS_NAME: TypeName + trait AbsTypeNames extends AbsNames { val BYNAME_PARAM_CLASS_NAME: TypeName val EQUALS_PATTERN_NAME: TypeName val JAVA_REPEATED_PARAM_CLASS_NAME: TypeName val LOCAL_CHILD: TypeName + val REFINE_CLASS_NAME: TypeName val REPEATED_PARAM_CLASS_NAME: TypeName val WILDCARD_STAR: TypeName + + def dropSingletonName(name: Name): TypeName + def implClassName(name: Name): TypeName + def interfaceName(implname: Name): TypeName + def singletonName(name: Name): TypeName } } diff --git a/src/library/scala/reflect/api/Symbols.scala b/src/library/scala/reflect/api/Symbols.scala index e47bc7216e..32faee2512 100755 --- a/src/library/scala/reflect/api/Symbols.scala +++ b/src/library/scala/reflect/api/Symbols.scala @@ -4,8 +4,101 @@ package api trait Symbols { self: Universe => type Symbol >: Null <: AbsSymbol + type TypeSymbol <: Symbol with TypeSymbolApi + type TermSymbol <: Symbol with TermSymbolApi + type MethodSymbol <: TermSymbol with MethodSymbolApi + type ModuleSymbol <: TermSymbol with ModuleSymbolApi + type PackageSymbol <: ModuleSymbol with PackageSymbolApi + type ClassSymbol <: TypeSymbol with ClassSymbolApi - abstract class AbsSymbol { this: Symbol => + val NoSymbol: Symbol + + trait TypeSymbolApi { + self: TypeSymbol => + + def name: TypeName + } + trait TermSymbolApi { + self: TermSymbol => + + def name: TermName + } + trait MethodSymbolApi extends TermSymbolApi { + self: MethodSymbol => + } + trait ClassSymbolApi extends TypeSymbolApi { + self: ClassSymbol => + } + trait ModuleSymbolApi extends TermSymbolApi { + self: ModuleSymbol => + } + trait PackageSymbolApi extends ModuleSymbolApi { + self: PackageSymbol => + } + + // I intend to pull everything in here out of the public API. + trait AbsSymbolInternal { + this: Symbol => + + /** A fresh symbol with given name `name`, position `pos` and flags `flags` that has + * the current symbol as its owner. + */ + def newNestedSymbol(name: Name, pos: Position, flags: Long, isClass: Boolean): Symbol + // needed by LiftCode !!! not enough reason to have in the api + + /** Low-level operation to set the symbol's flags + * @return the symbol itself + */ + def setInternalFlags(flags: Long): this.type + // needed by LiftCode !!! not enough reason to have in the api + + /** Set symbol's type signature to given type + * @return the symbol itself + */ + def setTypeSignature(tpe: Type): this.type + // needed by LiftCode !!! not enough reason to have in the api + + /** Set symbol's annotations to given annotations `annots`. + */ + def setAnnotations(annots: AnnotationInfo*): this.type + // needed by LiftCode !!! not enough reason to have in the api + + /** Does this symbol represent the definition of a skolem? + * Skolems are used during typechecking to represent type parameters viewed from inside their scopes. + * If yes, `isType` is also guaranteed to be true. + */ + def isSkolem : Boolean + + /** Does this symbol represent a free type captured by reification? + */ + // needed for ones who wish to inspect reified trees + def isFreeType : Boolean + + /** The type signature of this symbol. + * Note if the symbol is a member of a class, one almost always is interested + * in `typeSignatureIn` with a site type instead. + */ + def typeSignature: Type // !!! Since one should almost never use this, let's give it a different name. + + /** A type reference that refers to this type symbol + * Note if symbol is a member of a class, one almost always is interested + * in `asTypeIn` with a site type instead. + * + * Example: Given a class declaration `class C[T] { ... } `, that generates a symbol + * `C`. Then `C.asType` is the type `C[T]`. + * + * By contrast, `C.typeSignature` would be a type signature of form + * `PolyType(ClassInfoType(...))` that describes type parameters, value + * parameters, parent types, and members of `C`. + */ + def asType: Type // !!! Same as typeSignature. + + /** The kind of this symbol; used for debugging */ + def kind: String + } + + trait AbsSymbol extends AbsSymbolInternal { + this: Symbol => /** The position of this symbol */ @@ -53,7 +146,15 @@ trait Symbols { self: Universe => /** ... */ - def orElse[T](alt: => Symbol): Symbol + def orElse(alt: => Symbol): Symbol + + /** ... + */ + def filter(cond: Symbol => Boolean): Symbol + + /** ... + */ + def suchThat(cond: Symbol => Boolean): Symbol /** * Set when symbol has a modifier of the form private[X], NoSymbol otherwise. @@ -120,6 +221,11 @@ trait Symbols { self: Universe => */ def isTerm : Boolean + /** Does this symbol represent a package? + * If yes, `isTerm` is also guaranteed to be true. + */ + def isPackage : Boolean + /** Does this symbol represent the definition of method? * If yes, `isTerm` is also guaranteed to be true. */ @@ -146,6 +252,11 @@ trait Symbols { self: Universe => */ def isClass : Boolean + /** Does this symbol represent a package class? + * If yes, `isClass` is also guaranteed to be true. + */ + def isPackageClass : Boolean + /** Does this symbol represent the definition of a primitive class? * Namely, is it one of [[scala.Double]], [[scala.Float]], [[scala.Long]], [[scala.Int]], [[scala.Char]], * [[scala.Short]], [[scala.Byte]], [[scala.Unit]] or [[scala.Boolean]]? @@ -167,22 +278,11 @@ trait Symbols { self: Universe => */ def isAbstractType : Boolean - /** Does this symbol represent the definition of a skolem? - * Skolems are used during typechecking to represent type parameters viewed from inside their scopes. - * If yes, `isType` is also guaranteed to be true. - */ - def isSkolem : Boolean - /** Does this symbol represent an existentially bound type? * If yes, `isType` is also guaranteed to be true. */ def isExistential : Boolean - /** Does this symbol represent a free type captured by reification? - */ - // needed for ones who wish to inspect reified trees - def isFreeType : Boolean - /** Is the type parameter represented by this symbol contravariant? */ def isContravariant : Boolean @@ -195,29 +295,10 @@ trait Symbols { self: Universe => */ def isErroneous : Boolean - /** The type signature of this symbol. - * Note if the symbol is a member of a class, one almost always is interested - * in `typeSignatureIn` with a site type instead. - */ - def typeSignature: Type // !!! Since one should almost never use this, let's give it a different name. - /** The type signature of this symbol seen as a member of given type `site`. */ def typeSignatureIn(site: Type): Type - /** A type reference that refers to this type symbol - * Note if symbol is a member of a class, one almost always is interested - * in `asTypeIn` with a site type instead. - * - * Example: Given a class declaration `class C[T] { ... } `, that generates a symbol - * `C`. Then `C.asType` is the type `C[T]`. - * - * By contrast, `C.typeSignature` would be a type signature of form - * `PolyType(ClassInfoType(...))` that describes type parameters, value - * parameters, parent types, and members of `C`. - */ - def asType: Type // !!! Same as typeSignature. - /** A type reference that refers to this type symbol seen * as a member of given type `site`. */ @@ -245,29 +326,5 @@ trait Symbols { self: Universe => def alternatives: List[Symbol] def resolveOverloaded(pre: Type = NoPrefix, targs: Seq[Type] = List(), actuals: Seq[Type]): Symbol - - /** A fresh symbol with given name `name`, position `pos` and flags `flags` that has - * the current symbol as its owner. - */ - def newNestedSymbol(name: Name, pos: Position, flags: Long, isClass: Boolean): Symbol // needed by LiftCode !!! not enough reason to have in the api - - /** Low-level operation to set the symbol's flags - * @return the symbol itself - */ - def setInternalFlags(flags: Long): this.type // needed by LiftCode !!! not enough reason to have in the api - - /** Set symbol's type signature to given type - * @return the symbol itself - */ - def setTypeSignature(tpe: Type): this.type // needed by LiftCode !!! not enough reason to have in the api - - /** Set symbol's annotations to given annotations `annots`. - */ - def setAnnotations(annots: AnnotationInfo*): this.type // needed by LiftCode !!! not enough reason to have in the api - - /** The kind of this symbol; used for debugging */ - def kind: String } - - val NoSymbol: Symbol } diff --git a/src/library/scala/reflect/api/ToolBoxes.scala b/src/library/scala/reflect/api/ToolBoxes.scala index 387ef5163b..aefd6b511c 100644 --- a/src/library/scala/reflect/api/ToolBoxes.scala +++ b/src/library/scala/reflect/api/ToolBoxes.scala @@ -5,17 +5,17 @@ trait ToolBoxes { self: Universe => type ToolBox <: AbsToolBox - def mkToolBox(reporter: Reporter = mkSilentReporter(), options: String = ""): AbsToolBox + def mkToolBox(frontEnd: FrontEnd = mkSilentFrontEnd(), options: String = ""): AbsToolBox // [Eugene] what do you think about the interface? namely about the ``freeTypes'' part. trait AbsToolBox { - /** UI of the toolbox. + /** Front end of the toolbox. * * Accumulates and displays warnings and errors, can drop to interactive mode (if supported). * The latter can be useful to study the typechecker or to debug complex macros. */ - def reporter: Reporter + def frontEnd: FrontEnd /** Typechecks a tree using this ToolBox. * This populates symbols and types of the tree and possibly transforms it to reflect certain desugarings. diff --git a/src/library/scala/reflect/api/TreeBuildUtil.scala b/src/library/scala/reflect/api/TreeBuildUtil.scala index 32d7eefa5b..87790b3812 100644 --- a/src/library/scala/reflect/api/TreeBuildUtil.scala +++ b/src/library/scala/reflect/api/TreeBuildUtil.scala @@ -62,20 +62,34 @@ trait TreeBuildUtil { self: Universe => * @param name the name of the free variable * @param info the type signature of the free variable * @param value the value of the free variable at runtime + * @param flags (optional) flags of the free variable * @param origin debug information that tells where this symbol comes from */ - def newFreeTerm(name: String, info: Type, value: => Any, origin: String): Symbol + def newFreeTerm(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null): Symbol - /** Create a fresh free type symbol. + /** Create a fresh free non-existential type symbol. * @param name the name of the free variable * @param info the type signature of the free variable * @param value a type tag that captures the value of the free variable * is completely phantom, since the captured type cannot be propagated to the runtime * if it could be, we wouldn't be creating a free type to begin with * the only usage for it is preserving the captured symbol for compile-time analysis + * @param flags (optional) flags of the free variable * @param origin debug information that tells where this symbol comes from */ - def newFreeType(name: String, info: Type, value: => Any, origin: String): Symbol + def newFreeType(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null): Symbol + + /** Create a fresh free existential type symbol. + * @param name the name of the free variable + * @param info the type signature of the free variable + * @param value a type tag that captures the value of the free variable + * is completely phantom, since the captured type cannot be propagated to the runtime + * if it could be, we wouldn't be creating a free type to begin with + * the only usage for it is preserving the captured symbol for compile-time analysis + * @param flags (optional) flags of the free variable + * @param origin (optional) debug information that tells where this symbol comes from + */ + def newFreeExistential(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null): Symbol /** Create a Modiiers structure given internal flags, qualifier, annotations */ def modifiersFromInternalFlags(flags: Long, privateWithin: Name, annotations: List[Tree]): Modifiers @@ -124,4 +138,22 @@ trait AbsTreeGen { /** Builds a typed Select with an underlying symbol. */ def mkAttributedSelect(qual: Tree, sym: Symbol): Tree + + /** A creator for method calls, e.g. fn[T1, T2, ...](v1, v2, ...) + * There are a number of variations. + * + * @param receiver symbol of the method receiver + * @param methodName name of the method to call + * @param targs type arguments (if Nil, no TypeApply node will be generated) + * @param args value arguments + * @return the newly created trees. + */ + def mkMethodCall(receiver: Symbol, methodName: Name, targs: List[Type], args: List[Tree]): Tree + def mkMethodCall(method: Symbol, targs: List[Type], args: List[Tree]): Tree + def mkMethodCall(method: Symbol, args: List[Tree]): Tree + def mkMethodCall(target: Tree, args: List[Tree]): Tree + def mkMethodCall(receiver: Symbol, methodName: Name, args: List[Tree]): Tree + def mkMethodCall(receiver: Tree, method: Symbol, targs: List[Type], args: List[Tree]): Tree + def mkMethodCall(target: Tree, targs: List[Type], args: List[Tree]): Tree + def mkNullaryCall(method: Symbol, targs: List[Type]): Tree } diff --git a/src/library/scala/reflect/api/Trees.scala b/src/library/scala/reflect/api/Trees.scala index 7548a6bdc0..9f8906a8cd 100644 --- a/src/library/scala/reflect/api/Trees.scala +++ b/src/library/scala/reflect/api/Trees.scala @@ -85,18 +85,39 @@ trait Trees { self: Universe => def pos_=(pos: Position): Unit = rawatt = (rawatt withPos pos) // the "withPos" part is crucial to robustness def setPos(newpos: Position): this.type = { pos = newpos; this } + // [Eugene] can we make this more type-safe private var rawatt: Attachment = NoPosition - private case class NontrivialAttachment(pos: api.Position, payload: Any) extends Attachment { - def withPos(newPos: api.Position) = copy(pos = newPos, payload = payload) - def withPayload(newPayload: Any) = copy(pos = pos, payload = newPayload) - } - // todo. annotate T with ClassTag and make pattern matcher use it - // todo. support multiple attachments, and remove the assignment. only leave attach/detach -// def attachment[T]: T = rawatt.payload.asInstanceOf[T] -// def attachmentOpt[T]: Option[T] = try { Some(rawatt.payload.asInstanceOf[T]) } catch { case _: Throwable => None } - def attachment: Any = rawatt.payload - def attachment_=(att: Any): Unit = rawatt = NontrivialAttachment(pos, att) - def setAttachment(att: Any): this.type = { attachment = att; this } + def attach(att: Any): Unit = + rawatt match { + case NontrivialAttachment(pos, payload) => + val index = payload.indexWhere(p => p.getClass == att.getClass) + if (index == -1) payload += att + else payload(index) = att + case _ => + rawatt = NontrivialAttachment(pos, collection.mutable.ListBuffer[Any](att)) + } + def withAttachment(att: Any): this.type = { attach(att); this } + def detach(att: Any): Unit = + detach(att.getClass) + def detach(clazz: java.lang.Class[_]): Unit = + rawatt match { + case NontrivialAttachment(pos, payload) => + val index = payload.indexWhere(p => p.getClass == clazz) + if (index != -1) payload.remove(index) + case _ => + // do nothing + } + def withoutAttachment(att: Any): this.type = { detach(att); this } + def attachment[T: ClassTag]: T = attachmentOpt[T] getOrElse { throw new Error("no attachment of type %s".format(classTag[T].erasure)) } + def attachmentOpt[T: ClassTag]: Option[T] = + rawatt match { + case NontrivialAttachment(pos, payload) => + val index = payload.indexWhere(p => p.getClass == classTag[T].erasure) + if (index != -1) Some(payload(index).asInstanceOf[T]) + else None + case _ => + None + } private[this] var rawtpe: Type = _ @@ -257,34 +278,6 @@ trait Trees { self: Universe => override def equals(that: Any) = this eq that.asInstanceOf[AnyRef] } - // [Eugene] uh-oh - // locker.comp: - // [mkdir] Created dir: C:\Projects\Kepler\build\locker\classes\compiler - // [scalacfork] Compiling 471 files to C:\Projects\Kepler\build\locker\classes\compiler - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree - // [scalacfork] amb prefix: Importers.this.type#class Tree Importer.this.from.type#class Tree -// object Tree { -// // would be great if in future this generated an Expr[Magic] -// // where Magic is a magic untyped type that propagates through the entire quasiquote -// // and turns off typechecking whenever it's involved -// // that'd allow us to splice trees into quasiquotes and still have these qqs to be partially typechecked -// // see some exploration of these ideas here: https://github.com/xeno-by/alphakeplerdemo -// implicit def tree2expr(tree: Tree): Expr[Nothing] = Expr[Nothing](tree) -// implicit def expr2tree(expr: Expr[_]): Tree = expr.tree -// -// // [Eugene] good idea? -// implicit def trees2exprs(trees: List[Tree]): List[Expr[Nothing]] = trees map tree2expr -// implicit def exprs2trees(exprs: List[Expr[_]]): List[Tree] = exprs map expr2tree -// } - /** A tree for a term. Not all terms are TermTrees; use isTerm * to reliably identify terms. */ @@ -642,10 +635,17 @@ trait Trees { self: Universe => def Apply(sym: Symbol, args: Tree*): Tree + // TODO remove this class, add a tree attachment to Apply to track whether implicits were involved + // copying trees will all too easily forget to distinguish subclasses class ApplyToImplicitArgs(fun: Tree, args: List[Tree]) extends Apply(fun, args) + // TODO remove this class, add a tree attachment to Apply to track whether implicits were involved + // copying trees will all too easily forget to distinguish subclasses class ApplyImplicitView(fun: Tree, args: List[Tree]) extends Apply(fun, args) + // TODO: use a factory method, not a class (???) + // as a case in point of the comment that should go here by similarity to ApplyToImplicitArgs, + // this tree is considered in importers, but not in treecopier class ApplyConstructor(tpt: Tree, args: List[Tree]) extends Apply(Select(New(tpt), nme.CONSTRUCTOR), args) { override def printingPrefix = "ApplyConstructor" } @@ -697,6 +697,8 @@ trait Trees { self: Universe => def Ident(sym: Symbol): Ident + // TODO remove this class, add a tree attachment to Ident to track whether it was backquoted + // copying trees will all too easily forget to distinguish subclasses class BackQuotedIdent(name: Name) extends Ident(name) /** Marks underlying reference to id as boxed. @@ -1136,9 +1138,10 @@ trait Trees { self: Universe => def TypeApply(tree: Tree, fun: Tree, args: List[Tree]) = new TypeApply(fun, args).copyAttrs(tree) def Apply(tree: Tree, fun: Tree, args: List[Tree]) = - (tree match { + (tree match { // TODO: use a tree attachment to track whether this is an apply to implicit args or a view case _: ApplyToImplicitArgs => new ApplyToImplicitArgs(fun, args) case _: ApplyImplicitView => new ApplyImplicitView(fun, args) + // TODO: ApplyConstructor ??? case _ => new Apply(fun, args) }).copyAttrs(tree) def ApplyDynamic(tree: Tree, qual: Tree, args: List[Tree]) = @@ -1150,7 +1153,10 @@ trait Trees { self: Universe => def Select(tree: Tree, qualifier: Tree, selector: Name) = new Select(qualifier, selector).copyAttrs(tree) def Ident(tree: Tree, name: Name) = - new Ident(name).copyAttrs(tree) + (tree match { // TODO: use a tree attachment to track whether this identifier was backquoted + case _ : BackQuotedIdent => new BackQuotedIdent(name) + case _ => new Ident(name) + }).copyAttrs(tree) def ReferenceToBoxed(tree: Tree, idt: Ident) = new ReferenceToBoxed(idt).copyAttrs(tree) def Literal(tree: Tree, value: Constant) = diff --git a/src/library/scala/reflect/api/TypeTags.scala b/src/library/scala/reflect/api/TypeTags.scala index 59a7c87f44..c58b0fcec2 100644 --- a/src/library/scala/reflect/api/TypeTags.scala +++ b/src/library/scala/reflect/api/TypeTags.scala @@ -6,7 +6,7 @@ package scala.reflect package api -import scala.reflect.{ mirror => rm } +import java.lang.{ Class => jClass } import language.implicitConversions /** @@ -14,22 +14,41 @@ import language.implicitConversions * They are supposed to replace the pre-2.10 concept of a [[scala.reflect.Manifest]]. * TypeTags are much better integrated with reflection than manifests are, and are consequently much simpler. * - * Type tags are organized in a hierarchy of two classes: + * === Overview === + * + * Type tags are organized in a hierarchy of five classes: + * [[scala.reflect.ArrayTag]], [[scala.reflect.ErasureTag]], [[scala.reflect.ClassTag]], * [[scala.reflect.api.Universe#TypeTag]] and [[scala.reflect.api.Universe#ConcreteTypeTag]]. - * A [[scala.reflect.api.Universe#TypeTag]] value wraps a full Scala type in its tpe field. - * A [[scala.reflect.api.Universe#ConcreteTypeTag]] value is a type tag that is guaranteed not to contain any references to type parameters or abstract types. * - * It is also possible to capture Java classes by using a different kind of tag. - * A [[scala.reflect.ClassTag]] value wraps a Java class, which can be accessed via the erasure method. + * An [[scala.reflect.ArrayTag]] value carries knowledge about how to build an array of elements of type T. + * Typically such operation is performed by storing an erasure and instantiating arrays via Java reflection, + * but [[scala.reflect.ArrayTag]] only defines an interface, not an implementation, hence it only contains the factory methods + * `newArray` and `wrap` that can be used to build, correspondingly, single-dimensional and multi-dimensional arrays. * - * TypeTags correspond loosely to Manifests. More precisely: - * The previous notion of a [[scala.reflect.ClassManifest]] corresponds to a scala.reflect.ClassTag, - * The previous notion of a [[scala.reflect.Manifest]] corresponds to scala.reflect.mirror.ConcreteTypeTag, - * Whereas scala.reflect.mirror.TypeTag is approximated by the previous notion of [[scala.reflect.OptManifest]]. + * An [[scala.reflect.ErasureTag]] value wraps a Java class, which can be accessed via the `erasure` method. + * This notion, previously embodied in a [[scala.reflect.ClassManifest]] together with the notion of array creation, + * deserves a concept of itself. Quite often (e.g. for serialization or classloader introspection) it's useful to + * know an erasure, and only it, so we've implemented this notion in [[scala.reflect.ErasureTag]]. + * + * A [[scala.reflect.ClassTag]] is a standard implementation of both [[scala.reflect.ArrayTag]] and [[scala.reflect.ErasureTag]]. + * It guarantees that the source type T did not to contain any references to type parameters or abstract types. + * [[scala.reflect.ClassTag]] corresponds to a previous notion of [[scala.reflect.ClassManifest]]. + * + * A [[scala.reflect.api.Universe#TypeTag]] value wraps a full Scala type in its tpe field. + * A [[scala.reflect.api.Universe#ConcreteTypeTag]] value is a [[scala.reflect.api.Universe#TypeTag]] + * that is guaranteed not to contain any references to type parameters or abstract types. + * Both flavors of TypeTags also carry an erasure, so [[scala.reflect.api.Universe#TypeTag]] is also an [[scala.reflect.ErasureTag]], + * and [[scala.reflect.api.Universe#ConcreteTypeTag]] is additionally an [[scala.reflect.ArrayTag]] and a [[scala.reflect.ClassTag]] + * + * It is recommended to use the tag supertypes of to precisely express your intent, i.e.: + * use ArrayTag when you want to construct arrays, + * use ErasureTag when you need an erasure and don't mind it being generated for untagged abstract types, + * use ClassTag only when you need an erasure of a type that doesn't refer to untagged abstract types. * - * Implicit in the contract for all Tag classes is that the reified type tpe represents the type parameter T. - * Tags are typically created by the compiler, which makes sure that this contract is kept. + * === Splicing === * + * Tags can be spliced, i.e. if compiler generates a tag for a type that contains references to tagged + * type parameters or abstract type members, it will retrieve the corresponding tag and embed it into the result. * An example that illustrates the TypeTag embedding, consider the following function: * * import reflect.mirror._ @@ -43,6 +62,54 @@ import language.implicitConversions * TypeTag(<[ String => U ]>). * * Note that T has been replaced by String, because it comes with a TypeTag in f, whereas U was left as a type parameter. + * + * === ErasureTag vs ClassTag and TypeTag vs ConcreteTypeTag === + * + * Be careful with ErasureTag and TypeTag, because they will reify types even if these types are abstract. + * This makes it easy to forget to tag one of the methods in the call chain and discover it much later in the runtime + * by getting cryptic errors far away from their source. For example, consider the following snippet: + * + * def bind[T: TypeTag](name: String, value: T): IR.Result = bind((name, value)) + * def bind(p: NamedParam): IR.Result = bind(p.name, p.tpe, p.value) + * object NamedParam { + * implicit def namedValue[T: TypeTag](name: String, x: T): NamedParam = apply(name, x) + * def apply[T: TypeTag](name: String, x: T): NamedParam = new Typed[T](name, x) + * } + * + * This fragment of Scala REPL implementation defines a `bind` function that carries a named value along with its type + * into the heart of the REPL. Using a [[scala.reflect.api.Universe#TypeTag]] here is reasonable, because it is desirable + * to work with all types, even if they are type parameters or abstract type members. + * + * However if any of the three `TypeTag` context bounds is omitted, the resulting code will be incorrect, + * because the missing `TypeTag` will be transparently generated by the compiler, carrying meaningless information. + * Most likely, this problem will manifest itself elsewhere, making debugging complicated. + * If `TypeTag` context bounds were replaced with `ConcreteTypeTag`, then such errors would be reported statically. + * But in that case we wouldn't be able to use `bind` in arbitrary contexts. + * + * === Backward compatibility === + * + * TypeTags correspond loosely to Manifests. More precisely: + * The previous notion of a [[scala.reflect.ClassManifest]] corresponds to a scala.reflect.ClassTag, + * The previous notion of a [[scala.reflect.Manifest]] corresponds to scala.reflect.mirror.ConcreteTypeTag, + * Whereas scala.reflect.mirror.TypeTag is approximated by the previous notion of [[scala.reflect.OptManifest]]. + * + * In Scala 2.10, manifests are deprecated, so it's adviseable to migrate them to tags, + * because manifests might be removed in the next major release. + * + * In most cases it will be enough to replace ClassManifests with ClassTags and Manifests with ConcreteTypeTags, + * however there are a few caveats: + * + * 1) The notion of OptManifest is no longer supported. Tags can reify arbitrary types, so they are always available. + * // [Eugene] it might be useful, though, to guard against abstractness of the incoming type. + * + * 2) There's no equivalent for AnyValManifest. Consider comparing your tag with one of the core tags + * (defined in the corresponding companion objects) to find out whether it represents a primitive value class. + * + * 3) There's no replacement for factory methods defined in `ClassManifest` and `Manifest` companion objects. + * Consider assembling corresponding types using reflection API provided by Java (for classes) and Scala (for types). + * + * 4) Certain manifest functions (such as `<:<`, `>:>` and `typeArguments`) weren't included in the tag API. + * Consider using reflection API provided by Java (for classes) and Scala (for types) instead. */ trait TypeTags { self: Universe => @@ -55,21 +122,20 @@ trait TypeTags { self: Universe => * @see [[scala.reflect.api.TypeTags]] */ @annotation.implicitNotFound(msg = "No TypeTag available for ${T}") - abstract case class TypeTag[T](tpe: Type) { - // it's unsafe to use assert here, because we might run into deadlocks with Predef - // also see comments in ClassTags.scala - // assert(tpe != null) - - def sym = tpe.typeSymbol - def isConcrete = tpe.isConcrete - def notConcrete = !isConcrete - def toConcrete: ConcreteTypeTag[T] = ConcreteTypeTag[T](tpe) - - override def toString = { - var prefix = if (isConcrete) "ConcreteTypeTag" else "TypeTag" - if (prefix != this.productPrefix) prefix = "*" + prefix - prefix + "[" + tpe + "]" - } + trait TypeTag[T] extends ErasureTag[T] with Equals with Serializable { + + def tpe: Type + def sym: Symbol = tpe.typeSymbol + + def isConcrete: Boolean = tpe.isConcrete + def notConcrete: Boolean = !isConcrete + def toConcrete: ConcreteTypeTag[T] = ConcreteTypeTag[T](tpe, erasure) + + /** case class accessories */ + override def canEqual(x: Any) = x.isInstanceOf[TypeTag[_]] + override def equals(x: Any) = x.isInstanceOf[TypeTag[_]] && this.tpe == x.asInstanceOf[TypeTag[_]].tpe + override def hashCode = scala.runtime.ScalaRunTime.hash(tpe) + override def toString = if (!self.isInstanceOf[DummyMirror]) (if (isConcrete) "*ConcreteTypeTag" else "TypeTag") + "[" + tpe + "]" else "TypeTag[?]" } object TypeTag { @@ -90,8 +156,10 @@ trait TypeTags { self: Universe => val Null : TypeTag[scala.Null] = ConcreteTypeTag.Null val String : TypeTag[java.lang.String] = ConcreteTypeTag.String - def apply[T](tpe: Type): TypeTag[T] = - tpe match { + // todo. uncomment after I redo the starr + // def apply[T](tpe1: Type, erasure1: jClass[_]): TypeTag[T] = + def apply[T](tpe1: Type, erasure1: jClass[_]): TypeTag[T] = + tpe1 match { case ByteTpe => TypeTag.Byte.asInstanceOf[TypeTag[T]] case ShortTpe => TypeTag.Short.asInstanceOf[TypeTag[T]] case CharTpe => TypeTag.Char.asInstanceOf[TypeTag[T]] @@ -108,8 +176,10 @@ trait TypeTags { self: Universe => case NothingTpe => TypeTag.Nothing.asInstanceOf[TypeTag[T]] case NullTpe => TypeTag.Null.asInstanceOf[TypeTag[T]] case StringTpe => TypeTag.String.asInstanceOf[TypeTag[T]] - case _ => new TypeTag[T](tpe) {} + case _ => new TypeTag[T]{ def tpe = tpe1; def erasure = erasure1 } } + + def unapply[T](ttag: TypeTag[T]): Option[Type] = Some(ttag.tpe) } /** @@ -119,34 +189,40 @@ trait TypeTags { self: Universe => * @see [[scala.reflect.api.TypeTags]] */ @annotation.implicitNotFound(msg = "No ConcreteTypeTag available for ${T}") - class ConcreteTypeTag[T](tpe: Type) extends TypeTag[T](tpe) { - // it's unsafe to use assert here, because we might run into deadlocks with Predef - // also see comments in ClassTags.scala - //assert(isConcrete, tpe) - if (notConcrete) throw new Error("%s (%s) is not concrete and cannot be used to construct a concrete type tag".format(tpe, tpe.kind)) - override def productPrefix = "ConcreteTypeTag" + trait ConcreteTypeTag[T] extends TypeTag[T] with ClassTag[T] with Equals with Serializable { + if (!self.isInstanceOf[DummyMirror]) { + if (notConcrete) throw new Error("%s (%s) is not concrete and cannot be used to construct a concrete type tag".format(tpe, tpe.kind)) + } + + /** case class accessories */ + override def canEqual(x: Any) = x.isInstanceOf[TypeTag[_]] // this is done on purpose. TypeTag(tpe) and ConcreteTypeTag(tpe) should be equal if tpe's are equal + override def equals(x: Any) = x.isInstanceOf[TypeTag[_]] && this.tpe == x.asInstanceOf[TypeTag[_]].tpe + override def hashCode = scala.runtime.ScalaRunTime.hash(tpe) + override def toString = if (!self.isInstanceOf[DummyMirror]) "ConcreteTypeTag[" + tpe + "]" else "ConcreteTypeTag[?]" } object ConcreteTypeTag { - val Byte : ConcreteTypeTag[scala.Byte] = new ConcreteTypeTag[scala.Byte](ByteTpe) { private def readResolve() = ConcreteTypeTag.Byte } - val Short : ConcreteTypeTag[scala.Short] = new ConcreteTypeTag[scala.Short](ShortTpe) { private def readResolve() = ConcreteTypeTag.Short } - val Char : ConcreteTypeTag[scala.Char] = new ConcreteTypeTag[scala.Char](CharTpe) { private def readResolve() = ConcreteTypeTag.Char } - val Int : ConcreteTypeTag[scala.Int] = new ConcreteTypeTag[scala.Int](IntTpe) { private def readResolve() = ConcreteTypeTag.Int } - val Long : ConcreteTypeTag[scala.Long] = new ConcreteTypeTag[scala.Long](LongTpe) { private def readResolve() = ConcreteTypeTag.Long } - val Float : ConcreteTypeTag[scala.Float] = new ConcreteTypeTag[scala.Float](FloatTpe) { private def readResolve() = ConcreteTypeTag.Float } - val Double : ConcreteTypeTag[scala.Double] = new ConcreteTypeTag[scala.Double](DoubleTpe) { private def readResolve() = ConcreteTypeTag.Double } - val Boolean : ConcreteTypeTag[scala.Boolean] = new ConcreteTypeTag[scala.Boolean](BooleanTpe) { private def readResolve() = ConcreteTypeTag.Boolean } - val Unit : ConcreteTypeTag[scala.Unit] = new ConcreteTypeTag[scala.Unit](UnitTpe) { private def readResolve() = ConcreteTypeTag.Unit } - val Any : ConcreteTypeTag[scala.Any] = new ConcreteTypeTag[scala.Any](AnyTpe) { private def readResolve() = ConcreteTypeTag.Any } - val Object : ConcreteTypeTag[java.lang.Object] = new ConcreteTypeTag[java.lang.Object](ObjectTpe) { private def readResolve() = ConcreteTypeTag.Object } - val AnyVal : ConcreteTypeTag[scala.AnyVal] = new ConcreteTypeTag[scala.AnyVal](AnyValTpe) { private def readResolve() = ConcreteTypeTag.AnyVal } - val AnyRef : ConcreteTypeTag[scala.AnyRef] = new ConcreteTypeTag[scala.AnyRef](AnyRefTpe) { private def readResolve() = ConcreteTypeTag.AnyRef } - val Nothing : ConcreteTypeTag[scala.Nothing] = new ConcreteTypeTag[scala.Nothing](NothingTpe) { private def readResolve() = ConcreteTypeTag.Nothing } - val Null : ConcreteTypeTag[scala.Null] = new ConcreteTypeTag[scala.Null](NullTpe) { private def readResolve() = ConcreteTypeTag.Null } - val String : ConcreteTypeTag[java.lang.String] = new ConcreteTypeTag[java.lang.String](StringTpe) { private def readResolve() = ConcreteTypeTag.String } - - def apply[T](tpe: Type): ConcreteTypeTag[T] = - tpe match { + val Byte : ConcreteTypeTag[scala.Byte] = new ConcreteTypeTag[scala.Byte]{ def tpe = ByteTpe; def erasure = ClassTag.Byte.erasure; private def readResolve() = ConcreteTypeTag.Byte } + val Short : ConcreteTypeTag[scala.Short] = new ConcreteTypeTag[scala.Short]{ def tpe = ShortTpe; def erasure = ClassTag.Short.erasure; private def readResolve() = ConcreteTypeTag.Short } + val Char : ConcreteTypeTag[scala.Char] = new ConcreteTypeTag[scala.Char]{ def tpe = CharTpe; def erasure = ClassTag.Char.erasure; private def readResolve() = ConcreteTypeTag.Char } + val Int : ConcreteTypeTag[scala.Int] = new ConcreteTypeTag[scala.Int]{ def tpe = IntTpe; def erasure = ClassTag.Int.erasure; private def readResolve() = ConcreteTypeTag.Int } + val Long : ConcreteTypeTag[scala.Long] = new ConcreteTypeTag[scala.Long]{ def tpe = LongTpe; def erasure = ClassTag.Long.erasure; private def readResolve() = ConcreteTypeTag.Long } + val Float : ConcreteTypeTag[scala.Float] = new ConcreteTypeTag[scala.Float]{ def tpe = FloatTpe; def erasure = ClassTag.Float.erasure; private def readResolve() = ConcreteTypeTag.Float } + val Double : ConcreteTypeTag[scala.Double] = new ConcreteTypeTag[scala.Double]{ def tpe = DoubleTpe; def erasure = ClassTag.Double.erasure; private def readResolve() = ConcreteTypeTag.Double } + val Boolean : ConcreteTypeTag[scala.Boolean] = new ConcreteTypeTag[scala.Boolean]{ def tpe = BooleanTpe; def erasure = ClassTag.Boolean.erasure; private def readResolve() = ConcreteTypeTag.Boolean } + val Unit : ConcreteTypeTag[scala.Unit] = new ConcreteTypeTag[scala.Unit]{ def tpe = UnitTpe; def erasure = ClassTag.Unit.erasure; private def readResolve() = ConcreteTypeTag.Unit } + val Any : ConcreteTypeTag[scala.Any] = new ConcreteTypeTag[scala.Any]{ def tpe = AnyTpe; def erasure = ClassTag.Any.erasure; private def readResolve() = ConcreteTypeTag.Any } + val Object : ConcreteTypeTag[java.lang.Object] = new ConcreteTypeTag[java.lang.Object]{ def tpe = ObjectTpe; def erasure = ClassTag.Object.erasure; private def readResolve() = ConcreteTypeTag.Object } + val AnyVal : ConcreteTypeTag[scala.AnyVal] = new ConcreteTypeTag[scala.AnyVal]{ def tpe = AnyValTpe; def erasure = ClassTag.AnyVal.erasure; private def readResolve() = ConcreteTypeTag.AnyVal } + val AnyRef : ConcreteTypeTag[scala.AnyRef] = new ConcreteTypeTag[scala.AnyRef]{ def tpe = AnyRefTpe; def erasure = ClassTag.AnyRef.erasure; private def readResolve() = ConcreteTypeTag.AnyRef } + val Nothing : ConcreteTypeTag[scala.Nothing] = new ConcreteTypeTag[scala.Nothing]{ def tpe = NothingTpe; def erasure = ClassTag.Nothing.erasure; private def readResolve() = ConcreteTypeTag.Nothing } + val Null : ConcreteTypeTag[scala.Null] = new ConcreteTypeTag[scala.Null]{ def tpe = NullTpe; def erasure = ClassTag.Null.erasure; private def readResolve() = ConcreteTypeTag.Null } + val String : ConcreteTypeTag[java.lang.String] = new ConcreteTypeTag[java.lang.String]{ def tpe = StringTpe; def erasure = ClassTag.String.erasure; private def readResolve() = ConcreteTypeTag.String } + + // todo. uncomment after I redo the starr + // def apply[T](tpe1: Type, erasure1: jClass[_]): ConcreteTypeTag[T] = + def apply[T](tpe1: Type, erasure1: jClass[_] = null): ConcreteTypeTag[T] = + tpe1 match { case ByteTpe => ConcreteTypeTag.Byte.asInstanceOf[ConcreteTypeTag[T]] case ShortTpe => ConcreteTypeTag.Short.asInstanceOf[ConcreteTypeTag[T]] case CharTpe => ConcreteTypeTag.Char.asInstanceOf[ConcreteTypeTag[T]] @@ -163,26 +239,10 @@ trait TypeTags { self: Universe => case NothingTpe => ConcreteTypeTag.Nothing.asInstanceOf[ConcreteTypeTag[T]] case NullTpe => ConcreteTypeTag.Null.asInstanceOf[ConcreteTypeTag[T]] case StringTpe => ConcreteTypeTag.String.asInstanceOf[ConcreteTypeTag[T]] - case _ => new ConcreteTypeTag[T](tpe) {} + case _ => new ConcreteTypeTag[T]{ def tpe = tpe1; def erasure = erasure1 } } def unapply[T](ttag: TypeTag[T]): Option[Type] = if (ttag.isConcrete) Some(ttag.tpe) else None - - implicit def toClassTag[T](ttag: rm.ConcreteTypeTag[T]): ClassTag[T] = ClassTag[T](rm.typeToClass(ttag.tpe.erasure)) - - implicit def toDeprecatedManifestApis[T](ttag: rm.ConcreteTypeTag[T]): DeprecatedManifestApis[T] = new DeprecatedManifestApis[T](ttag) - - // this class should not be used directly in client code - class DeprecatedManifestApis[T](ttag: rm.ConcreteTypeTag[T]) extends DeprecatedClassManifestApis[T](toClassTag(ttag)) { - @deprecated("Use `tpe` to analyze the underlying type", "2.10.0") - def <:<(that: Manifest[_]): Boolean = ttag.tpe <:< that.tpe - - @deprecated("Use `tpe` to analyze the underlying type", "2.10.0") - def >:>(that: Manifest[_]): Boolean = that <:< ttag - - @deprecated("Use `tpe` to analyze the type arguments", "2.10.0") - override def typeArguments: List[Manifest[_]] = ttag.tpe.typeArguments map (targ => rm.ConcreteTypeTag(targ)) - } } // incantations for summoning diff --git a/src/library/scala/reflect/api/Types.scala b/src/library/scala/reflect/api/Types.scala index 5e1c1af2fe..e06bb37cba 100755 --- a/src/library/scala/reflect/api/Types.scala +++ b/src/library/scala/reflect/api/Types.scala @@ -53,14 +53,26 @@ trait Types { self: Universe => */ def typeArguments: List[Type] + /** For a (potentially wrapped) poly type, its type parameters, + * the empty list for all other types */ + def typeParams: List[Symbol] + /** Is this type a type constructor that is missing its type arguments? */ def isHigherKinded: Boolean // !!! This should be called "isTypeConstructor", no? - /** Does this type refer to abstract types or is an abstract type? + /** Returns the corresponding type constructor (e.g. List for List[T] or List[String]) + */ + def typeConstructor: Type + + /** Does this type refer to spliceable types or is a spliceable type? */ def isConcrete: Boolean + /** Is this type an abstract type that needs to be resolved? + */ + def isSpliceable: Boolean + /** * Expands type aliases and converts higher-kinded TypeRefs to PolyTypes. * Functions on types are also implemented as PolyTypes. @@ -257,6 +269,7 @@ trait Types { self: Universe => * (T # x).type SingleType(T, x) * p.x.type SingleType(p.type, x) * x.type SingleType(NoPrefix, x) + * }}} */ type SingleType <: SingletonType diff --git a/src/library/scala/reflect/api/Universe.scala b/src/library/scala/reflect/api/Universe.scala index d1f546608e..9670780522 100755 --- a/src/library/scala/reflect/api/Universe.scala +++ b/src/library/scala/reflect/api/Universe.scala @@ -1,5 +1,6 @@ package scala.reflect package api + import language.experimental.macros abstract class Universe extends Symbols @@ -19,7 +20,7 @@ abstract class Universe extends Symbols with ClassLoaders with TreeBuildUtil with ToolBoxes - with Reporters + with FrontEnds with Importers { /** Given an expression, generate a tree that when compiled and executed produces the original tree. @@ -64,26 +65,7 @@ abstract class Universe extends Symbols object Universe { def reify[T](cc: scala.reflect.makro.Context{ type PrefixType = Universe })(expr: cc.Expr[T]): cc.Expr[cc.prefix.value.Expr[T]] = { - import cc.mirror._ - try cc.reifyTree(cc.prefix, expr) - catch { - case ex: Throwable => - // [Eugene] cannot pattern match on an abstract type, so had to do this - val ex1 = ex - if (ex.getClass.toString.endsWith("$ReificationError")) { - ex match { - case cc.ReificationError(pos, msg) => - cc.error(pos, msg) - EmptyTree - } - } else if (ex.getClass.toString.endsWith("$UnexpectedReificationError")) { - ex match { - case cc.UnexpectedReificationError(pos, err, cause) => - if (cause != null) throw cause else throw ex - } - } else { - throw ex - } - } + import scala.reflect.makro.internal._ + cc.Expr(cc.materializeExpr(cc.prefix.tree, expr.tree)) } } diff --git a/src/library/scala/reflect/makro/Context.scala b/src/library/scala/reflect/makro/Context.scala index 5ce801e2e6..b8fb0dcce5 100644 --- a/src/library/scala/reflect/makro/Context.scala +++ b/src/library/scala/reflect/makro/Context.scala @@ -12,7 +12,7 @@ trait Context extends Aliases with Infrastructure with Names with Reifiers - with Reporters + with FrontEnds with Settings with Symbols with Typers @@ -34,28 +34,11 @@ trait Context extends Aliases object Context { def reify[T](cc: Context{ type PrefixType = Context })(expr: cc.Expr[T]): cc.Expr[cc.prefix.value.Expr[T]] = { import cc.mirror._ + import scala.reflect.makro.internal._ // [Eugene] how do I typecheck this without undergoing this tiresome (and, in general, incorrect) procedure? - val prefix: Tree = Select(cc.prefix, newTermName("mirror")) + val prefix: Tree = Select(cc.prefix.tree, newTermName("mirror")) val prefixTpe = cc.typeCheck(TypeApply(Select(prefix, newTermName("asInstanceOf")), List(SingletonTypeTree(prefix)))).tpe prefix setType prefixTpe - try cc.reifyTree(prefix, expr) - catch { - case ex: Throwable => - // [Eugene] cannot pattern match on an abstract type, so had to do this - if (ex.getClass.toString.endsWith("$ReificationError")) { - ex match { - case cc.ReificationError(pos, msg) => - cc.error(pos, msg) - EmptyTree - } - } else if (ex.getClass.toString.endsWith("$UnexpectedReificationError")) { - ex match { - case cc.UnexpectedReificationError(pos, err, cause) => - if (cause != null) throw cause else throw ex - } - } else { - throw ex - } - } + cc.Expr(cc.materializeExpr(prefix, expr.tree)) } } diff --git a/src/library/scala/reflect/makro/Reporters.scala b/src/library/scala/reflect/makro/FrontEnds.scala index 7341b0e0b7..a1e24dcea3 100644 --- a/src/library/scala/reflect/makro/Reporters.scala +++ b/src/library/scala/reflect/makro/FrontEnds.scala @@ -1,14 +1,14 @@ package scala.reflect.makro -trait Reporters { +trait FrontEnds { self: Context => import mirror._ /** Exposes means to control the compiler UI */ - def reporter: Reporter - def setReporter(reporter: Reporter): this.type - def withReporter[T](reporter: Reporter)(op: => T): T + def frontEnd: FrontEnd + def setFrontEnd(frontEnd: FrontEnd): this.type + def withFrontEnd[T](frontEnd: FrontEnd)(op: => T): T /** For sending a message which should not be labeled as a warning/error, * but also shouldn't require -verbose to be visible. diff --git a/src/library/scala/reflect/makro/Reifiers.scala b/src/library/scala/reflect/makro/Reifiers.scala index d690df6aee..b1de8d9957 100644 --- a/src/library/scala/reflect/makro/Reifiers.scala +++ b/src/library/scala/reflect/makro/Reifiers.scala @@ -46,7 +46,12 @@ trait Reifiers { * The produced tree will be bound to the mirror specified by ``prefix'' (also see ``reflectMirrorPrefix''). * For more information and examples see the documentation for ``Context.reifyTree'' and ``Universe.reify''. */ - def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Tree + def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, concrete: Boolean = false): Tree + + /** Given a type, generate a tree that when compiled and executed produces the erasure of the original type. + * If ``concrete'' is true, then this function will bail on types, whose erasure includes abstract types (like `ClassTag` does). + */ + def reifyErasure(tpe: Type, concrete: Boolean = true): Tree /** Undoes reification of a tree. * @@ -63,20 +68,10 @@ trait Reifiers { * 3) compileAndEval(unreifyTree(reifyTree(tree))) ~ compileAndEval(tree) // at runtime original and unreified trees are behaviorally equivalent */ def unreifyTree(tree: Tree): Tree +} - /** Represents an error during reification - */ - type ReificationError <: Throwable - val ReificationError: ReificationErrorExtractor - abstract class ReificationErrorExtractor { - def unapply(error: ReificationError): Option[(Position, String)] - } +// made these guys non path-dependent, otherwise exception handling quickly becomes a mess - /** Wraps an unexpected error during reification - */ - type UnexpectedReificationError <: Throwable - val UnexpectedReificationError: UnexpectedReificationErrorExtractor - abstract class UnexpectedReificationErrorExtractor { - def unapply(error: UnexpectedReificationError): Option[(Position, String, Throwable)] - } -} +case class ReificationError(var pos: reflect.api.Position, val msg: String) extends Throwable(msg) + +case class UnexpectedReificationError(val pos: reflect.api.Position, val msg: String, val cause: Throwable = null) extends Throwable(msg, cause)
\ No newline at end of file diff --git a/src/library/scala/reflect/makro/Symbols.scala b/src/library/scala/reflect/makro/Symbols.scala index 91a5f6d8a5..ca1c17534c 100644 --- a/src/library/scala/reflect/makro/Symbols.scala +++ b/src/library/scala/reflect/makro/Symbols.scala @@ -14,4 +14,11 @@ trait Symbols { * With `isLocatable' it's possible to check whether a tree can be retained as is, or it needs special treatment. */ def isLocatable(sym: Symbol): Boolean + + /** Is this symbol static (i.e. with no outer instance)? + * Q: When exactly is a sym marked as STATIC? + * A: If it's a member of a toplevel object, or of an object contained in a toplevel object, or any number of levels deep. + * http://groups.google.com/group/scala-internals/browse_thread/thread/d385bcd60b08faf6 + */ + def isStatic(sym: Symbol): Boolean }
\ No newline at end of file diff --git a/src/library/scala/reflect/makro/Typers.scala b/src/library/scala/reflect/makro/Typers.scala index 1ced2daccd..c62c5f254c 100644 --- a/src/library/scala/reflect/makro/Typers.scala +++ b/src/library/scala/reflect/makro/Typers.scala @@ -29,7 +29,7 @@ trait Typers { * * If ``silent'' is false, ``TypeError'' will be thrown in case of a typecheck error. * If ``silent'' is true, the typecheck is silent and will return ``EmptyTree'' if an error occurs. - * Such errors don't vanish and can be inspected by turning on -Ymacro-debug. + * Such errors don't vanish and can be inspected by turning on -Ymacro-debug-verbose. * Unlike in ``inferImplicitValue'' and ``inferImplicitView'', ``silent'' is false by default. * * Typechecking can be steered with the following optional parameters: diff --git a/src/library/scala/reflect/makro/internal/Utils.scala b/src/library/scala/reflect/makro/internal/Utils.scala index db658fd637..3af58e1c88 100644 --- a/src/library/scala/reflect/makro/internal/Utils.scala +++ b/src/library/scala/reflect/makro/internal/Utils.scala @@ -7,6 +7,20 @@ import language.experimental.macros /** This package is required by the compiler and <b>should not be used in client code</b>. */ package object internal { /** This method is required by the compiler and <b>should not be used in client code</b>. */ + def materializeArrayTag[T](u: Universe): ArrayTag[T] = macro materializeArrayTag_impl[T] + + /** This method is required by the compiler and <b>should not be used in client code</b>. */ + def materializeArrayTag_impl[T: c.TypeTag](c: Context)(u: c.Expr[Universe]): c.Expr[ArrayTag[T]] = + c.Expr[Nothing](c.materializeArrayTag(u.tree, implicitly[c.TypeTag[T]].tpe))(c.TypeTag.Nothing) + + /** This method is required by the compiler and <b>should not be used in client code</b>. */ + def materializeErasureTag[T](u: Universe): ErasureTag[T] = macro materializeErasureTag_impl[T] + + /** This method is required by the compiler and <b>should not be used in client code</b>. */ + def materializeErasureTag_impl[T: c.TypeTag](c: Context)(u: c.Expr[Universe]): c.Expr[ErasureTag[T]] = + c.Expr[Nothing](c.materializeErasureTag(u.tree, implicitly[c.TypeTag[T]].tpe, concrete = false))(c.TypeTag.Nothing) + + /** This method is required by the compiler and <b>should not be used in client code</b>. */ def materializeClassTag[T](u: Universe): ClassTag[T] = macro materializeClassTag_impl[T] /** This method is required by the compiler and <b>should not be used in client code</b>. */ @@ -18,14 +32,14 @@ package object internal { /** This method is required by the compiler and <b>should not be used in client code</b>. */ def materializeTypeTag_impl[T: c.TypeTag](c: Context)(u: c.Expr[Universe]): c.Expr[u.value.TypeTag[T]] = - c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, requireConcreteTypeTag = false))(c.TypeTag.Nothing) + c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, concrete = false))(c.TypeTag.Nothing) /** This method is required by the compiler and <b>should not be used in client code</b>. */ def materializeConcreteTypeTag[T](u: Universe): u.ConcreteTypeTag[T] = macro materializeConcreteTypeTag_impl[T] /** This method is required by the compiler and <b>should not be used in client code</b>. */ def materializeConcreteTypeTag_impl[T: c.TypeTag](c: Context)(u: c.Expr[Universe]): c.Expr[u.value.ConcreteTypeTag[T]] = - c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, requireConcreteTypeTag = true))(c.TypeTag.Nothing) + c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, concrete = true))(c.TypeTag.Nothing) /** This method is required by the compiler and <b>should not be used in client code</b>. */ private[scala] implicit def context2utils(c0: Context) : Utils { val c: c0.type } = new { val c: c0.type = c0 } with Utils @@ -53,76 +67,70 @@ package internal { AnyValClass.asType -> newTermName("AnyVal"), AnyRefClass.asType -> newTermName("AnyRef"), NothingClass.asType -> newTermName("Nothing"), - NullClass.asType -> newTermName("Null")) - - def materializeClassTag(prefix: Tree, tpe: Type): Tree = { - val typetagInScope = c.inferImplicitValue(appliedType(typeRef(prefix.tpe, ConcreteTypeTagClass, Nil), List(tpe))) - def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == ConcreteTypeTagModule)) - typetagInScope match { - case success if !success.isEmpty && !typetagIsSynthetic(success) => - val factory = TypeApply(Select(Ident(ClassTagModule), newTermName("apply")), List(TypeTree(tpe))) - Apply(factory, List(Select(typetagInScope, newTermName("tpe")))) - case _ => - val result = - tpe match { - case coreTpe if coreTags contains coreTpe => - Select(Ident(ClassTagModule), coreTags(coreTpe)) - case _ => - if (tpe.typeSymbol == ArrayClass) { - val componentTpe = tpe.typeArguments(0) - val classtagInScope = c.inferImplicitValue(appliedType(typeRef(NoPrefix, ClassTagClass, Nil), List(componentTpe))) - val componentTag = classtagInScope orElse materializeClassTag(prefix, componentTpe) - Select(componentTag, newTermName("wrap")) - } else { - // [Eugene] what's the intended behavior? there's no spec on ClassManifests - // for example, should we ban Array[T] or should we tag them with Array[AnyRef]? - // if its the latter, what should be the result of tagging Array[T] where T <: Int? - if (tpe.typeSymbol.isAbstractType) fail("tpe is an abstract type") - val erasure = - if (tpe.typeSymbol.isDerivedValueClass) tpe // [Eugene to Martin] is this correct? - else tpe.erasure.normalize // necessary to deal with erasures of HK types - val factory = TypeApply(Select(Ident(ClassTagModule), newTermName("apply")), List(TypeTree(tpe))) - Apply(factory, List(TypeApply(Ident(newTermName("classOf")), List(TypeTree(erasure))))) - } - } - try c.typeCheck(result) - catch { case terr @ c.TypeError(pos, msg) => fail(terr) } - } + NullClass.asType -> newTermName("Null"), + StringClass.asType -> newTermName("String")) + + // todo. the following two methods won't be necessary once we implement implicit macro generators for tags + + def materializeArrayTag(prefix: Tree, tpe: Type): Tree = + materializeClassTag(prefix, tpe) + + def materializeErasureTag(prefix: Tree, tpe: Type, concrete: Boolean): Tree = + if (concrete) materializeClassTag(prefix, tpe) else materializeTypeTag(prefix, tpe, concrete = false) + + def materializeClassTag(prefix: Tree, tpe: Type): Tree = + materializeTag(prefix, tpe, ClassTagModule, { + val erasure = c.reifyErasure(tpe, concrete = true) + val factory = TypeApply(Select(Ident(ClassTagModule), "apply"), List(TypeTree(tpe))) + Apply(factory, List(erasure)) + }) + + def materializeTypeTag(prefix: Tree, tpe: Type, concrete: Boolean): Tree = { + val tagModule = if (concrete) ConcreteTypeTagModule else TypeTagModule + materializeTag(prefix, tpe, tagModule, c.reifyType(prefix, tpe, dontSpliceAtTopLevel = true, concrete = concrete)) } - def materializeTypeTag(prefix: Tree, tpe: Type, requireConcreteTypeTag: Boolean): Tree = { - val tagModule = if (requireConcreteTypeTag) ConcreteTypeTagModule else TypeTagModule + private def materializeTag(prefix: Tree, tpe: Type, tagModule: Symbol, materializer: => Tree): Tree = { val result = tpe match { case coreTpe if coreTags contains coreTpe => - Select(Select(prefix, tagModule.name), coreTags(coreTpe)) + val ref = if (tagModule.owner.isPackageClass) Ident(tagModule) else Select(prefix, tagModule.name) + Select(ref, coreTags(coreTpe)) case _ => - try c.reifyType(prefix, tpe, dontSpliceAtTopLevel = true, requireConcreteTypeTag = requireConcreteTypeTag) - catch { - case ex: Throwable => - // [Eugene] cannot pattern match on an abstract type, so had to do this - val ex1 = ex - if (ex.getClass.toString.endsWith("$ReificationError")) { - ex match { - case c.ReificationError(pos, msg) => - c.error(pos, msg) - EmptyTree - } - } else if (ex.getClass.toString.endsWith("$UnexpectedReificationError")) { - ex match { - case c.UnexpectedReificationError(pos, err, cause) => - if (cause != null) throw cause else throw ex - } - } else { - throw ex - } - } + val manifestInScope = nonSyntheticManifestInScope(tpe) + if (manifestInScope.isEmpty) translatingReificationErrors(materializer) + else gen.mkMethodCall(staticModule("scala.reflect.package"), newTermName("manifestToConcreteTypeTag"), List(tpe), List(manifestInScope)) } try c.typeCheck(result) - catch { case terr @ c.TypeError(pos, msg) => fail(terr) } + catch { case terr @ c.TypeError(pos, msg) => failTag(terr) } + } + + private def nonSyntheticManifestInScope(tpe: Type) = { + val ManifestClass = staticClass("scala.reflect.Manifest") + val ManifestModule = staticModule("scala.reflect.Manifest") + val manifest = c.inferImplicitValue(appliedType(ManifestClass.asTypeConstructor, List(tpe))) + val notOk = manifest.isEmpty || (manifest exists (sub => sub.symbol != null && (sub.symbol == ManifestModule || sub.symbol.owner == ManifestModule))) + if (notOk) EmptyTree else manifest } - private def fail(reason: Any): Nothing = { + def materializeExpr(prefix: Tree, expr: Tree): Tree = { + val result = translatingReificationErrors(c.reifyTree(prefix, expr)) + try c.typeCheck(result) + catch { case terr @ c.TypeError(pos, msg) => failExpr(terr) } + } + + private def translatingReificationErrors(materializer: => Tree): Tree = { + try materializer + catch { + case ReificationError(pos, msg) => + c.error(pos.asInstanceOf[c.Position], msg) // this cast is a very small price for the sanity of exception handling + EmptyTree + case UnexpectedReificationError(pos, err, cause) if cause != null => + throw cause + } + } + + private def failTag(reason: Any): Nothing = { val Apply(TypeApply(fun, List(tpeTree)), _) = c.macroApplication val tpe = tpeTree.tpe val PolyType(_, MethodType(_, tagTpe)) = fun.tpe @@ -131,5 +139,8 @@ package internal { c.echo(c.enclosingPosition, "cannot materialize " + tagModule.name + "[" + tpe + "] because:\n" + reason) c.abort(c.enclosingPosition, "No %s available for %s".format(tagModule.name, tpe)) } + + private def failExpr(reason: Any): Nothing = + c.abort(c.enclosingPosition, "Cannot materialize Expr because:\n" + reason) } } diff --git a/src/library/scala/reflect/makro/internal/macroImpl.scala b/src/library/scala/reflect/makro/internal/macroImpl.scala index 86600ba0a1..9cf4d23072 100644 --- a/src/library/scala/reflect/makro/internal/macroImpl.scala +++ b/src/library/scala/reflect/makro/internal/macroImpl.scala @@ -2,4 +2,4 @@ package scala.reflect.makro package internal /** This type is required by the compiler and <b>should not be used in client code</b>. */ -class macroImpl(val referenceToMacroImpl: Any) extends StaticAnnotation +class macroImpl(val referenceToMacroImpl: Any) extends annotation.StaticAnnotation diff --git a/src/library/scala/reflect/package.scala b/src/library/scala/reflect/package.scala index 1738642932..38a144cd49 100644 --- a/src/library/scala/reflect/package.scala +++ b/src/library/scala/reflect/package.scala @@ -3,6 +3,7 @@ package scala package object reflect { import ReflectionUtils._ + import scala.compat.Platform.EOL // !!! This was a val; we can't throw exceptions that aggressively without breaking // non-standard environments, e.g. google app engine. I made it a lazy val, but @@ -10,17 +11,30 @@ package object reflect { // initialization, but in response to a doomed attempt to utilize it. // todo. default mirror (a static object) might become a source for memory leaks (because it holds a strong reference to a classloader)! - lazy val mirror: api.Mirror = mkMirror(defaultReflectionClassLoader) + lazy val mirror: api.Mirror = + try mkMirror(defaultReflectionClassLoader) + catch { + case ex: UnsupportedOperationException => + new DummyMirror(defaultReflectionClassLoader) + } + + private[scala] def mirrorDiagnostics(cl: ClassLoader): String = """ + | + | This error has happened because `scala.reflect.runtime.package` located in + | scala-compiler.jar cannot be loaded. Classloader you are using is: + | %s. + | + | For the instructions for some of the situations that might be relevant + | visit our knowledge base at https://gist.github.com/2391081. + """.stripMargin('|').format(show(cl)) def mkMirror(classLoader: ClassLoader): api.Mirror = { - // we use (Java) reflection here so that we can keep reflect.runtime and reflect.internals in a seperate jar - // note that we must instantiate the mirror with current classloader, otherwise we won't be able to cast it to api.Mirror - // that's not a problem, though, because mirror can service classes from arbitrary classloaders - val instance = invokeFactoryOpt(getClass.getClassLoader, "scala.reflect.runtime.package", "mkMirror", classLoader) + val coreClassLoader = getClass.getClassLoader + val instance = invokeFactoryOpt(coreClassLoader, "scala.reflect.runtime.package", "mkMirror", classLoader) instance match { case Some(x: api.Mirror) => x - case Some(_) => throw new UnsupportedOperationException("Available scala reflection implementation is incompatible with this interface") - case None => throw new UnsupportedOperationException("Scala reflection not available on this platform") + case Some(_) => throw new UnsupportedOperationException("Available scala reflection implementation is incompatible with this interface." + mirrorDiagnostics(coreClassLoader)) + case None => throw new UnsupportedOperationException("Scala reflection not available on this platform." + mirrorDiagnostics(coreClassLoader)) } } @@ -39,20 +53,9 @@ package object reflect { @deprecated("Use `@scala.beans.ScalaBeanInfo` instead", "2.10.0") type ScalaBeanInfo = scala.beans.ScalaBeanInfo - @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0") - type ClassManifest[T] = ClassTag[T] - @deprecated("OptManifest is no longer supported, and using it may lead to incorrect results, Use `@scala.reflect.TypeTag` instead", "2.10.0") - type OptManifest[T] = TypeTag[T] - @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0") - type Manifest[T] = ConcreteTypeTag[T] - - @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0") - val ClassManifest = ClassTag - @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0") - lazy val Manifest = ConcreteTypeTag - @deprecated("NoManifest is no longer supported, and using it may lead to incorrect results, Use `@scala.reflect.TypeTag` instead", "2.10.0") - object NoManifest extends OptManifest[Nothing](scala.reflect.mirror.definitions.NothingClass.asType) with Serializable - + // ArrayTag trait is defined separately from the mirror + // ErasureTag trait is defined separately from the mirror + // ConcreteErasureTag trait is defined separately from the mirror // ClassTag class is defined separately from the mirror type TypeTag[T] = scala.reflect.mirror.TypeTag[T] type ConcreteTypeTag[T] = scala.reflect.mirror.ConcreteTypeTag[T] @@ -60,4 +63,8 @@ package object reflect { // ClassTag object is defined separately from the mirror lazy val TypeTag = scala.reflect.mirror.TypeTag lazy val ConcreteTypeTag = scala.reflect.mirror.ConcreteTypeTag + + def arrayTagToClassManifest[T](tag: ArrayTag[T]): ClassManifest[T] = TagInterop.arrayTagToClassManifest[T](tag) + def concreteTypeTagToManifest[T](tag: ConcreteTypeTag[T]): Manifest[T] = TagInterop.concreteTypeTagToManifest[T](tag) + def manifestToConcreteTypeTag[T](tag: Manifest[T]): ConcreteTypeTag[T] = TagInterop.manifestToConcreteTypeTag[T](tag) } diff --git a/src/library/scala/runtime/AbstractPartialFunction.scala b/src/library/scala/runtime/AbstractPartialFunction.scala index 2e435d8a7e..f499350ce9 100644 --- a/src/library/scala/runtime/AbstractPartialFunction.scala +++ b/src/library/scala/runtime/AbstractPartialFunction.scala @@ -36,7 +36,7 @@ abstract class AbstractPartialFunction[@specialized(scala.Int, scala.Long, scala // let's not make it final so as not to confuse anyone /*final*/ def apply(x: T1): R = applyOrElse(x, PartialFunction.empty) - override final def andThen[C](k: R => C) : PartialFunction[T1, C] = + @annotation.unspecialized override final def andThen[C](k: R => C) : PartialFunction[T1, C] = new AbstractPartialFunction[T1, C] { def isDefinedAt(x: T1): Boolean = self.isDefinedAt(x) override def applyOrElse[A1 <: T1, C1 >: C](x: A1, default: A1 => C1): C1 = @@ -61,8 +61,8 @@ abstract class AbstractPartialFunction[@specialized(scala.Int, scala.Long, scala */ abstract class AbstractTotalFunction[@specialized(scala.Int, scala.Long, scala.Float, scala.Double, scala.AnyRef) -T1, @specialized(scala.Unit, scala.Boolean, scala.Int, scala.Float, scala.Long, scala.Double, scala.AnyRef) +R] extends Function1[T1, R] with PartialFunction[T1, R] { final def isDefinedAt(x: T1): Boolean = true - override final def applyOrElse[A1 <: T1, B1 >: R](x: A1, default: A1 => B1): B1 = apply(x) - override final def orElse[A1 <: T1, B1 >: R](that: PartialFunction[A1, B1]): PartialFunction[A1, B1] = this + @annotation.unspecialized override final def applyOrElse[A1 <: T1, B1 >: R](x: A1, default: A1 => B1): B1 = apply(x) + @annotation.unspecialized override final def orElse[A1 <: T1, B1 >: R](that: PartialFunction[A1, B1]): PartialFunction[A1, B1] = this //TODO: check generated code for PF literal here - override final def andThen[C](k: R => C): PartialFunction[T1, C] = { case x => k(apply(x)) } + @annotation.unspecialized override final def andThen[C](k: R => C): PartialFunction[T1, C] = { case x => k(apply(x)) } } diff --git a/src/library/scala/runtime/RichInt.scala b/src/library/scala/runtime/RichInt.scala index cf5aab0be4..d03968212f 100644 --- a/src/library/scala/runtime/RichInt.scala +++ b/src/library/scala/runtime/RichInt.scala @@ -9,7 +9,6 @@ package scala.runtime import scala.collection.immutable.Range -import annotation.bridge // Note that this does not implement IntegralProxy[Int] so that it can return // the Int-specific Range class from until/to. @@ -37,9 +36,6 @@ final class RichInt(val self: Int) extends ScalaNumberProxy[Int] with RangedProx */ def until(end: Int, step: Int): Range = Range(self, end, step) -// @bridge -// def until(end: Int): Range with Range.ByOne = new Range(self, end, 1) with Range.ByOne - /** like `until`, but includes the last index */ /** * @param end The final bound of the range to make. @@ -56,9 +52,6 @@ final class RichInt(val self: Int) extends ScalaNumberProxy[Int] with RangedProx */ def to(end: Int, step: Int): Range.Inclusive = Range.inclusive(self, end, step) -// @bridge -// def to(end: Int): Range with Range.ByOne = new Range.Inclusive(self, end, 1) with Range.ByOne - /** * @return `'''this'''` if `'''this''' < that` or `that` otherwise */ diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 7a932c21bc..9d67644d61 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -47,21 +47,29 @@ object ScalaRunTime { names.toSet } + /** Return the class object representing an array with element class `clazz`. + */ + def arrayClass(clazz: Class[_]): Class[_] = { + // newInstance throws an exception if the erasure is Void.TYPE. see SI-5680 + if (clazz == java.lang.Void.TYPE) classOf[Array[Unit]] + else java.lang.reflect.Array.newInstance(clazz, 0).getClass + } + + /** Return the class object representing elements in arrays described by a given schematic. + */ + def arrayElementClass(schematic: Any): Class[_] = schematic match { + case cls: Class[_] => cls.getComponentType + case tag: ClassTag[_] => tag.erasure + case tag: ArrayTag[_] => tag.newArray(0).getClass.getComponentType + case _ => throw new UnsupportedOperationException("unsupported schematic %s (%s)".format(schematic, if (schematic == null) "null" else schematic.getClass)) + } + /** Return the class object representing an unboxed value type, * e.g. classOf[int], not classOf[java.lang.Integer]. The compiler * rewrites expressions like 5.getClass to come here. */ - def anyValClass[T <: AnyVal](value: T): Class[T] = (value match { - case x: Byte => java.lang.Byte.TYPE - case x: Short => java.lang.Short.TYPE - case x: Char => java.lang.Character.TYPE - case x: Int => java.lang.Integer.TYPE - case x: Long => java.lang.Long.TYPE - case x: Float => java.lang.Float.TYPE - case x: Double => java.lang.Double.TYPE - case x: Boolean => java.lang.Boolean.TYPE - case x: Unit => java.lang.Void.TYPE - }).asInstanceOf[Class[T]] + def anyValClass[T <: AnyVal : ClassTag](value: T): Class[T] = + classTag[T].erasure.asInstanceOf[Class[T]] /** Retrieve generic array element */ def array_apply(xs: AnyRef, idx: Int): Any = xs match { diff --git a/src/library/scala/runtime/SeqCharSequence.scala b/src/library/scala/runtime/SeqCharSequence.scala new file mode 100644 index 0000000000..7f7bca789f --- /dev/null +++ b/src/library/scala/runtime/SeqCharSequence.scala @@ -0,0 +1,25 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.runtime + +import java.util.Arrays.copyOfRange + +final class SeqCharSequence(val xs: collection.IndexedSeq[Char]) extends CharSequence { + def length: Int = xs.length + def charAt(index: Int): Char = xs(index) + def subSequence(start: Int, end: Int): CharSequence = new SeqCharSequence(xs.slice(start, end)) + override def toString = xs.mkString("") +} + +final class ArrayCharSequence(val xs: Array[Char]) extends CharSequence { + def length: Int = xs.length + def charAt(index: Int): Char = xs(index) + def subSequence(start: Int, end: Int): CharSequence = new ArrayCharSequence(copyOfRange(xs, math.max(0, start), math.min(xs.length, end))) + override def toString = xs.mkString("") +} diff --git a/src/library/scala/runtime/Tuple2Zipped.scala b/src/library/scala/runtime/Tuple2Zipped.scala new file mode 100644 index 0000000000..5ad364c8a5 --- /dev/null +++ b/src/library/scala/runtime/Tuple2Zipped.scala @@ -0,0 +1,130 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.runtime + +import scala.collection.{ TraversableLike, IterableLike } +import scala.collection.generic.{ CanBuildFrom => CBF } + +/** This interface is intended as a minimal interface, not complicated + * by the requirement to resolve type constructors, for implicit search (which only + * needs to find an implicit conversion to Traversable for our purposes.) + */ +trait ZippedTraversable2[+El1, +El2] { + def foreach[U](f: (El1, El2) => U): Unit +} +object ZippedTraversable2 { + implicit def zippedTraversable2ToTraversable[El1, El2](zz: ZippedTraversable2[El1, El2]): Traversable[(El1, El2)] = { + new collection.AbstractTraversable[(El1, El2)] { + def foreach[U](f: ((El1, El2)) => U): Unit = zz foreach Function.untupled(f) + } + } +} + +class Tuple2Zipped[El1, Repr1, El2, Repr2]( + coll1: TraversableLike[El1, Repr1], + coll2: IterableLike[El2, Repr2] +) extends ZippedTraversable2[El1, El2] { + def map[B, To](f: (El1, El2) => B)(implicit cbf: CBF[Repr1, B, To]): To = { + val b = cbf(coll1.repr) + b.sizeHint(coll1) + val elems2 = coll2.iterator + + for (el1 <- coll1) { + if (elems2.hasNext) + b += f(el1, elems2.next) + else + return b.result + } + + b.result + } + + def flatMap[B, To](f: (El1, El2) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = { + val b = cbf(coll1.repr) + val elems2 = coll2.iterator + + for (el1 <- coll1) { + if (elems2.hasNext) + b ++= f(el1, elems2.next) + else + return b.result + } + + b.result + } + + def filter[To1, To2](f: (El1, El2) => Boolean)(implicit cbf1: CBF[Repr1, El1, To1], cbf2: CBF[Repr2, El2, To2]): (To1, To2) = { + val b1 = cbf1(coll1.repr) + val b2 = cbf2(coll2.repr) + val elems2 = coll2.iterator + + for (el1 <- coll1) { + if (elems2.hasNext) { + val el2 = elems2.next + if (f(el1, el2)) { + b1 += el1 + b2 += el2 + } + } + else return (b1.result, b2.result) + } + + (b1.result, b2.result) + } + + def exists(f: (El1, El2) => Boolean): Boolean = { + val elems2 = coll2.iterator + + for (el1 <- coll1) { + if (elems2.hasNext) { + if (f(el1, elems2.next)) + return true + } + else return false + } + false + } + + def forall(f: (El1, El2) => Boolean): Boolean = + !exists((x, y) => !f(x, y)) + + def foreach[U](f: (El1, El2) => U): Unit = { + val elems2 = coll2.iterator + + for (el1 <- coll1) { + if (elems2.hasNext) + f(el1, elems2.next) + else + return + } + } +} + +object Tuple2Zipped { + class Ops[T1, T2](x: (T1, T2)) { + def invert[El1, CC1[X] <: TraversableOnce[X], El2, CC2[X] <: TraversableOnce[X], That] + (implicit w1: T1 <:< CC1[El1], + w2: T2 <:< CC2[El2], + bf: collection.generic.CanBuildFrom[CC1[_], (El1, El2), That] + ): That = { + val buf = bf(x._1) + val it1 = x._1.toIterator + val it2 = x._2.toIterator + while (it1.hasNext && it2.hasNext) + buf += ((it1.next, it2.next)) + + buf.result + } + + def zipped[El1, Repr1, El2, Repr2] + (implicit w1: T1 => TraversableLike[El1, Repr1], + w2: T2 => IterableLike[El2, Repr2] + ): Tuple2Zipped[El1, Repr1, El2, Repr2] = new Tuple2Zipped(x._1, x._2) + } +} diff --git a/src/library/scala/runtime/Tuple3Zipped.scala b/src/library/scala/runtime/Tuple3Zipped.scala new file mode 100644 index 0000000000..4e9c542c58 --- /dev/null +++ b/src/library/scala/runtime/Tuple3Zipped.scala @@ -0,0 +1,141 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.runtime + +import scala.collection.{ TraversableLike, IterableLike } +import scala.collection.generic.{ CanBuildFrom => CBF } + +/** See comment on ZippedTraversable2. */ +trait ZippedTraversable3[+El1, +El2, +El3] { + def foreach[U](f: (El1, El2, El3) => U): Unit +} +object ZippedTraversable3 { + implicit def zippedTraversable3ToTraversable[El1, El2, El3](zz: ZippedTraversable3[El1, El2, El3]): Traversable[(El1, El2, El3)] = { + new collection.AbstractTraversable[(El1, El2, El3)] { + def foreach[U](f: ((El1, El2, El3)) => U): Unit = zz foreach Function.untupled(f) + } + } +} + +class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3]( + coll1: TraversableLike[El1, Repr1], + coll2: IterableLike[El2, Repr2], + coll3: IterableLike[El3, Repr3] +) extends ZippedTraversable3[El1, El2, El3] { + def map[B, To](f: (El1, El2, El3) => B)(implicit cbf: CBF[Repr1, B, To]): To = { + val b = cbf(coll1.repr) + val elems2 = coll2.iterator + val elems3 = coll3.iterator + + for (el1 <- coll1) { + if (elems2.hasNext && elems3.hasNext) + b += f(el1, elems2.next, elems3.next) + else + return b.result + } + b.result + } + + def flatMap[B, To](f: (El1, El2, El3) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = { + val b = cbf(coll1.repr) + val elems2 = coll2.iterator + val elems3 = coll3.iterator + + for (el1 <- coll1) { + if (elems2.hasNext && elems3.hasNext) + b ++= f(el1, elems2.next, elems3.next) + else + return b.result + } + b.result + } + + def filter[To1, To2, To3](f: (El1, El2, El3) => Boolean)( + implicit cbf1: CBF[Repr1, El1, To1], + cbf2: CBF[Repr2, El2, To2], + cbf3: CBF[Repr3, El3, To3]): (To1, To2, To3) = { + val b1 = cbf1(coll1.repr) + val b2 = cbf2(coll2.repr) + val b3 = cbf3(coll3.repr) + val elems2 = coll2.iterator + val elems3 = coll3.iterator + def result = (b1.result, b2.result, b3.result) + + for (el1 <- coll1) { + if (elems2.hasNext && elems3.hasNext) { + val el2 = elems2.next + val el3 = elems3.next + + if (f(el1, el2, el3)) { + b1 += el1 + b2 += el2 + b3 += el3 + } + } + else return result + } + + result + } + + def exists(f: (El1, El2, El3) => Boolean): Boolean = { + val elems2 = coll2.iterator + val elems3 = coll3.iterator + + for (el1 <- coll1) { + if (elems2.hasNext && elems3.hasNext) { + if (f(el1, elems2.next, elems3.next)) + return true + } + else return false + } + false + } + + def forall(f: (El1, El2, El3) => Boolean): Boolean = + !exists((x, y, z) => !f(x, y, z)) + + def foreach[U](f: (El1, El2, El3) => U): Unit = { + val elems2 = coll2.iterator + val elems3 = coll3.iterator + + for (el1 <- coll1) { + if (elems2.hasNext && elems3.hasNext) + f(el1, elems2.next, elems3.next) + else + return + } + } +} + +object Tuple3Zipped { + class Ops[T1, T2, T3](x: (T1, T2, T3)) { + def invert[El1, CC1[X] <: TraversableOnce[X], El2, CC2[X] <: TraversableOnce[X], El3, CC3[X] <: TraversableOnce[X], That] + (implicit w1: T1 <:< CC1[El1], + w2: T2 <:< CC2[El2], + w3: T3 <:< CC3[El3], + bf: collection.generic.CanBuildFrom[CC1[_], (El1, El2, El3), That] + ): That = { + val buf = bf(x._1) + val it1 = x._1.toIterator + val it2 = x._2.toIterator + val it3 = x._3.toIterator + while (it1.hasNext && it2.hasNext && it3.hasNext) + buf += ((it1.next, it2.next, it3.next)) + + buf.result + } + + def zipped[El1, Repr1, El2, Repr2, El3, Repr3] + (implicit w1: T1 => TraversableLike[El1, Repr1], + w2: T2 => IterableLike[El2, Repr2], + w3: T3 => IterableLike[El3, Repr3] + ): Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3] = new Tuple3Zipped(x._1, x._2, x._3) + } +} diff --git a/src/library/scala/runtime/package.scala b/src/library/scala/runtime/package.scala index 9c87baf6a7..e4472b3ea1 100644 --- a/src/library/scala/runtime/package.scala +++ b/src/library/scala/runtime/package.scala @@ -1,13 +1,3 @@ package scala -package object runtime { - @deprecated("Use `scala.Unit` instead.", "2.9.0") val Unit = scala.Unit - @deprecated("Use `scala.Boolean` instead.", "2.9.0") val Boolean = scala.Boolean - @deprecated("Use `scala.Byte` instead.", "2.9.0") val Byte = scala.Byte - @deprecated("Use `scala.Short` instead.", "2.9.0") val Short = scala.Short - @deprecated("Use `scala.Char` instead.", "2.9.0") val Char = scala.Char - @deprecated("Use `scala.Int` instead.", "2.9.0") val Int = scala.Int - @deprecated("Use `scala.Long` instead.", "2.9.0") val Long = scala.Long - @deprecated("Use `scala.Float` instead.", "2.9.0") val Float = scala.Float - @deprecated("Use `scala.Double` instead.", "2.9.0") val Double = scala.Double -} +package object runtime { } diff --git a/src/library/scala/util/Marshal.scala b/src/library/scala/util/Marshal.scala index c2269cde45..e2ebe7851c 100644 --- a/src/library/scala/util/Marshal.scala +++ b/src/library/scala/util/Marshal.scala @@ -11,19 +11,19 @@ package scala.util /** - * Marshalling of Scala objects using Scala manifests. + * Marshalling of Scala objects using Scala tags. * * @author Stephane Micheloud * @version 1.0 */ object Marshal { import java.io._ - import scala.reflect.ClassManifest + import scala.reflect.ClassTag - def dump[A](o: A)(implicit m: ClassManifest[A]): Array[Byte] = { + def dump[A](o: A)(implicit t: ClassTag[A]): Array[Byte] = { val ba = new ByteArrayOutputStream(512) val out = new ObjectOutputStream(ba) - out.writeObject(m) + out.writeObject(t) out.writeObject(o) out.close() ba.toByteArray() @@ -32,20 +32,20 @@ object Marshal { @throws(classOf[IOException]) @throws(classOf[ClassCastException]) @throws(classOf[ClassNotFoundException]) - def load[A](buffer: Array[Byte])(implicit expected: ClassManifest[A]): A = { + def load[A](buffer: Array[Byte])(implicit expected: ClassTag[A]): A = { val in = new ObjectInputStream(new ByteArrayInputStream(buffer)) - val found = in.readObject.asInstanceOf[ClassManifest[_]] - // todo. [Eugene] needs review, since ClassManifests no longer capture typeArguments - if (found.tpe <:< expected.tpe) { - val o = in.readObject.asInstanceOf[A] - in.close() - o - } else { - in.close() - throw new ClassCastException("type mismatch;"+ - "\n found : "+found+ - "\n required: "+expected) + val found = in.readObject.asInstanceOf[ClassTag[_]] + try { + // [Eugene] needs review + // previously was: found <:< expected + found.erasure.asSubclass(expected.erasure) + in.readObject.asInstanceOf[A] + } catch { + case _: ClassCastException => + in.close() + throw new ClassCastException("type mismatch;"+ + "\n found : "+found+ + "\n required: "+expected) } } - } diff --git a/src/library/scala/util/Sorting.scala b/src/library/scala/util/Sorting.scala index bf460a118f..7d98e57741 100644 --- a/src/library/scala/util/Sorting.scala +++ b/src/library/scala/util/Sorting.scala @@ -8,7 +8,7 @@ package scala.util -import scala.reflect.ClassManifest +import scala.reflect.ClassTag import scala.math.Ordering /** The Sorting object provides functions that can sort various kinds of @@ -39,14 +39,14 @@ object Sorting { /** Sort an array of K where K is Ordered, preserving the existing order * where the values are equal. */ - def stableSort[K: ClassManifest: Ordering](a: Array[K]) { + def stableSort[K: ArrayTag: Ordering](a: Array[K]) { stableSort(a, 0, a.length-1, new Array[K](a.length), Ordering[K].lt _) } /** Sorts an array of `K` given an ordering function `f`. * `f` should return `true` iff its first parameter is strictly less than its second parameter. */ - def stableSort[K: ClassManifest](a: Array[K], f: (K, K) => Boolean) { + def stableSort[K: ArrayTag](a: Array[K], f: (K, K) => Boolean) { stableSort(a, 0, a.length-1, new Array[K](a.length), f) } @@ -57,14 +57,14 @@ object Sorting { * @param f the comparison function. * @return the sorted sequence of items. */ - def stableSort[K: ClassManifest](a: Seq[K], f: (K, K) => Boolean): Array[K] = { + def stableSort[K: ArrayTag](a: Seq[K], f: (K, K) => Boolean): Array[K] = { val ret = a.toArray stableSort(ret, f) ret } /** Sorts an arbitrary sequence of items that are viewable as ordered. */ - def stableSort[K: ClassManifest: Ordering](a: Seq[K]): Array[K] = + def stableSort[K: ArrayTag: Ordering](a: Seq[K]): Array[K] = stableSort(a, Ordering[K].lt _) /** Stably sorts a sequence of items given an extraction function that will @@ -74,8 +74,8 @@ object Sorting { * @param f the comparison function. * @return the sorted sequence of items. */ - def stableSort[K: ClassManifest, M: Ordering](a: Seq[K], f: K => M): Array[K] = - stableSort(a)(implicitly[ClassManifest[K]], Ordering[M] on f) + def stableSort[K: ArrayTag, M: Ordering](a: Seq[K], f: K => M): Array[K] = + stableSort(a)(implicitly[ArrayTag[K]], Ordering[M] on f) private def sort1[K: Ordering](x: Array[K], off: Int, len: Int) { val ord = Ordering[K] @@ -498,7 +498,7 @@ object Sorting { sort2(off, len) } - private def stableSort[K : ClassManifest](a: Array[K], lo: Int, hi: Int, scratch: Array[K], f: (K,K) => Boolean) { + private def stableSort[K : ArrayTag](a: Array[K], lo: Int, hi: Int, scratch: Array[K], f: (K,K) => Boolean) { if (lo < hi) { val mid = (lo+hi) / 2 stableSort(a, lo, mid, scratch, f) diff --git a/src/library/scala/util/control/Exception.scala b/src/library/scala/util/control/Exception.scala index 1cae8088f5..38f4abb20a 100644 --- a/src/library/scala/util/control/Exception.scala +++ b/src/library/scala/util/control/Exception.scala @@ -30,9 +30,9 @@ import language.implicitConversions object Exception { type Catcher[+T] = PartialFunction[Throwable, T] - def mkCatcher[Ex <: Throwable: ClassManifest, T](isDef: Ex => Boolean, f: Ex => T) = new Catcher[T] { + def mkCatcher[Ex <: Throwable: ClassTag, T](isDef: Ex => Boolean, f: Ex => T) = new Catcher[T] { private def downcast(x: Throwable): Option[Ex] = - if (classManifest[Ex].erasure.isAssignableFrom(x.getClass)) Some(x.asInstanceOf[Ex]) + if (classTag[Ex].erasure.isAssignableFrom(x.getClass)) Some(x.asInstanceOf[Ex]) else None def isDefinedAt(x: Throwable) = downcast(x) exists isDef @@ -41,7 +41,7 @@ object Exception { def mkThrowableCatcher[T](isDef: Throwable => Boolean, f: Throwable => T) = mkCatcher(isDef, f) - implicit def throwableSubtypeToCatcher[Ex <: Throwable: ClassManifest, T](pf: PartialFunction[Ex, T]) = + implicit def throwableSubtypeToCatcher[Ex <: Throwable: ClassTag, T](pf: PartialFunction[Ex, T]) = mkCatcher(pf.isDefinedAt _, pf.apply _) /** !!! Not at all sure of every factor which goes into this, diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index 3f21cc9724..a83619cf01 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -204,7 +204,7 @@ class Regex(regex: String, groupNames: String*) extends Serializable { /** Return all matches of this regexp in given character sequence as a - * [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]. + * [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]]. * * @param source The text to match against. * @return A [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]] for all matches. diff --git a/src/partest/scala/tools/partest/CompilerTest.scala b/src/partest/scala/tools/partest/CompilerTest.scala index aaea4416dd..86678760be 100644 --- a/src/partest/scala/tools/partest/CompilerTest.scala +++ b/src/partest/scala/tools/partest/CompilerTest.scala @@ -5,6 +5,7 @@ package scala.tools.partest +import scala.reflect.{mirror => rm} import scala.tools.nsc._ /** For testing compiler internals directly. @@ -29,13 +30,13 @@ abstract class CompilerTest extends DirectTest { // Override at least one of these... def code = "" def sources: List[String] = List(code) - + // Utility functions - + class MkType(sym: Symbol) { - def apply[M](implicit m1: Manifest[M]): Type = + def apply[M](implicit t: rm.TypeTag[M]): Type = if (sym eq NoSymbol) NoType - else appliedType(sym, manifestToType(m1)) + else appliedType(sym, compilerTypeFromTag(t)) } implicit def mkMkType(sym: Symbol) = new MkType(sym) @@ -47,7 +48,7 @@ abstract class CompilerTest extends DirectTest { } loop(Set(), List(root)) } - + class SymsInPackage(pkgName: String) { def pkg = getRequiredModule(pkgName) def classes = allMembers(pkg) filter (_.isClass) diff --git a/src/partest/scala/tools/partest/SigTest.scala b/src/partest/scala/tools/partest/SigTest.scala index 072ec006f9..999d901d21 100644 --- a/src/partest/scala/tools/partest/SigTest.scala +++ b/src/partest/scala/tools/partest/SigTest.scala @@ -20,31 +20,31 @@ trait SigTest { def isObjectMethodName(name: String) = classOf[Object].getMethods exists (_.getName == name) - def fields[T: ClassManifest](p: JField => Boolean) = { - val cl = classManifest[T].erasure + def fields[T: ClassTag](p: JField => Boolean) = { + val cl = classTag[T].erasure val fs = (cl.getFields ++ cl.getDeclaredFields).distinct sortBy (_.getName) fs filter p } - def methods[T: ClassManifest](p: JMethod => Boolean) = { - val cl = classManifest[T].erasure + def methods[T: ClassTag](p: JMethod => Boolean) = { + val cl = classTag[T].erasure val ms = (cl.getMethods ++ cl.getDeclaredMethods).distinct sortBy (x => (x.getName, x.isBridge)) ms filter p } - def allFields[T: ClassManifest]() = fields[T](_ => true) - def allMethods[T: ClassManifest]() = methods[T](m => !isObjectMethodName(m.getName)) - def fieldsNamed[T: ClassManifest](name: String) = fields[T](_.getName == name) - def methodsNamed[T: ClassManifest](name: String) = methods[T](_.getName == name) + def allFields[T: ClassTag]() = fields[T](_ => true) + def allMethods[T: ClassTag]() = methods[T](m => !isObjectMethodName(m.getName)) + def fieldsNamed[T: ClassTag](name: String) = fields[T](_.getName == name) + def methodsNamed[T: ClassTag](name: String) = methods[T](_.getName == name) - def allGenericStrings[T: ClassManifest]() = + def allGenericStrings[T: ClassTag]() = (allMethods[T]() map mstr) ++ (allFields[T]() map fstr) - def genericStrings[T: ClassManifest](name: String) = + def genericStrings[T: ClassTag](name: String) = (methodsNamed[T](name) map mstr) ++ (fieldsNamed[T](name) map fstr) - def show[T: ClassManifest](name: String = "") = { - println(classManifest[T].erasure.getName) + def show[T: ClassTag](name: String = "") = { + println(classTag[T].erasure.getName) if (name == "") allGenericStrings[T]() foreach println else genericStrings[T](name) foreach println } diff --git a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala index 85060ad633..fb3cab52c4 100644 --- a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala +++ b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala @@ -213,7 +213,12 @@ class ConsoleRunner extends DirectRunner { * @return (success count, failure count) */ def testCheckAll(enabledSets: List[TestSet]): (Int, Int) = { - def kindOf(f: File) = (srcDir relativize Path(f).toCanonical).segments.head + def kindOf(f: File) = { + (srcDir relativize Path(f).toCanonical).segments match { + case (".." :: "scaladoc" :: xs) => xs.head + case xs => xs.head + } + } val (valid, invalid) = testFiles partition (x => testSetKinds contains kindOf(x)) invalid foreach (x => NestUI.failure( diff --git a/src/scalacheck/org/scalacheck/Arbitrary.scala b/src/scalacheck/org/scalacheck/Arbitrary.scala index 91d56b0aec..9bb235f917 100644 --- a/src/scalacheck/org/scalacheck/Arbitrary.scala +++ b/src/scalacheck/org/scalacheck/Arbitrary.scala @@ -263,7 +263,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: ClassManifest[T] + implicit def arbArray[T](implicit a: Arbitrary[T], c: ClassTag[T] ): Arbitrary[Array[T]] = Arbitrary(containerOf[Array,T](arbitrary[T])) diff --git a/src/scalacheck/org/scalacheck/util/Buildable.scala b/src/scalacheck/org/scalacheck/util/Buildable.scala index 6378e72d4f..662bc6146b 100644 --- a/src/scalacheck/org/scalacheck/util/Buildable.scala +++ b/src/scalacheck/org/scalacheck/util/Buildable.scala @@ -30,7 +30,7 @@ object Buildable { def builder = (new mutable.ListBuffer[T]).mapResult(_.toStream) } - implicit def buildableArray[T](implicit cm: ClassManifest[T]) = + implicit def buildableArray[T](implicit t: ClassTag[T]) = new Buildable[T,Array] { def builder = mutable.ArrayBuilder.make[T] } diff --git a/src/swing/scala/swing/Font.scala.disabled b/src/swing/scala/swing/Font.scala.disabled index 6eebd667bd..9e21eb859c 100644 --- a/src/swing/scala/swing/Font.scala.disabled +++ b/src/swing/scala/swing/Font.scala.disabled @@ -1,36 +1,36 @@ package scala.swing -/*object Font { - def apply(fontFormat: Int, fontFile: java.io.File) = java.awt.Font.createFont(fontFormat, fontFile) - def apply(fontFormat: Int, fontStream: java.io.InputStream) = java.awt.Font.createFont(fontFormat, fontStream) +/*object Font { + def apply(fontFormat: Int, fontFile: java.io.File) = java.awt.Font.createFont(fontFormat, fontFile) + def apply(fontFormat: Int, fontStream: java.io.InputStream) = java.awt.Font.createFont(fontFormat, fontStream) def decode(str: String) = java.awt.Font.decode(str) - + /* TODO: finish implementation /** * See [java.awt.Font.getFont]. */ - def get(attributes: Map[_ <: java.text.AttributedCharacterIterator.Attribute, _]) = + def get(attributes: Map[_ <: java.text.AttributedCharacterIterator.Attribute, _]) = java.awt.Font.getFont(ImmutableMapWrapper(attributes)) - + import java.{util => ju} - private case class ImmutableMapWrapper[A, B](underlying : Map[A, B])(m : ClassManifest[A]) extends ju.AbstractMap[A, B] { + private case class ImmutableMapWrapper[A, B](underlying : Map[A, B])(t : ClassTag[A]) extends ju.AbstractMap[A, B] { self => override def size = underlying.size - override def put(k : A, v : B) = + override def put(k : A, v : B) = throw new UnsupportedOperationException("This is a wrapper that does not support mutation") - override def remove(k : AnyRef) = + override def remove(k : AnyRef) = throw new UnsupportedOperationException("This is a wrapper that does not support mutation") - + override def entrySet : ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] { def size = self.size def iterator = new ju.Iterator[ju.Map.Entry[A, B]] { val ui = underlying.iterator var prev : Option[A] = None - + def hasNext = ui.hasNext - + def next = { val (k, v) = ui.next prev = Some(k) @@ -44,7 +44,7 @@ package scala.swing } } } - + def remove = prev match { case Some(k) => val v = self.remove(k.asInstanceOf[AnyRef]) ; prev = None ; v case _ => throw new IllegalStateException("next must be called at least once before remove") @@ -53,7 +53,7 @@ package scala.swing } } */ - + /** * See [java.awt.Font.getFont]. */ @@ -62,9 +62,9 @@ package scala.swing * See [java.awt.Font.getFont]. */ def get(nm: String, font: Font) = java.awt.Font.getFont(nm, font) - + def Insets(x: Int, y: Int, width: Int, height: Int) = new Insets(x, y, width, height) def Rectangle(x: Int, y: Int, width: Int, height: Int) = new Insets(x, y, width, height) def Point(x: Int, y: Int) = new Point(x, y) - def Dimension(x: Int, y: Int) = new Dimension(x, y) + def Dimension(x: Int, y: Int) = new Dimension(x, y) }*/
\ No newline at end of file |