diff options
153 files changed, 833 insertions, 837 deletions
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 28905dd240..29eb573b64 100644 --- a/src/compiler/scala/reflect/internal/Definitions.scala +++ b/src/compiler/scala/reflect/internal/Definitions.scala @@ -534,9 +534,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_+ diff --git a/src/compiler/scala/reflect/internal/pickling/UnPickler.scala b/src/compiler/scala/reflect/internal/pickling/UnPickler.scala index eb4bae78d0..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)) @@ -843,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/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/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/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/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/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/ModelFactoryImplicitSupport.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala index 4e03dc8788..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? @@ -504,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/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala index 9279d37464..297d6ad1b9 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala @@ -1053,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 923fc867a9..3d77344091 100644 --- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala +++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala @@ -351,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 } @@ -667,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 @@ -683,12 +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 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) + 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() { @@ -1185,9 +1185,10 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends val termname = newTypeName(name) 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 } 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 2cb034f7ab..01ace0e984 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,8 +226,8 @@ 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 @@ -236,9 +236,9 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl 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) @@ -366,7 +366,7 @@ class Power[ReplValsImpl <: ReplVals : Manifest](val intp: IMain, replVals: Repl 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 +381,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 => diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala b/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala index 4efab7e260..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. @@ -39,8 +40,8 @@ class StdReplVals(final val r: ILoop) extends ReplVals { 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 @@ -53,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 3d4d22063e..2e735e3b9b 100644 --- a/src/compiler/scala/tools/nsc/interpreter/RichClass.scala +++ b/src/compiler/scala/tools/nsc/interpreter/RichClass.scala @@ -6,10 +6,8 @@ package scala.tools.nsc package interpreter -import scala.reflect.{mirror => rm} - class RichClass[T](val clazz: Class[T]) { - def toManifest: Manifest[T] = Manifest[T](rm.classToType(clazz)) + def toTag: ClassTag[T] = ClassTag[T](clazz) def toTypeString: String = TypeStrings.fromClazz(clazz) // Sadly isAnonymousClass does not return true for scala anonymous @@ -21,9 +19,9 @@ class RichClass[T](val clazz: Class[T]) { ) /** 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 9ba75d9166..5d5123811e 100644 --- a/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala +++ b/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala @@ -192,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) "" @@ -209,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/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/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 c766b52159..338c39dc5f 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -668,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 => diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 8d26f66370..c13be0e39d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -861,7 +861,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/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/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index be269cf4b2..3d9fc67389 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 } 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/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 744bf9b226..0b0c0905cb 100644 --- a/src/compiler/scala/tools/reflect/package.scala +++ b/src/compiler/scala/tools/reflect/package.scala @@ -7,7 +7,6 @@ package scala.tools import java.lang.reflect.Method import java.{ lang => jl } -import scala.reflect.{mirror => rm} package object reflect { def nameAndArity(m: Method) = (m.getName, m.getParameterTypes.size) @@ -28,17 +27,17 @@ package object reflect { } } - def zeroOfClass(clazz: Class[_]) = zeroOf(Manifest(rm.classToType(clazz))) - 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/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 ![T](x: T)(implicit m: reflect.Manifest[T]) { send(x)(m) } + def ![T](x: T)(implicit m: reflect.ClassTag[T]) { send(x)(m) } def close() { try { socket.close() } 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/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/Traversable.scala b/src/library/scala/collection/Traversable.scala index 3fba3dfa79..a65be3ffcc 100644 --- a/src/library/scala/collection/Traversable.scala +++ b/src/library/scala/collection/Traversable.scala @@ -75,7 +75,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/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/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/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/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/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/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/FlatArray.scala b/src/library/scala/collection/mutable/FlatArray.scala index 3e43b66ecf..5b4b5e777f 100644 --- a/src/library/scala/collection/mutable/FlatArray.scala +++ b/src/library/scala/collection/mutable/FlatArray.scala @@ -11,7 +11,7 @@ package scala.collection package mutable -import scala.reflect.ClassManifest +import scala.reflect.ArrayTag import generic.CanBuildFrom /** @@ -62,16 +62,16 @@ object FlatArray { def ofDim[Boxed, Unboxed](size:Int) (implicit boxings: BoxingConversions[Boxed, Unboxed], - manifest: ClassManifest[Unboxed]): FlatArray[Boxed] = { + tag: ArrayTag[Unboxed]): FlatArray[Boxed] = { val elems = Array.ofDim[Unboxed](size) - new FlatArray.Impl(elems, boxings, manifest) + new FlatArray.Impl(elems, boxings, tag) } def empty[Boxed, Unboxed](implicit boxings: BoxingConversions[Boxed, Unboxed], - elemManifest: ClassManifest[Unboxed]): FlatArray[Boxed] = apply() + elemTag: ArrayTag[Unboxed]): FlatArray[Boxed] = apply() def apply[Boxed, Unboxed](elems: Boxed*) - (implicit boxings: BoxingConversions[Boxed, Unboxed], elemManifest: ClassManifest[Unboxed]): FlatArray[Boxed] = { + (implicit boxings: BoxingConversions[Boxed, Unboxed], elemTag: ArrayTag[Unboxed]): FlatArray[Boxed] = { val b = newBuilder[Boxed, Unboxed] b.sizeHint(elems.length) b ++= elems @@ -79,13 +79,13 @@ object FlatArray { } def newBuilder[Boxed, Unboxed] - (implicit boxings: BoxingConversions[Boxed, Unboxed], elemManifest: ClassManifest[Unboxed]): Builder[Boxed, FlatArray[Boxed]] = - new Bldr[Boxed, Unboxed](boxings, elemManifest) + (implicit boxings: BoxingConversions[Boxed, Unboxed], elemTag: ArrayTag[Unboxed]): Builder[Boxed, FlatArray[Boxed]] = + new Bldr[Boxed, Unboxed](boxings, elemTag) implicit def canBuildFrom[Boxed, Unboxed]( implicit boxings: BoxingConversions[Boxed, Unboxed], - elemManifest: ClassManifest[Unboxed]): CanBuildFrom[FlatArray[_], Boxed, FlatArray[Boxed]] = + elemTag: ArrayTag[Unboxed]): CanBuildFrom[FlatArray[_], Boxed, FlatArray[Boxed]] = new CanBuildFrom[FlatArray[_], Boxed, FlatArray[Boxed]] { def apply(from: FlatArray[_]): Builder[Boxed, FlatArray[Boxed]] = newBuilder[Boxed, Unboxed] @@ -93,14 +93,14 @@ object FlatArray { newBuilder[Boxed, Unboxed] } - private class Bldr[Boxed, Unboxed](boxings: BoxingConversions[Boxed, Unboxed], manifest: ClassManifest[Unboxed]) extends Builder[Boxed, FlatArray[Boxed]] { + private class Bldr[Boxed, Unboxed](boxings: BoxingConversions[Boxed, Unboxed], tag: ArrayTag[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) + val newelems = tag.newArray(size) if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) elems = newelems capacity = size @@ -131,14 +131,14 @@ object FlatArray { def result(): FlatArray[Boxed] = { if (capacity == 0 || capacity != size) resize(size) - new FlatArray.Impl(elems, boxings, manifest) + new FlatArray.Impl(elems, boxings, tag) } } private class Impl[Boxed, Unboxed]( elems: Array[Unboxed], boxings: BoxingConversions[Boxed, Unboxed], - elemManifest: ClassManifest[Unboxed]) extends FlatArray[Boxed] { + elemTag: ArrayTag[Unboxed]) extends FlatArray[Boxed] { def length = elems.length @@ -149,9 +149,9 @@ object FlatArray { /** Creates new builder for this collection ==> move to subclasses */ override protected[this] def newBuilder: Builder[Boxed, FlatArray[Boxed]] = - new Bldr[Boxed, Unboxed](boxings, elemManifest) + new Bldr[Boxed, Unboxed](boxings, elemTag) /** Clones this object, including the underlying Array. */ - override def clone: FlatArray[Boxed] = new Impl[Boxed, Unboxed](elems.clone(), boxings, elemManifest) + override def clone: FlatArray[Boxed] = new Impl[Boxed, Unboxed](elems.clone(), boxings, elemTag) } } 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..5e20f4ec61 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[T](arrayElementClass(elemTag)) /** 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/reflect/DummyMirror.scala b/src/library/scala/reflect/DummyMirror.scala index 8b2ddde2a1..276237fce4 100644 --- a/src/library/scala/reflect/DummyMirror.scala +++ b/src/library/scala/reflect/DummyMirror.scala @@ -5,9 +5,10 @@ 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 classfileAnnotArgManifest: scala.reflect.ClassManifest[ClassfileAnnotArg] = notSupported() + implicit def classfileAnnotArgTag: scala.reflect.ClassTag[ClassfileAnnotArg] = notSupported() type AnnotationInfo = DummyAnnotationInfo.type object DummyAnnotationInfo val AnnotationInfo: AnnotationInfoExtractor = DummyAnnotationInfoExtractor 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/util/Marshal.scala b/src/library/scala/util/Marshal.scala index 6eb58e8570..e2ebe7851c 100644 --- a/src/library/scala/util/Marshal.scala +++ b/src/library/scala/util/Marshal.scala @@ -48,4 +48,4 @@ object Marshal { "\n required: "+expected) } } -}
\ No newline at end of file +} 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/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/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 diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/arrays/Resetting.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/arrays/Resetting.scala index e6feb59fcd..22d2107f62 100644 --- a/test/benchmarks/src/scala/collection/parallel/benchmarks/arrays/Resetting.scala +++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/arrays/Resetting.scala @@ -4,19 +4,19 @@ package scala.collection.parallel.benchmarks.arrays import scala.collection.parallel.benchmarks._ -abstract class Resetting[T: Manifest](elemcreate: Int => T, sz: Int, p: Int, what: String) +abstract class Resetting[T: ClassTag](elemcreate: Int => T, sz: Int, p: Int, what: String) extends Bench { val size = sz val parallelism = p val runWhat = what - + var anyarray: Array[Any] = null var castarray: AnyRef = null var gencastarray: Array[T] = null var manifarray: Array[T] = null - + reset - + def reset = what match { case "any" => anyarray = new Array[Any](sz) diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/MatrixMultiplication.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/MatrixMultiplication.scala index 5f902ff483..6d5b189c3a 100644 --- a/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/MatrixMultiplication.scala +++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/MatrixMultiplication.scala @@ -16,54 +16,54 @@ class MatrixMultiplication(sz: Int, p: Int, what: String) extends Resettable(sz, p, what, new Cont(_), new Array[Any](_), classOf[Cont]) { def companion = MatrixMultiplication collection.parallel.tasksupport.environment = forkjoinpool - + val a = Matrix.unit[Int](sz) val b = Matrix.unit[Int](sz) var c = new Matrix[Int](sz) - + def runpar = c = a * b //{ c.assignProduct(a, b) } //; println("--------"); c.output } def runseq = throw new UnsupportedOperationException def comparisonMap = collection.Map() - - class Matrix[T](n: Int)(implicit num: Numeric[T], man: Manifest[T]) { + + class Matrix[T](n: Int)(implicit num: Numeric[T], tag: ClassTag[T]) { val array = new Array[T](n * n) - + def apply(y: Int, x: Int) = array(y * n + x) - + def update(y: Int, x: Int, elem: T) = array(y * n + x) = elem - + def *(b: Matrix[T]) = { val m = new Matrix[T](n) m.assignProduct(this, b) m } - + def assignProduct(a: Matrix[T], b: Matrix[T]) = { val range = ParRange(0, n * n, 1, false) for (i <- range) this(i / n, i % n) = calcProduct(a, b, i / n, i % n); } - + private def calcProduct(a: Matrix[T], b: Matrix[T], y: Int, x: Int): T = { import num._ var sum = zero for (i <- 0 until n) sum += a(y, i) * b(i, x) sum } - + def output = for (y <- 0 until n) { for (x <- 0 until n) print(this(y, x)) println } } - + object Matrix { - def unit[T](n: Int)(implicit num: Numeric[T], man: Manifest[T]) = { + def unit[T](n: Int)(implicit num: Numeric[T], tag: ClassTag[T]) = { val m = new Matrix[T](n) for (i <- 0 until n) m(i, i) = num.one m } } - + } diff --git a/test/disabled/presentation/akka.check b/test/disabled/presentation/akka.check index 9cd20ffb1c..5105d85a00 100644 --- a/test/disabled/presentation/akka.check +++ b/test/disabled/presentation/akka.check @@ -153,11 +153,11 @@ retrieved 131 members `method spawn(clazz: Class[_ <: akka.actor.Actor])akka.actor.ActorRef` `method spawnLink(clazz: Class[_ <: akka.actor.Actor])akka.actor.ActorRef` `method spawnLinkRemote(clazz: Class[_ <: akka.actor.Actor], hostname: String, port: Int, timeout: Long)akka.actor.ActorRef` -`method spawnLinkRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$4: Manifest[T])akka.actor.ActorRef` -`method spawnLink[T <: akka.actor.Actor](implicit evidence$3: Manifest[T])akka.actor.ActorRef` +`method spawnLinkRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$4: ClassTag[T])akka.actor.ActorRef` +`method spawnLink[T <: akka.actor.Actor](implicit evidence$3: ClassTag[T])akka.actor.ActorRef` `method spawnRemote(clazz: Class[_ <: akka.actor.Actor], hostname: String, port: Int, timeout: Long)akka.actor.ActorRef` -`method spawnRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$2: Manifest[T])akka.actor.ActorRef` -`method spawn[T <: akka.actor.Actor](implicit evidence$1: Manifest[T])akka.actor.ActorRef` +`method spawnRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$2: ClassTag[T])akka.actor.ActorRef` +`method spawn[T <: akka.actor.Actor](implicit evidence$1: ClassTag[T])akka.actor.ActorRef` `method start()akka.actor.ActorRef` `method startLink(actorRef: akka.actor.ActorRef)Unit` `method stop()Unit` @@ -286,11 +286,11 @@ retrieved 131 members `method spawn(clazz: Class[_ <: akka.actor.Actor])akka.actor.ActorRef` `method spawnLink(clazz: Class[_ <: akka.actor.Actor])akka.actor.ActorRef` `method spawnLinkRemote(clazz: Class[_ <: akka.actor.Actor], hostname: String, port: Int, timeout: Long)akka.actor.ActorRef` -`method spawnLinkRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$4: Manifest[T])akka.actor.ActorRef` -`method spawnLink[T <: akka.actor.Actor](implicit evidence$3: Manifest[T])akka.actor.ActorRef` +`method spawnLinkRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$4: ClassTag[T])akka.actor.ActorRef` +`method spawnLink[T <: akka.actor.Actor](implicit evidence$3: ClassTag[T])akka.actor.ActorRef` `method spawnRemote(clazz: Class[_ <: akka.actor.Actor], hostname: String, port: Int, timeout: Long)akka.actor.ActorRef` -`method spawnRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$2: Manifest[T])akka.actor.ActorRef` -`method spawn[T <: akka.actor.Actor](implicit evidence$1: Manifest[T])akka.actor.ActorRef` +`method spawnRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$2: ClassTag[T])akka.actor.ActorRef` +`method spawn[T <: akka.actor.Actor](implicit evidence$1: ClassTag[T])akka.actor.ActorRef` `method start()akka.actor.ActorRef` `method startLink(actorRef: akka.actor.ActorRef)Unit` `method stop()Unit` @@ -419,11 +419,11 @@ retrieved 131 members `method spawn(clazz: Class[_ <: akka.actor.Actor])akka.actor.ActorRef` `method spawnLink(clazz: Class[_ <: akka.actor.Actor])akka.actor.ActorRef` `method spawnLinkRemote(clazz: Class[_ <: akka.actor.Actor], hostname: String, port: Int, timeout: Long)akka.actor.ActorRef` -`method spawnLinkRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$4: Manifest[T])akka.actor.ActorRef` -`method spawnLink[T <: akka.actor.Actor](implicit evidence$3: Manifest[T])akka.actor.ActorRef` +`method spawnLinkRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$4: ClassTag[T])akka.actor.ActorRef` +`method spawnLink[T <: akka.actor.Actor](implicit evidence$3: ClassTag[T])akka.actor.ActorRef` `method spawnRemote(clazz: Class[_ <: akka.actor.Actor], hostname: String, port: Int, timeout: Long)akka.actor.ActorRef` -`method spawnRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$2: Manifest[T])akka.actor.ActorRef` -`method spawn[T <: akka.actor.Actor](implicit evidence$1: Manifest[T])akka.actor.ActorRef` +`method spawnRemote[T <: akka.actor.Actor](hostname: String, port: Int, timeout: Long)(implicit evidence$2: ClassTag[T])akka.actor.ActorRef` +`method spawn[T <: akka.actor.Actor](implicit evidence$1: ClassTag[T])akka.actor.ActorRef` `method start()akka.actor.ActorRef` `method startLink(actorRef: akka.actor.ActorRef)Unit` `method stop()Unit` diff --git a/test/disabled/presentation/akka/src/akka/actor/Actor.scala b/test/disabled/presentation/akka/src/akka/actor/Actor.scala index b955c4c38b..b9bc51b635 100644 --- a/test/disabled/presentation/akka/src/akka/actor/Actor.scala +++ b/test/disabled/presentation/akka/src/akka/actor/Actor.scala @@ -135,7 +135,7 @@ object Actor extends ListenerManagement { * val actor = actorOf[MyActor].start() * </pre> */ - def actorOf[T <: Actor: Manifest]: ActorRef = actorOf(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]]) + def actorOf[T <: Actor: ClassTag]: ActorRef = actorOf(classTag[T].erasure.asInstanceOf[Class[_ <: Actor]]) /** Creates an ActorRef out of the Actor of the specified Class. * <pre> @@ -481,7 +481,7 @@ private[actor] class AnyOptionAsTypedOption(anyOption: Option[Any]) { /** Convenience helper to cast the given Option of Any to an Option of the given type. Will swallow a possible * ClassCastException and return None in that case. */ - def asSilently[T: Manifest]: Option[T] = narrowSilently[T](anyOption) + def asSilently[T: ClassTag]: Option[T] = narrowSilently[T](anyOption) } /** Marker interface for proxyable actors (such as typed actor). diff --git a/test/disabled/presentation/akka/src/akka/actor/ActorRef.scala b/test/disabled/presentation/akka/src/akka/actor/ActorRef.scala index ff67c9468e..da0b63006a 100644 --- a/test/disabled/presentation/akka/src/akka/actor/ActorRef.scala +++ b/test/disabled/presentation/akka/src/akka/actor/ActorRef.scala @@ -1406,28 +1406,28 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef => /** * Atomically create (from actor class) and start an actor. */ - def spawn[T <: Actor: Manifest]: ActorRef = - spawn(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]]) + def spawn[T <: Actor: ClassTag]: ActorRef = + spawn(classTag[T].erasure.asInstanceOf[Class[_ <: Actor]]) /** * Atomically create (from actor class), start and make an actor remote. */ - def spawnRemote[T <: Actor: Manifest](hostname: String, port: Int, timeout: Long): ActorRef = { + def spawnRemote[T <: Actor: ClassTag](hostname: String, port: Int, timeout: Long): ActorRef = { ensureRemotingEnabled - spawnRemote(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]], hostname, port, timeout) + spawnRemote(classTag[T].erasure.asInstanceOf[Class[_ <: Actor]], hostname, port, timeout) } /** * Atomically create (from actor class), start and link an actor. */ - def spawnLink[T <: Actor: Manifest]: ActorRef = - spawnLink(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]]) + def spawnLink[T <: Actor: ClassTag]: ActorRef = + spawnLink(classTag[T].erasure.asInstanceOf[Class[_ <: Actor]]) /** * Atomically create (from actor class), start, link and make an actor remote. */ - def spawnLinkRemote[T <: Actor: Manifest](hostname: String, port: Int, timeout: Long): ActorRef = { + def spawnLinkRemote[T <: Actor: ClassTag](hostname: String, port: Int, timeout: Long): ActorRef = { ensureRemotingEnabled - spawnLinkRemote(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]], hostname, port, timeout) + spawnLinkRemote(classTag[T].erasure.asInstanceOf[Class[_ <: Actor]], hostname, port, timeout) } } diff --git a/test/disabled/presentation/akka/src/akka/actor/ActorRegistry.scala b/test/disabled/presentation/akka/src/akka/actor/ActorRegistry.scala index df335dc8b4..5d649fcd36 100644 --- a/test/disabled/presentation/akka/src/akka/actor/ActorRegistry.scala +++ b/test/disabled/presentation/akka/src/akka/actor/ActorRegistry.scala @@ -5,7 +5,7 @@ package akka.actor import scala.collection.mutable.{ ListBuffer, Map } -import scala.reflect.Manifest +import scala.reflect.ArrayTag import java.util.concurrent.{ ConcurrentSkipListSet, ConcurrentHashMap } import java.util.{ Set => JSet } @@ -74,10 +74,10 @@ final class ActorRegistry private[actor] () extends ListenerManagement { } /** - * Finds all actors that are subtypes of the class passed in as the Manifest argument and supporting passed message. + * Finds all actors that are subtypes of the class passed in as the ClassTag argument and supporting passed message. */ - def actorsFor[T <: Actor](message: Any)(implicit manifest: Manifest[T]): Array[ActorRef] = - filter(a => manifest.erasure.isAssignableFrom(a.actor.getClass) && a.isDefinedAt(message)) + def actorsFor[T <: Actor](message: Any)(implicit classTag: ClassTag[T]): Array[ActorRef] = + filter(a => classTag.erasure.isAssignableFrom(a.actor.getClass) && a.isDefinedAt(message)) /** * Finds all actors that satisfy a predicate. @@ -93,16 +93,16 @@ final class ActorRegistry private[actor] () extends ListenerManagement { } /** - * Finds all actors that are subtypes of the class passed in as the Manifest argument. + * Finds all actors that are subtypes of the class passed in as the ClassTag argument. */ - def actorsFor[T <: Actor](implicit manifest: Manifest[T]): Array[ActorRef] = - actorsFor[T](manifest.erasure.asInstanceOf[Class[T]]) + def actorsFor[T <: Actor](implicit classTag: ClassTag[T]): Array[ActorRef] = + actorsFor[T](classTag.erasure.asInstanceOf[Class[T]]) /** * Finds any actor that matches T. Very expensive, traverses ALL alive actors. */ - def actorFor[T <: Actor](implicit manifest: Manifest[T]): Option[ActorRef] = - find({ case a: ActorRef if manifest.erasure.isAssignableFrom(a.actor.getClass) => a }) + def actorFor[T <: Actor](implicit classTag: ClassTag[T]): Option[ActorRef] = + find({ case a: ActorRef if classTag.erasure.isAssignableFrom(a.actor.getClass) => a }) /** * Finds all actors of type or sub-type specified by the class passed in as the Class argument. @@ -166,21 +166,21 @@ final class ActorRegistry private[actor] () extends ListenerManagement { } /** - * Finds all typed actors that are subtypes of the class passed in as the Manifest argument. + * Finds all typed actors that are subtypes of the class passed in as the ClassTag argument. */ - def typedActorsFor[T <: AnyRef](implicit manifest: Manifest[T]): Array[AnyRef] = { + def typedActorsFor[T <: AnyRef](implicit classTag: ClassTag[T]): Array[AnyRef] = { TypedActorModule.ensureEnabled - typedActorsFor[T](manifest.erasure.asInstanceOf[Class[T]]) + typedActorsFor[T](classTag.erasure.asInstanceOf[Class[T]]) } /** * Finds any typed actor that matches T. */ - def typedActorFor[T <: AnyRef](implicit manifest: Manifest[T]): Option[AnyRef] = { + def typedActorFor[T <: AnyRef](implicit classTag: ClassTag[T]): Option[AnyRef] = { TypedActorModule.ensureEnabled def predicate(proxy: AnyRef): Boolean = { val actorRef = TypedActorModule.typedActorObjectInstance.get.actorFor(proxy) - actorRef.isDefined && manifest.erasure.isAssignableFrom(actorRef.get.actor.getClass) + actorRef.isDefined && classTag.erasure.isAssignableFrom(actorRef.get.actor.getClass) } findTypedActor({ case a: Some[AnyRef] if predicate(a.get) => a }) } @@ -279,7 +279,7 @@ final class ActorRegistry private[actor] () extends ListenerManagement { * * @author Viktor Klang */ -class Index[K <: AnyRef, V <: AnyRef: Manifest] { +class Index[K <: AnyRef, V <: AnyRef: ArrayTag] { private val Naught = Array[V]() //Nil for Arrays private val container = new ConcurrentHashMap[K, JSet[V]] private val emptySet = new ConcurrentSkipListSet[V] diff --git a/test/disabled/presentation/akka/src/akka/event/EventHandler.scala b/test/disabled/presentation/akka/src/akka/event/EventHandler.scala index f3176b7c21..af2fee6c47 100644 --- a/test/disabled/presentation/akka/src/akka/event/EventHandler.scala +++ b/test/disabled/presentation/akka/src/akka/event/EventHandler.scala @@ -115,8 +115,8 @@ object EventHandler extends ListenerManagement { notifyListeners(event) } - def notify[T <: Event: ClassManifest](event: => T) { - if (level >= levelFor(classManifest[T].erasure.asInstanceOf[Class[_ <: Event]])) notifyListeners(event) + def notify[T <: Event: ClassTag](event: => T) { + if (level >= levelFor(classTag[T].erasure.asInstanceOf[Class[_ <: Event]])) notifyListeners(event) } def error(cause: Throwable, instance: AnyRef, message: => String) { diff --git a/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala b/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala index 0c5da82294..5219c49dcb 100644 --- a/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala +++ b/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala @@ -206,8 +206,8 @@ abstract class RemoteSupport extends ListenerManagement with RemoteServerModule * </pre> */ @deprecated("Will be removed after 1.1", "1.1") - def actorOf[T <: Actor: Manifest](host: String, port: Int): ActorRef = - clientManagedActorOf(() => createActorFromClass(manifest.erasure), host, port) + def actorOf[T <: Actor: ClassTag](host: String, port: Int): ActorRef = + clientManagedActorOf(() => createActorFromClass(classTag[T].erasure), host, port) protected def createActorFromClass(clazz: Class[_]): Actor = { import ReflectiveAccess.{ createInstance, noParams, noArgs } diff --git a/test/disabled/presentation/akka/src/akka/util/Helpers.scala b/test/disabled/presentation/akka/src/akka/util/Helpers.scala index 48477426c9..0ff45408d0 100644 --- a/test/disabled/presentation/akka/src/akka/util/Helpers.scala +++ b/test/disabled/presentation/akka/src/akka/util/Helpers.scala @@ -37,7 +37,7 @@ object Helpers { * Convenience helper to cast the given Option of Any to an Option of the given type. Will swallow a possible * ClassCastException and return None in that case. */ - def narrowSilently[T: Manifest](o: Option[Any]): Option[T] = + def narrowSilently[T: ClassTag](o: Option[Any]): Option[T] = try { narrow(o) } catch { diff --git a/test/disabled/presentation/simple-tests.check b/test/disabled/presentation/simple-tests.check index b90dfce77c..cdb80ed987 100644 --- a/test/disabled/presentation/simple-tests.check +++ b/test/disabled/presentation/simple-tests.check @@ -244,7 +244,7 @@ TypeMember(method disable,(s: Tester.this.settings.Setting)scala.collection.muta TypeMember(value disable,Tester.this.settings.MultiStringSetting,false,true,<none>) TypeMember(value elidebelow,Tester.this.settings.IntSetting,false,true,<none>) TypeMember(method embeddedDefaults,(loader: java.lang.ClassLoader)Unit,true,true,<none>) -TypeMember(method embeddedDefaults,[T](implicit evidence$1: Manifest[T])Unit,true,true,<none>) +TypeMember(method embeddedDefaults,[T](implicit evidence$1: ClassTag[T])Unit,true,true,<none>) TypeMember(value encoding,Tester.this.settings.StringSetting,false,true,<none>) TypeMember(method ensuring,(cond: (scala.tools.nsc.Settings) => Boolean,msg: => Any)scala.tools.nsc.Settings,true,false,method any2Ensuring) TypeMember(method ensuring,(cond: (scala.tools.nsc.Settings) => Boolean)scala.tools.nsc.Settings,true,false,method any2Ensuring) diff --git a/test/files/jvm/manifests-new.check b/test/files/jvm/manifests-new.check new file mode 100644 index 0000000000..9fca856970 --- /dev/null +++ b/test/files/jvm/manifests-new.check @@ -0,0 +1,58 @@ +x=(), t=ConcreteTypeTag[Unit], k=TypeRef, s=class Unit
+x=true, t=ConcreteTypeTag[Boolean], k=TypeRef, s=class Boolean
+x=a, t=ConcreteTypeTag[Char], k=TypeRef, s=class Char
+x=1, t=ConcreteTypeTag[Int], k=TypeRef, s=class Int
+x=abc, t=ConcreteTypeTag[String], k=TypeRef, s=class String
+x='abc, t=ConcreteTypeTag[Symbol], k=TypeRef, s=class Symbol
+
+x=List(()), t=ConcreteTypeTag[List[Unit]], k=TypeRef, s=class List
+x=List(true), t=ConcreteTypeTag[List[Boolean]], k=TypeRef, s=class List
+x=List(1), t=ConcreteTypeTag[List[Int]], k=TypeRef, s=class List
+x=List(abc), t=ConcreteTypeTag[List[String]], k=TypeRef, s=class List
+x=List('abc), t=ConcreteTypeTag[List[Symbol]], k=TypeRef, s=class List
+
+x=[Z, t=ConcreteTypeTag[Array[Boolean]], k=TypeRef, s=class Array
+x=[C, t=ConcreteTypeTag[Array[Char]], k=TypeRef, s=class Array
+x=[I, t=ConcreteTypeTag[Array[Int]], k=TypeRef, s=class Array
+x=[Ljava.lang.String;, t=ConcreteTypeTag[Array[String]], k=TypeRef, s=class Array
+x=[Lscala.Symbol;, t=ConcreteTypeTag[Array[Symbol]], k=TypeRef, s=class Array
+
+x=((),()), t=ConcreteTypeTag[(Unit, Unit)], k=TypeRef, s=class Tuple2
+x=(true,false), t=ConcreteTypeTag[(Boolean, Boolean)], k=TypeRef, s=class Tuple2
+x=(1,2), t=ConcreteTypeTag[(Int, Int)], k=TypeRef, s=class Tuple2
+x=(abc,xyz), t=ConcreteTypeTag[(String, String)], k=TypeRef, s=class Tuple2
+x=('abc,'xyz), t=ConcreteTypeTag[(Symbol, Symbol)], k=TypeRef, s=class Tuple2
+
+x=Test$, t=ConcreteTypeTag[Test.type], k=TypeRef, s=object Test
+x=scala.collection.immutable.List$, t=ConcreteTypeTag[scala.collection.immutable.List.type], k=TypeRef, s=object List
+
+x=Foo, t=ConcreteTypeTag[Foo[Int]], k=TypeRef, s=class Foo
+x=Foo, t=ConcreteTypeTag[Foo[List[Int]]], k=TypeRef, s=class Foo
+x=Foo, t=ConcreteTypeTag[Foo[Foo[Int]]], k=TypeRef, s=class Foo
+x=Foo, t=ConcreteTypeTag[Foo[List[Foo[Int]]]], k=TypeRef, s=class Foo
+
+x=Test1$$anon$1, t=ConcreteTypeTag[Bar[String]], k=RefinedType, s=<local Test1>
+x=Test1$$anon$2, t=ConcreteTypeTag[Bar[String]], k=RefinedType, s=<local Test1>
+
+()=()
+true=true
+a=a
+1=1
+'abc='abc
+
+List(())=List(())
+List(true)=List(true)
+List('abc)=List('abc)
+
+Array()=Array()
+Array(true)=Array(true)
+Array(a)=Array(a)
+Array(1)=Array(1)
+
+((),())=((),())
+(true,false)=(true,false)
+
+List(List(1), List(2))=List(List(1), List(2))
+
+Array(Array(1), Array(2))=Array(Array(1), Array(2))
+
diff --git a/test/files/jvm/manifests.scala b/test/files/jvm/manifests-new.scala index 935427f5d4..d02f6ee608 100644 --- a/test/files/jvm/manifests.scala +++ b/test/files/jvm/manifests-new.scala @@ -37,11 +37,8 @@ object Test1 extends TestUtil { print(('abc, 'xyz)) println() - // Disabled: should these work? changing the inference for objects from - // "object Test" to "Test.type" drags in a singleton manifest which for - // some reason leads to serialization failure. - // print(Test) - // print(List) + print(Test) + print(List) println() print(new Foo(2)) @@ -69,8 +66,8 @@ object Test2 { println("List('abc)="+load[List[Symbol]](dump(List('abc)))) println() - def loadArray[T](x: Array[Byte])(implicit m: reflect.Manifest[Array[T]]) = - load[Array[T]](x)(m).deep.toString + def loadArray[T](x: Array[Byte])(implicit t: reflect.ClassTag[Array[T]]) = + load[Array[T]](x)(t).deep.toString println("Array()="+loadArray[Int](dump(Array(): Array[Int]))) println("Array(true)="+loadArray[Boolean](dump(Array(true)))) println("Array(a)="+loadArray[Char](dump(Array('a')))) @@ -102,11 +99,11 @@ trait TestUtil { in.readObject().asInstanceOf[A] } import scala.reflect._ - def print[T](x: T)(implicit m: Manifest[T]) { - // manifests are no longer serializable -// val m1: Manifest[T] = read(write(m)) - val m1: Manifest[T] = m + def print[T](x: T)(implicit t: ConcreteTypeTag[T]) { + // todo. type tags are not yet serializable +// val t1: ConcreteTypeTag[T] = read(write(t)) + val t1: ConcreteTypeTag[T] = t val x1 = x.toString.replaceAll("@[0-9a-z]+$", "") - println("x="+x1+", m="+m1+", k="+m1.tpe.kind+", s="+m1.sym.toString) + println("x="+x1+", t="+t1+", k="+t1.tpe.kind+", s="+t1.sym.toString) } } diff --git a/test/files/jvm/manifests.check b/test/files/jvm/manifests.check deleted file mode 100644 index be8ec2bb5b..0000000000 --- a/test/files/jvm/manifests.check +++ /dev/null @@ -1,56 +0,0 @@ -x=(), m=ConcreteTypeTag[Unit], k=TypeRef, s=class Unit
-x=true, m=ConcreteTypeTag[Boolean], k=TypeRef, s=class Boolean
-x=a, m=ConcreteTypeTag[Char], k=TypeRef, s=class Char
-x=1, m=ConcreteTypeTag[Int], k=TypeRef, s=class Int
-x=abc, m=ConcreteTypeTag[String], k=TypeRef, s=class String
-x='abc, m=ConcreteTypeTag[Symbol], k=TypeRef, s=class Symbol
-
-x=List(()), m=ConcreteTypeTag[List[Unit]], k=TypeRef, s=class List
-x=List(true), m=ConcreteTypeTag[List[Boolean]], k=TypeRef, s=class List
-x=List(1), m=ConcreteTypeTag[List[Int]], k=TypeRef, s=class List
-x=List(abc), m=ConcreteTypeTag[List[String]], k=TypeRef, s=class List
-x=List('abc), m=ConcreteTypeTag[List[Symbol]], k=TypeRef, s=class List
-
-x=[Z, m=ConcreteTypeTag[Array[Boolean]], k=TypeRef, s=class Array
-x=[C, m=ConcreteTypeTag[Array[Char]], k=TypeRef, s=class Array
-x=[I, m=ConcreteTypeTag[Array[Int]], k=TypeRef, s=class Array
-x=[Ljava.lang.String;, m=ConcreteTypeTag[Array[String]], k=TypeRef, s=class Array
-x=[Lscala.Symbol;, m=ConcreteTypeTag[Array[Symbol]], k=TypeRef, s=class Array
-
-x=((),()), m=ConcreteTypeTag[(Unit, Unit)], k=TypeRef, s=class Tuple2
-x=(true,false), m=ConcreteTypeTag[(Boolean, Boolean)], k=TypeRef, s=class Tuple2
-x=(1,2), m=ConcreteTypeTag[(Int, Int)], k=TypeRef, s=class Tuple2
-x=(abc,xyz), m=ConcreteTypeTag[(String, String)], k=TypeRef, s=class Tuple2
-x=('abc,'xyz), m=ConcreteTypeTag[(Symbol, Symbol)], k=TypeRef, s=class Tuple2
-
-
-x=Foo, m=ConcreteTypeTag[Foo[Int]], k=TypeRef, s=class Foo
-x=Foo, m=ConcreteTypeTag[Foo[List[Int]]], k=TypeRef, s=class Foo
-x=Foo, m=ConcreteTypeTag[Foo[Foo[Int]]], k=TypeRef, s=class Foo
-x=Foo, m=ConcreteTypeTag[Foo[List[Foo[Int]]]], k=TypeRef, s=class Foo
-
-x=Test1$$anon$1, m=ConcreteTypeTag[Bar[String]], k=RefinedType, s=<local Test1>
-x=Test1$$anon$2, m=ConcreteTypeTag[Bar[String]], k=RefinedType, s=<local Test1>
-
-()=()
-true=true
-a=a
-1=1
-'abc='abc
-
-List(())=List(())
-List(true)=List(true)
-List('abc)=List('abc)
-
-Array()=Array()
-Array(true)=Array(true)
-Array(a)=Array(a)
-Array(1)=Array(1)
-
-((),())=((),())
-(true,false)=(true,false)
-
-List(List(1), List(2))=List(List(1), List(2))
-
-Array(Array(1), Array(2))=Array(Array(1), Array(2))
-
diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization-new.check index fa51c6a879..fa51c6a879 100644 --- a/test/files/jvm/serialization.check +++ b/test/files/jvm/serialization-new.check diff --git a/test/files/jvm/serialization.scala b/test/files/jvm/serialization-new.scala index 9c2f2acdbf..bb971fdf36 100644 --- a/test/files/jvm/serialization.scala +++ b/test/files/jvm/serialization-new.scala @@ -282,7 +282,7 @@ object Test2_immutable { // Test classes in package "scala.collection.mutable" object Test3_mutable { - import scala.reflect.ClassManifest + import scala.reflect.ArrayTag import scala.collection.mutable.{ ArrayBuffer, ArrayBuilder, ArraySeq, ArrayStack, BitSet, DoubleLinkedList, HashMap, HashSet, History, LinkedList, ListBuffer, Publisher, Queue, @@ -296,21 +296,21 @@ object Test3_mutable { ab1 ++= List("one", "two") val _ab1: ArrayBuffer[String] = read(write(ab1)) check(ab1, _ab1) - + // ArrayBuilder val abu1 = ArrayBuilder.make[Long] - val _abu1: ArrayBuilder[ClassManifest[Long]] = read(write(abu1)) + val _abu1: ArrayBuilder[ArrayTag[Long]] = read(write(abu1)) check(abu1, _abu1) val abu2 = ArrayBuilder.make[Float] - val _abu2: ArrayBuilder[ClassManifest[Float]] = read(write(abu2)) + val _abu2: ArrayBuilder[ArrayTag[Float]] = read(write(abu2)) check(abu2, _abu2) - + // ArraySeq val aq1 = ArraySeq(1, 2, 3) val _aq1: ArraySeq[Int] = read(write(aq1)) check(aq1, _aq1) - + // ArrayStack val as1 = new ArrayStack[Int] as1 ++= List(20, 2, 3).iterator @@ -381,12 +381,12 @@ object Test3_mutable { val wa1 = WrappedArray.make(Array(1, 2, 3)) val _wa1: WrappedArray[Int] = read(write(wa1)) check(wa1, _wa1) - + // TreeSet val ts1 = TreeSet[Int]() ++= Array(1, 2, 3) val _ts1: TreeSet[Int] = read(write(ts1)) check(ts1, _ts1) - + // concurrent.TrieMap val ct1 = TrieMap[Int, String]() ++= Array(1 -> "one", 2 -> "two", 3 -> "three") val _ct1: TrieMap[Int, String] = read(write(ct1)) @@ -548,7 +548,7 @@ class WithTransient extends Serializable { @transient private lazy val a2 = 2 @transient object B extends Serializable @transient private object C extends Serializable - + def test = { println(a1) println(a2) @@ -594,55 +594,55 @@ object Test { // Test classes in package "scala.collection.parallel" and subpackages object Test9_parallel { import scala.collection.parallel._ - + try { println() - + // UnrolledBuffer val ub = new collection.mutable.UnrolledBuffer[String] ub ++= List("one", "two") val _ub: collection.mutable.UnrolledBuffer[String] = read(write(ub)) check(ub, _ub) - + // mutable.ParArray val pa = mutable.ParArray("abc", "def", "etc") val _pa: mutable.ParArray[String] = read(write(pa)) check(pa, _pa) - + // mutable.ParHashMap val mpm = mutable.ParHashMap(1 -> 2, 2 -> 4) val _mpm: mutable.ParHashMap[Int, Int] = read(write(mpm)) check(mpm, _mpm) - + // mutable.ParTrieMap val mpc = mutable.ParTrieMap(1 -> 2, 2 -> 4) val _mpc: mutable.ParTrieMap[Int, Int] = read(write(mpc)) check(mpc, _mpc) - + // mutable.ParHashSet val mps = mutable.ParHashSet(1, 2, 3) val _mps: mutable.ParHashSet[Int] = read(write(mps)) check(mps, _mps) - + // immutable.ParRange val pr1 = immutable.ParRange(0, 4, 1, true) val _pr1: immutable.ParRange = read(write(pr1)) check(pr1, _pr1) - + val pr2 = immutable.ParRange(0, 4, 1, false) val _pr2: immutable.ParRange = read(write(pr2)) check(pr2, _pr2) - + // immutable.ParHashMap val ipm = immutable.ParHashMap(5 -> 1, 10 -> 2) val _ipm: immutable.ParHashMap[Int, Int] = read(write(ipm)) check(ipm, _ipm) - + // immutable.ParHashSet val ips = immutable.ParHashSet("one", "two") val _ips: immutable.ParHashSet[String] = read(write(ips)) check(ips, _ips) - + } catch { case e: Exception => println("Error in Test5_parallel: " + e) diff --git a/test/files/neg/t2386.check b/test/files/neg/t2386.check deleted file mode 100644 index f70f12535f..0000000000 --- a/test/files/neg/t2386.check +++ /dev/null @@ -1,4 +0,0 @@ -t2386.scala:2: error: No ClassTag available for Array[_ >: String with Int]
- val a = Array(Array(1, 2), Array("a","b"))
- ^
-one error found
diff --git a/test/files/neg/t2386.scala b/test/files/neg/t2386.scala deleted file mode 100644 index 56146cc5c3..0000000000 --- a/test/files/neg/t2386.scala +++ /dev/null @@ -1,3 +0,0 @@ -object Test { - val a = Array(Array(1, 2), Array("a","b")) -} diff --git a/test/files/neg/t3692-new.check b/test/files/neg/t3692-new.check new file mode 100644 index 0000000000..e013daca74 --- /dev/null +++ b/test/files/neg/t3692-new.check @@ -0,0 +1,4 @@ +t3692-new.scala:15: error: unreachable code
+ case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
+ ^
+one error found
diff --git a/test/files/neg/t3692.flags b/test/files/neg/t3692-new.flags index 82becdfbfd..82becdfbfd 100644 --- a/test/files/neg/t3692.flags +++ b/test/files/neg/t3692-new.flags diff --git a/test/files/neg/t3692.scala b/test/files/neg/t3692-new.scala index 151535ae94..46874b02e3 100644 --- a/test/files/neg/t3692.scala +++ b/test/files/neg/t3692-new.scala @@ -1,14 +1,14 @@ import java.lang.Integer -object ManifestTester { +object Tester { def main(args: Array[String]) = { val map = Map("John" -> 1, "Josh" -> 2) - new ManifestTester().toJavaMap(map) + new Tester().toJavaMap(map) } } -class ManifestTester { - private final def toJavaMap[T, V](map: Map[T, V])(implicit m1: Manifest[T], m2: Manifest[V]): java.util.Map[_, _] = { +class Tester { + private final def toJavaMap[T, V](map: Map[T, V])(implicit m1: ClassTag[T], m2: ClassTag[V]): java.util.Map[_, _] = { map match { case m0: Map[Int, Int] => new java.util.HashMap[Integer, Integer] case m1: Map[Int, V] => new java.util.HashMap[Integer, V] diff --git a/test/files/neg/t3692.check b/test/files/neg/t3692.check deleted file mode 100644 index d83abd31e2..0000000000 --- a/test/files/neg/t3692.check +++ /dev/null @@ -1,11 +0,0 @@ -t3692.scala:11: warning: type Manifest in object Predef is deprecated: Use `@scala.reflect.ConcreteTypeTag` instead
- private final def toJavaMap[T, V](map: Map[T, V])(implicit m1: Manifest[T], m2: Manifest[V]): java.util.Map[_, _] = {
- ^
-t3692.scala:11: warning: type Manifest in object Predef is deprecated: Use `@scala.reflect.ConcreteTypeTag` instead
- private final def toJavaMap[T, V](map: Map[T, V])(implicit m1: Manifest[T], m2: Manifest[V]): java.util.Map[_, _] = {
- ^
-t3692.scala:15: error: unreachable code
- case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
- ^
-two warnings found
-one error found
diff --git a/test/files/neg/t5452-new.check b/test/files/neg/t5452-new.check new file mode 100644 index 0000000000..bbd3734f74 --- /dev/null +++ b/test/files/neg/t5452-new.check @@ -0,0 +1,8 @@ +t5452-new.scala:28: error: overloaded method value apply with alternatives:
+ ()Queryable[CoffeesTable] <and>
+ (t: Tree)(implicit evidence$2: ClassTag[CoffeesTable])Nothing <and>
+ (implicit evidence$1: ClassTag[CoffeesTable])Nothing
+ cannot be applied to (Queryable[CoffeesTable])
+ Queryable[CoffeesTable]( q.treeFilter(null) )
+ ^
+one error found
diff --git a/test/files/neg/t5452.scala b/test/files/neg/t5452-new.scala index 1032db7a4b..c829de7d7c 100644 --- a/test/files/neg/t5452.scala +++ b/test/files/neg/t5452-new.scala @@ -15,8 +15,8 @@ case class Queryable[T]() { } object Queryable { - def apply[T:Manifest] = ??? - def apply[T:Manifest]( t:Tree ) = ??? + def apply[T:ClassTag] = ??? + def apply[T:ClassTag]( t:Tree ) = ??? } trait CoffeesTable{ diff --git a/test/files/neg/t5452.check b/test/files/neg/t5452.check deleted file mode 100644 index 2f35a45509..0000000000 --- a/test/files/neg/t5452.check +++ /dev/null @@ -1,8 +0,0 @@ -t5452.scala:28: error: overloaded method value apply with alternatives: - ()Queryable[CoffeesTable] <and> - (t: Tree)(implicit evidence$2: Manifest[CoffeesTable])Nothing <and> - (implicit evidence$1: Manifest[CoffeesTable])Nothing - cannot be applied to (Queryable[CoffeesTable]) - Queryable[CoffeesTable]( q.treeFilter(null) ) - ^ -one error found diff --git a/test/files/pos/contextbounds-implicits.scala b/test/files/pos/contextbounds-implicits-new.scala index f9113ee320..71b3cca36f 100644 --- a/test/files/pos/contextbounds-implicits.scala +++ b/test/files/pos/contextbounds-implicits-new.scala @@ -3,6 +3,6 @@ */ class C { - def f[T: Manifest, S: Manifest](x: T, y: S)(implicit p: C) { } + def f[T: TypeTag, S: TypeTag](x: T, y: S)(implicit p: C) { } } diff --git a/test/files/pos/implicits.scala b/test/files/pos/implicits-new.scala index 2c01dd0ba8..7eb7e100c3 100644 --- a/test/files/pos/implicits.scala +++ b/test/files/pos/implicits-new.scala @@ -45,7 +45,7 @@ object Test1625 { implicit def byName[A](x: =>A) = new Wrapped(x) implicit def byVal[A](x: A) = x - + def main(args: Array[String]) = { // val res:Wrapped = 7 // works @@ -57,7 +57,7 @@ object Test1625 { } object Test2188 { - implicit def toJavaList[A: ClassManifest](t:collection.Seq[A]):java.util.List[A] = java.util.Arrays.asList(t.toArray:_*) + implicit def toJavaList[A: ArrayTag](t:collection.Seq[A]):java.util.List[A] = java.util.Arrays.asList(t.toArray:_*) val x: java.util.List[String] = List("foo") } @@ -67,23 +67,23 @@ object TestNumericWidening { val x: java.lang.Long = y } -// #2709 -package foo2709 { - class A - class B - - package object bar { - implicit def a2b(a: A): B = new B - } - - package bar { - object test { - new A: B - } - } -} +// #2709 +package foo2709 { + class A + class B + + package object bar { + implicit def a2b(a: A): B = new B + } + + package bar { + object test { + new A: B + } + } +} // Problem with specs object specsProblem { - println(implicitly[Manifest[Class[_]]]) + println(implicitly[ConcreteTypeTag[Class[_]]]) } diff --git a/test/files/pos/manifest1.scala b/test/files/pos/manifest1-new.scala index 8901aa7437..645bd42665 100644 --- a/test/files/pos/manifest1.scala +++ b/test/files/pos/manifest1-new.scala @@ -1,7 +1,7 @@ -import scala.reflect.Manifest +import scala.reflect.TypeTag object Test { - def foo[T](x: T)(implicit m: Manifest[T]) { + def foo[T](x: T)(implicit m: TypeTag[T]) { foo(List(x)) } foo(1) @@ -13,8 +13,8 @@ object Test { abstract class C { type T = String; val x: T } val c = new C { val x = "abc" } foo(c.x) - abstract class D { type T; implicit val m: Manifest[T]; val x: T } - val stringm = implicitly[Manifest[String]] + abstract class D { type T; implicit val m: TypeTag[T]; val x: T } + val stringm = implicitly[TypeTag[String]] val d: D = new D { type T = String; val m = stringm; val x = "x" } import d.m foo(d.x) diff --git a/test/files/pos/nothing_manifest_disambig-new.scala b/test/files/pos/nothing_manifest_disambig-new.scala new file mode 100644 index 0000000000..a60b0fdbf8 --- /dev/null +++ b/test/files/pos/nothing_manifest_disambig-new.scala @@ -0,0 +1,10 @@ +object Test { + def mani[T: TypeTag](xs: T) = xs + mani(List()) + + def listElMani[T: TypeTag](xs: List[T]) = xs + listElMani(List()) + + def foo[A, C](m : C)(implicit ev: C <:< Traversable[A], mani: TypeTag[A]): (C, A, TypeTag[A]) = (m, m.head, mani) + foo(List(1,2,3)) +}
\ No newline at end of file diff --git a/test/files/pos/nothing_manifest_disambig.scala b/test/files/pos/nothing_manifest_disambig.scala deleted file mode 100644 index 076742033f..0000000000 --- a/test/files/pos/nothing_manifest_disambig.scala +++ /dev/null @@ -1,10 +0,0 @@ -object Test { - def mani[T: Manifest](xs: T) = xs - mani(List()) - - def listElMani[T: Manifest](xs: List[T]) = xs - listElMani(List()) - - def foo[A, C](m : C)(implicit ev: C <:< Traversable[A], mani: Manifest[A]): (C, A, Manifest[A]) = (m, m.head, mani) - foo(List(1,2,3)) -}
\ No newline at end of file diff --git a/test/files/pos/spec-constr.scala b/test/files/pos/spec-constr-new.scala index e908b65a41..7cd02b0680 100644 --- a/test/files/pos/spec-constr.scala +++ b/test/files/pos/spec-constr-new.scala @@ -1,4 +1,4 @@ -class SparseArray2[@specialized(Int) T:ClassManifest](val maxSize: Int, initialLength:Int = 3) { +class SparseArray2[@specialized(Int) T:ArrayTag](val maxSize: Int, initialLength:Int = 3) { private var data = new Array[T](initialLength); private var index = new Array[Int](initialLength); diff --git a/test/files/pos/spec-doubledef.scala b/test/files/pos/spec-doubledef-new.scala index 86b0d857d3..33f1e82b6e 100644 --- a/test/files/pos/spec-doubledef.scala +++ b/test/files/pos/spec-doubledef-new.scala @@ -13,7 +13,7 @@ class C extends A[Int] { override def getWith[@specialized(Int) Z](f: Int => Z) = f(value) } -abstract class B[T, @specialized(scala.Int) U : Manifest, @specialized(scala.Int) V <% Ordered[V]] { +abstract class B[T, @specialized(scala.Int) U : TypeTag, @specialized(scala.Int) V <% Ordered[V]] { val u: U val v: V diff --git a/test/files/pos/spec-fields.scala b/test/files/pos/spec-fields-new.scala index 26a8c4ffbd..ddd8bd6624 100644 --- a/test/files/pos/spec-fields.scala +++ b/test/files/pos/spec-fields-new.scala @@ -1,4 +1,4 @@ -abstract class Foo[@specialized T: ClassManifest, U <: Ordered[U]](x: T, size: Int) { +abstract class Foo[@specialized T: ArrayTag, U <: Ordered[U]](x: T, size: Int) { var y: T var z: T = x diff --git a/test/files/pos/spec-params.scala b/test/files/pos/spec-params-new.scala index f522512846..5fe0c82d40 100644 --- a/test/files/pos/spec-params.scala +++ b/test/files/pos/spec-params-new.scala @@ -1,4 +1,4 @@ -class Foo[@specialized A: ClassManifest] { +class Foo[@specialized A: ArrayTag] { // conflicting in bounds, expect a normalized member calling m // and bridge + implementation in specialized subclasses @@ -10,7 +10,7 @@ class Foo[@specialized A: ClassManifest] { def m2[@specialized B <: String](x: B) = x.concat("a") // conflicting in bounds, no mention of other spec members - // expect an overload here plus implementation in + // expect an overload here plus implementation in // compatible specialized subclasses def m3[@specialized B >: A](x: B) = () @@ -19,10 +19,10 @@ class Foo[@specialized A: ClassManifest] { // non-conflicting, expect a normalized overload implementation here def m5[@specialized B](x: B) = x - + // non-conflicting, expect a normalized implementation here // and specialized implementations for all expansions in specialized subclasses - def m6[@specialized B](x: B, y: A) = + def m6[@specialized B](x: B, y: A) = goal(y) def goal(x: A) = { diff --git a/test/files/pos/spec-sparsearray.scala b/test/files/pos/spec-sparsearray-new.scala index ea7710a785..0659bf7926 100644 --- a/test/files/pos/spec-sparsearray.scala +++ b/test/files/pos/spec-sparsearray-new.scala @@ -1,6 +1,6 @@ import scala.collection.mutable.MapLike -class SparseArray[@specialized(Int) T:ClassManifest] extends collection.mutable.Map[Int,T] with collection.mutable.MapLike[Int,T,SparseArray[T]] { +class SparseArray[@specialized(Int) T:ArrayTag] extends collection.mutable.Map[Int,T] with collection.mutable.MapLike[Int,T,SparseArray[T]] { override def get(x: Int) = { val ind = findOffset(x) if(ind < 0) None else Some(error("ignore")) diff --git a/test/files/pos/t1381.scala b/test/files/pos/t1381-new.scala index 0762891898..8781ef4fdb 100644 --- a/test/files/pos/t1381.scala +++ b/test/files/pos/t1381-new.scala @@ -1,4 +1,4 @@ -import scala.reflect.Manifest +import scala.reflect.TypeTag class D[V <: Variable] diff --git a/test/files/pos/t2795.scala b/test/files/pos/t2795-new.scala index 935cb1f444..af9c4e8b1c 100644 --- a/test/files/pos/t2795.scala +++ b/test/files/pos/t2795-new.scala @@ -5,7 +5,7 @@ trait Element[T] { trait Config { type T <: Element[T] - implicit val m: ClassManifest[T] + implicit val m: ArrayTag[T] // XXX Following works fine: // type T <: Element[_] } diff --git a/test/files/pos/t3363.scala b/test/files/pos/t3363-new.scala index bae54084ea..270462745c 100755..100644 --- a/test/files/pos/t3363.scala +++ b/test/files/pos/t3363-new.scala @@ -7,12 +7,12 @@ object TestCase { //if you inherit from MapOps[T] instead of MapOps[F] then code compiles fine implicit def map2ops[T,F](fs: Map[T,F]) = new MapOps[F] { //if you remove this line, then code compiles - lazy val m: Manifest[T] = error("just something to make it compile") - def is(xs: List[T]) = List(xs) - } + lazy val m: TypeTag[T] = error("just something to make it compile") + def is(xs: List[T]) = List(xs) + } - def main(args: Array[String]) { - println(Map(1 -> "2") is List(2)) - } + def main(args: Array[String]) { + println(Map(1 -> "2") is List(2)) + } - } + } diff --git a/test/files/pos/t3498.scala b/test/files/pos/t3498-new.scala index bcc90ca64c..653c50042a 100644 --- a/test/files/pos/t3498.scala +++ b/test/files/pos/t3498-new.scala @@ -1,4 +1,4 @@ -abstract class A[T, @specialized(scala.Int) U : Manifest] { +abstract class A[T, @specialized(scala.Int) U : ArrayTag] { def f(state: T): Array[U] } diff --git a/test/files/presentation/ide-bug-1000531.check b/test/files/presentation/ide-bug-1000531.check index ae202001eb..2b48a80d38 100644 --- a/test/files/presentation/ide-bug-1000531.check +++ b/test/files/presentation/ide-bug-1000531.check @@ -99,7 +99,7 @@ retrieved 123 members `method synchronized[T0](x$1: T0)T0` `method take(n: Int)Iterator[B]` `method takeWhile(p: B => Boolean)Iterator[B]` -`method toArray[B >: B](implicit evidence$1: ClassManifest[B])Array[B]` +`method toArray[B >: B](implicit evidence$1: ArrayTag[B])Array[B]` `method toBuffer[B >: B]=> scala.collection.mutable.Buffer[B]` `method toIndexedSeq=> scala.collection.immutable.IndexedSeq[B]` `method toIterable=> Iterable[B]` diff --git a/test/files/run/arrayclone.scala b/test/files/run/arrayclone-new.scala index c9f7556b47..a4ba021409 100644 --- a/test/files/run/arrayclone.scala +++ b/test/files/run/arrayclone-new.scala @@ -16,7 +16,7 @@ object BooleanArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = false; - assert(it(0) == true) + assert(it(0) == true) } object ByteArrayClone{ @@ -24,7 +24,7 @@ object ByteArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = 0; - assert(it(0) == 1) + assert(it(0) == 1) } object ShortArrayClone{ @@ -32,7 +32,7 @@ object ShortArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = 0; - assert(it(0) == 1) + assert(it(0) == 1) } object CharArrayClone{ @@ -40,7 +40,7 @@ object CharArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = 0; - assert(it(0) == 1) + assert(it(0) == 1) } object IntArrayClone{ @@ -48,7 +48,7 @@ object IntArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = 0; - assert(it(0) == 1) + assert(it(0) == 1) } object LongArrayClone{ @@ -56,7 +56,7 @@ object LongArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = 0; - assert(it(0) == 1) + assert(it(0) == 1) } object FloatArrayClone{ @@ -64,7 +64,7 @@ object FloatArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = 0; - assert(it(0) == 1) + assert(it(0) == 1) } object DoubleArrayClone{ @@ -72,7 +72,7 @@ object DoubleArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = 0; - assert(it(0) == 1) + assert(it(0) == 1) } object ObjectArrayClone{ @@ -80,7 +80,7 @@ object ObjectArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = "0"; - assert(it(0) == "1") + assert(it(0) == "1") } object PolymorphicArrayClone{ @@ -88,14 +88,14 @@ object PolymorphicArrayClone{ val cloned = it.clone(); assert(cloned.sameElements(it)); cloned(0) = zero; - assert(it(0) == one) - } + assert(it(0) == one) + } testIt(Array("one", "two"), "one", "two"); - class Mangler[T: Manifest](ts : T*){ + class Mangler[T: ArrayTag](ts : T*){ // this will always be a BoxedAnyArray even after we've unboxed its contents. - val it = ts.toArray[T]; + val it = ts.toArray[T]; } val mangled = new Mangler[Int](0, 1); diff --git a/test/files/run/ctries/DumbHash.scala b/test/files/run/ctries-new/DumbHash.scala index 8ef325b67c..8ef325b67c 100644 --- a/test/files/run/ctries/DumbHash.scala +++ b/test/files/run/ctries-new/DumbHash.scala diff --git a/test/files/run/ctries/Wrap.scala b/test/files/run/ctries-new/Wrap.scala index 7b645c1612..7b645c1612 100644 --- a/test/files/run/ctries/Wrap.scala +++ b/test/files/run/ctries-new/Wrap.scala diff --git a/test/files/run/ctries/concmap.scala b/test/files/run/ctries-new/concmap.scala index 3ec0256afb..3ec0256afb 100644 --- a/test/files/run/ctries/concmap.scala +++ b/test/files/run/ctries-new/concmap.scala diff --git a/test/files/run/ctries/iterator.scala b/test/files/run/ctries-new/iterator.scala index b953a40e00..b953a40e00 100644 --- a/test/files/run/ctries/iterator.scala +++ b/test/files/run/ctries-new/iterator.scala diff --git a/test/files/run/ctries/lnode.scala b/test/files/run/ctries-new/lnode.scala index 92a31088e5..92a31088e5 100644 --- a/test/files/run/ctries/lnode.scala +++ b/test/files/run/ctries-new/lnode.scala diff --git a/test/files/run/ctries/main.scala b/test/files/run/ctries-new/main.scala index 8db7fcef54..1d40dab6c5 100644 --- a/test/files/run/ctries/main.scala +++ b/test/files/run/ctries-new/main.scala @@ -6,40 +6,40 @@ object Test { - + def main(args: Array[String]) { ConcurrentMapSpec.test() IteratorSpec.test() LNodeSpec.test() SnapshotSpec.test() } - + } trait Spec { - + implicit def str2ops(s: String) = new { def in[U](body: =>U) { // just execute body body } } - + implicit def any2ops(a: Any) = new { def shouldEqual(other: Any) = assert(a == other) } - + def evaluating[U](body: =>U) = new { - def shouldProduce[T <: Throwable: ClassManifest]() = { + def shouldProduce[T <: Throwable: ClassTag]() = { var produced = false try body catch { - case e => if (e.getClass == implicitly[ClassManifest[T]].erasure) produced = true + case e => if (e.getClass == implicitly[ClassTag[T]].erasure) produced = true } finally { - assert(produced, "Did not produce exception of type: " + implicitly[ClassManifest[T]]) + assert(produced, "Did not produce exception of type: " + implicitly[ClassTag[T]]) } } } - + } diff --git a/test/files/run/ctries/snapshot.scala b/test/files/run/ctries-new/snapshot.scala index 5fe77d445b..5fe77d445b 100644 --- a/test/files/run/ctries/snapshot.scala +++ b/test/files/run/ctries-new/snapshot.scala diff --git a/test/files/run/existentials3.check b/test/files/run/existentials3-new.check index e2c9382ab4..66674fbbd6 100644 --- a/test/files/run/existentials3.check +++ b/test/files/run/existentials3-new.check @@ -1,24 +1,24 @@ -ConcreteTypeTag[Bar.type], t=AbstractTypeRef, s= <: scala.runtime.AbstractFunction0[Bar] with Serializable{case def unapply(x$0: Bar): Boolean} with Singleton
-ConcreteTypeTag[Bar], t=AbstractTypeRef, s= <: Test.ToS with Product with Serializable{def copy(): Bar}
-ConcreteTypeTag[Test.ToS], t=RefinedType, s=f3
-ConcreteTypeTag[Test.ToS], t=RefinedType, s=f4
-ConcreteTypeTag[Test.ToS], t=RefinedType, s=f5
-ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0
-ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0
-ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with Test.ToS
-ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with A with Test.ToS
-TypeTag[List[Object{type T1}#T1]], t=TypeRef, s=class List
-ConcreteTypeTag[List[Seq[Int]]], t=TypeRef, s=class List
-ConcreteTypeTag[List[Seq[U forSome { type U <: Int }]]], t=TypeRef, s=class List
-ConcreteTypeTag[Bar.type], t=AbstractTypeRef, s= <: scala.runtime.AbstractFunction0[Bar] with Serializable{case def unapply(x$0: Bar): Boolean} with Singleton
-ConcreteTypeTag[Bar], t=AbstractTypeRef, s= <: Test.ToS with Product with Serializable{def copy(): Bar}
-ConcreteTypeTag[Test.ToS], t=RefinedType, s=g3
-ConcreteTypeTag[Test.ToS], t=RefinedType, s=g4
-ConcreteTypeTag[Test.ToS], t=RefinedType, s=g5
-ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0
-ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0
-ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with Test.ToS
-ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with A with Test.ToS
-TypeTag[List[Object{type T1}#T1]], t=TypeRef, s=class List
-ConcreteTypeTag[List[Seq[Int]]], t=TypeRef, s=class List
-ConcreteTypeTag[List[Seq[U forSome { type U <: Int }]]], t=TypeRef, s=class List
+ConcreteTypeTag[Bar.type], t=AbstractTypeRef, s= <: scala.runtime.AbstractFunction0[Bar] with Serializable{case def unapply(x$0: Bar): Boolean} with Singleton +ConcreteTypeTag[Bar], t=AbstractTypeRef, s= <: Test.ToS with Product with Serializable{def copy(): Bar} +ConcreteTypeTag[Test.ToS], t=RefinedType, s=f3 +ConcreteTypeTag[Test.ToS], t=RefinedType, s=f4 +ConcreteTypeTag[Test.ToS], t=RefinedType, s=f5 +ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0 +ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0 +ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with Test.ToS +ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with A with Test.ToS +TypeTag[List[Object{type T1}#T1]], t=TypeRef, s=class List +ConcreteTypeTag[List[Seq[Int]]], t=TypeRef, s=class List +ConcreteTypeTag[List[Seq[U forSome { type U <: Int }]]], t=TypeRef, s=class List +ConcreteTypeTag[Bar.type], t=AbstractTypeRef, s= <: scala.runtime.AbstractFunction0[Bar] with Serializable{case def unapply(x$0: Bar): Boolean} with Singleton +ConcreteTypeTag[Bar], t=AbstractTypeRef, s= <: Test.ToS with Product with Serializable{def copy(): Bar} +ConcreteTypeTag[Test.ToS], t=RefinedType, s=g3 +ConcreteTypeTag[Test.ToS], t=RefinedType, s=g4 +ConcreteTypeTag[Test.ToS], t=RefinedType, s=g5 +ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0 +ConcreteTypeTag[() => Test.ToS], t=TypeRef, s=class Function0 +ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with Test.ToS +ConcreteTypeTag[$anon], t=AbstractTypeRef, s= <: B with A with Test.ToS +TypeTag[List[Object{type T1}#T1]], t=TypeRef, s=class List +ConcreteTypeTag[List[Seq[Int]]], t=TypeRef, s=class List +ConcreteTypeTag[List[Seq[U forSome { type U <: Int }]]], t=TypeRef, s=class List diff --git a/test/files/run/existentials3.scala b/test/files/run/existentials3-new.scala index d6d5612687..32129a04c6 100644 --- a/test/files/run/existentials3.scala +++ b/test/files/run/existentials3-new.scala @@ -38,8 +38,7 @@ object Test { def m[T: ConcreteTypeTag](x: T) = printTag(concreteTypeTag[T]) def m2[T: TypeTag](x: T) = printTag(typeTag[T]) - // manifests don't work for f10/g10 - // oh, they do now :) + // tags do work for f10/g10 def main(args: Array[String]): Unit = { m(f1) m(f2) diff --git a/test/files/run/getClassTest.check b/test/files/run/getClassTest-new.check index 94e86c3889..94e86c3889 100644 --- a/test/files/run/getClassTest.check +++ b/test/files/run/getClassTest-new.check diff --git a/test/files/run/getClassTest.scala b/test/files/run/getClassTest-new.scala index 2485cd2c71..89778ca2d3 100644 --- a/test/files/run/getClassTest.scala +++ b/test/files/run/getClassTest-new.scala @@ -4,7 +4,7 @@ class AnyVals { def f3 = 5.getClass def f4 = (5: java.lang.Integer).getClass def f5 = (5.asInstanceOf[AnyRef]).getClass - + // scalap says: // // def f1 : java.lang.Class[?0] forSome {type ?0} = { /* compiled code */ } @@ -19,18 +19,18 @@ class AnyVals { // f2: java.lang.Class<?> // f3: java.lang.Class<java.lang.Object> // f4: java.lang.Class<? extends java.lang.Integer> - // f5: java.lang.Class<?> + // f5: java.lang.Class<?> } class AnyRefs { class A class B extends A - + def f1 = (new B: Any).getClass().newInstance() def f2 = (new B: AnyRef).getClass().newInstance() def f3 = (new B: A).getClass().newInstance() def f4 = (new B: B).getClass().newInstance() - + def f0[T >: B] = (new B: T).getClass().newInstance() def f5 = f0[Any] @@ -51,8 +51,8 @@ class MoreAnyRefs { } object Test { - def returnTypes[T: Manifest] = ( - manifest[T].erasure.getMethods.toList + def returnTypes[T: ClassTag] = ( + classTag[T].erasure.getMethods.toList filter (_.getName startsWith "f") sortBy (_.getName) map (m => m.getName + ": " + m.getGenericReturnType.toString) diff --git a/test/files/run/manifests.scala b/test/files/run/manifests-new.scala index 2d64bf18a9..4485ce9124 100644 --- a/test/files/run/manifests.scala +++ b/test/files/run/manifests-new.scala @@ -11,7 +11,7 @@ object Test import SubtypeRelationship.{ NONE, SAME, SUB, SUPER } class VarianceTester[T, U, CC[_]](expected: Variances.Value)( - implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) { + implicit ev1: TypeTag[T], ev2: TypeTag[U], ev3: TypeTag[CC[T]], ev4: TypeTag[CC[U]]) { def elements = List(ev1.tpe <:< ev2.tpe, ev2.tpe <:< ev1.tpe) def containers = List(ev3.tpe <:< ev4.tpe, ev4.tpe <:< ev3.tpe) @@ -37,42 +37,40 @@ object Test } } - def showsCovariance[T, U, CC[_]](implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) = + def showsCovariance[T, U, CC[_]](implicit ev1: TypeTag[T], ev2: TypeTag[U], ev3: TypeTag[CC[T]], ev4: TypeTag[CC[U]]) = new VarianceTester[T, U, CC](CO) showsExpectedVariance - def showsInvariance[T, U, CC[_]](implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) = + def showsInvariance[T, U, CC[_]](implicit ev1: TypeTag[T], ev2: TypeTag[U], ev3: TypeTag[CC[T]], ev4: TypeTag[CC[U]]) = new VarianceTester[T, U, CC](IN) showsExpectedVariance - def showsContravariance[T, U, CC[_]](implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) = + def showsContravariance[T, U, CC[_]](implicit ev1: TypeTag[T], ev2: TypeTag[U], ev3: TypeTag[CC[T]], ev4: TypeTag[CC[U]]) = new VarianceTester[T, U, CC](CONTRA) showsExpectedVariance - def typeCompare[T, U](implicit ev1: Manifest[T], ev2: Manifest[U]) = { - (ev1.tpe <:< ev2.tpe, ev2.tpe <:< ev1.tpe) match { - case (true, true) => SAME - case (true, false) => SUB - case (false, true) => SUPER - case (false, false) => NONE - } + def typeCompare[T, U](implicit ev1: TypeTag[T], ev2: TypeTag[U]) = (ev1.tpe <:< ev2.tpe, ev2.tpe <:< ev1.tpe) match { + case (true, true) => SAME + case (true, false) => SUB + case (false, true) => SUPER + case (false, false) => NONE } - def assertAnyRef[T: Manifest] = List( - manifest[T].tpe <:< manifest[Any].tpe, - manifest[T].tpe <:< manifest[AnyRef].tpe, - !(manifest[T].tpe <:< manifest[AnyVal].tpe) + def assertAnyRef[T: TypeTag] = List( + typeTag[T].tpe <:< typeTag[Any].tpe, + typeTag[T].tpe <:< typeTag[AnyRef].tpe, + !(typeTag[T].tpe <:< typeTag[AnyVal].tpe) ) foreach (assert(_, "assertAnyRef")) - def assertAnyVal[T: Manifest] = List( - manifest[T].tpe <:< manifest[Any].tpe, - !(manifest[T].tpe <:< manifest[AnyRef].tpe), - manifest[T].tpe <:< manifest[AnyVal].tpe + def assertAnyVal[T: TypeTag] = List( + typeTag[T].tpe <:< typeTag[Any].tpe, + !(typeTag[T].tpe <:< typeTag[AnyRef].tpe), + typeTag[T].tpe <:< typeTag[AnyVal].tpe ) foreach (assert(_, "assertAnyVal")) - def assertSameType[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == SAME, "assertSameType") - def assertSuperType[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == SUPER, "assertSuperType") - def assertSubType[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == SUB, "assertSubType") - def assertNoRelationship[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == NONE, "assertNoRelationship") + def assertSameType[T: TypeTag, U: TypeTag] = assert(typeCompare[T, U] == SAME, "assertSameType") + def assertSuperType[T: TypeTag, U: TypeTag] = assert(typeCompare[T, U] == SUPER, "assertSuperType") + def assertSubType[T: TypeTag, U: TypeTag] = assert(typeCompare[T, U] == SUB, "assertSubType") + def assertNoRelationship[T: TypeTag, U: TypeTag] = assert(typeCompare[T, U] == NONE, "assertNoRelationship") - def testVariancesVia[T: Manifest, U: Manifest] = assert( + def testVariancesVia[T: TypeTag, U: TypeTag] = assert( typeCompare[T, U] == SUB && showsCovariance[T, U, List] && showsInvariance[T, U, Set], diff --git a/test/files/run/patmat_unapp_abstype.check b/test/files/run/patmat_unapp_abstype-new.check index 72239d16cd..72239d16cd 100644 --- a/test/files/run/patmat_unapp_abstype.check +++ b/test/files/run/patmat_unapp_abstype-new.check diff --git a/test/files/run/patmat_unapp_abstype.flags b/test/files/run/patmat_unapp_abstype-new.flags index ba80cad69b..ba80cad69b 100644 --- a/test/files/run/patmat_unapp_abstype.flags +++ b/test/files/run/patmat_unapp_abstype-new.flags diff --git a/test/files/run/patmat_unapp_abstype.scala b/test/files/run/patmat_unapp_abstype-new.scala index 45496f08a2..45496f08a2 100644 --- a/test/files/run/patmat_unapp_abstype.scala +++ b/test/files/run/patmat_unapp_abstype-new.scala diff --git a/test/files/run/primitive-sigs-2.check b/test/files/run/primitive-sigs-2-new.check index 1b6e24ed20..b82ddbeaff 100644 --- a/test/files/run/primitive-sigs-2.check +++ b/test/files/run/primitive-sigs-2-new.check @@ -1,7 +1,7 @@ T<java.lang.Object>
List(A, char, class java.lang.Object)
a
-public <T> java.lang.Object Arr.arr4(java.lang.Object[],scala.reflect.api.TypeTags.scala.reflect.api.TypeTags$ConcreteTypeTag<T>)
+public <T> java.lang.Object Arr.arr4(java.lang.Object[],scala.reflect.ArrayTag<T>)
public float[] Arr.arr3(float[][])
public scala.collection.immutable.List<java.lang.Character> Arr.arr2(java.lang.Character[])
public scala.collection.immutable.List<java.lang.Object> Arr.arr1(int[])
diff --git a/test/files/run/primitive-sigs-2.scala b/test/files/run/primitive-sigs-2-new.scala index b7152f7e3d..7e13014cb2 100644 --- a/test/files/run/primitive-sigs-2.scala +++ b/test/files/run/primitive-sigs-2-new.scala @@ -10,22 +10,14 @@ class Arr { def arr1(xs: Array[Int]): List[Int] = xs.toList def arr2(xs: Array[jl.Character]): List[jl.Character] = xs.toList def arr3(xss: Array[Array[Float]]): Array[Float] = xss map (_.sum) - // This gets a signature like - // public <T> java.lang.Object Arr.arr4(java.lang.Object[],scala.reflect.Manifest<T>) - // - // instead of the more appealing version from the past - // public <T> T[] Arr.arr4(T[][],scala.reflect.Manifest<T>) - // - // because java inflict's its reference-only generic-arrays on us. - // - def arr4[T: Manifest](xss: Array[Array[T]]): Array[T] = xss map (_.head) + def arr4[T: ArrayTag](xss: Array[Array[T]]): Array[T] = xss map (_.head) } object Test { val c1: Class[_] = classOf[T[_]] val c2: Class[_] = classOf[C] val c3: Class[_] = classOf[Arr] - + val c1m = c1.getMethods.toList filter (_.getName == "f") map (_.getGenericReturnType.toString) val c2m = c2.getMethods.toList filter (_.getName == "f") map (_.getGenericReturnType.toString) val c3m = c3.getDeclaredMethods.toList map (_.toGenericString) diff --git a/test/files/run/reflection-implClass.scala b/test/files/run/reflection-implClass-new.scala index 7718b52f33..27374f2106 100644 --- a/test/files/run/reflection-implClass.scala +++ b/test/files/run/reflection-implClass-new.scala @@ -1,5 +1,5 @@ -/** - * Tries to load a symbol for the `Foo$class` using Scala reflection. +/** + * Tries to load a symbol for the `Foo$class` using Scala reflection. * Since trait implementation classes do not get pickling information * symbol for them should be created using fallback mechanism * that exposes Java reflection information dressed up in @@ -8,15 +8,15 @@ object Test extends App with Outer { import scala.reflect.mirror - assert(mirror.classToSymbol(manifest[Foo].erasure).typeSignature.declaration(mirror.newTermName("bar")).typeSignature == - mirror.classToSymbol(manifest[Bar].erasure).typeSignature.declaration(mirror.newTermName("foo")).typeSignature) + assert(mirror.classToSymbol(classTag[Foo].erasure).typeSignature.declaration(mirror.newTermName("bar")).typeSignature == + mirror.classToSymbol(classTag[Bar].erasure).typeSignature.declaration(mirror.newTermName("foo")).typeSignature) - val s1 = implClass(manifest[Foo].erasure) + val s1 = implClass(classTag[Foo].erasure) assert(s1 != mirror.NoSymbol) assert(s1.typeSignature != mirror.NoType) assert(s1.companionSymbol.typeSignature != mirror.NoType) assert(s1.companionSymbol.typeSignature.declaration(mirror.newTermName("bar")) != mirror.NoSymbol) - val s2 = implClass(manifest[Bar].erasure) + val s2 = implClass(classTag[Bar].erasure) assert(s2 != mirror.NoSymbol) assert(s2.typeSignature != mirror.NoType) assert(s2.companionSymbol.typeSignature != mirror.NoType) diff --git a/test/files/run/reify_implicits.check b/test/files/run/reify_implicits-new.check index e3aeb20f6b..e3aeb20f6b 100644 --- a/test/files/run/reify_implicits.check +++ b/test/files/run/reify_implicits-new.check diff --git a/test/files/run/reify_implicits.scala b/test/files/run/reify_implicits-new.scala index 60971c3cfb..69198391d1 100644 --- a/test/files/run/reify_implicits.scala +++ b/test/files/run/reify_implicits-new.scala @@ -2,7 +2,7 @@ import scala.reflect.mirror._ object Test extends App { reify { - implicit def arrayWrapper[A : ClassManifest](x: Array[A]) = + implicit def arrayWrapper[A : ArrayTag](x: Array[A]) = new { def sort(p: (A, A) => Boolean) = { util.Sorting.stableSort(x, p); x diff --git a/test/files/run/repl-power.check b/test/files/run/repl-power.check index 1e7b6f0cd8..c509434116 100644 --- a/test/files/run/repl-power.check +++ b/test/files/run/repl-power.check @@ -1,32 +1,32 @@ -Type in expressions to have them evaluated. -Type :help for more information. - -scala> :power -** Power User mode enabled - BEEP WHIR GYVE ** -** :phase has been set to 'typer'. ** -** scala.tools.nsc._ has been imported ** -** global._, definitions._ also imported ** -** Try :help, :vals, power.<tab> ** - -scala> // guarding against "error: reference to global is ambiguous" - -scala> global.emptyValDef // "it is imported twice in the same scope by ..." -res0: $r.global.emptyValDef.type = private val _ = _ - -scala> val tp = ArrayClass[scala.util.Random] // magic with manifests -tp: $r.global.Type = Array[scala.util.Random] - -scala> tp.memberType(Array_apply) // evidence -res1: $r.global.Type = (i: Int)scala.util.Random - -scala> val m = LIT(10) MATCH (CASE(LIT(5)) ==> FALSE, DEFAULT ==> TRUE) // treedsl -m: $r.treedsl.global.Match = -10 match { - case 5 => false - case _ => true -} - -scala> typed(m).tpe // typed is in scope -res2: $r.treedsl.global.Type = Boolean - -scala> +Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala> :power
+** Power User mode enabled - BEEP WHIR GYVE **
+** :phase has been set to 'typer'. **
+** scala.tools.nsc._ has been imported **
+** global._, definitions._ also imported **
+** Try :help, :vals, power.<tab> **
+
+scala> // guarding against "error: reference to global is ambiguous"
+
+scala> global.emptyValDef // "it is imported twice in the same scope by ..."
+res0: $r.global.emptyValDef.type = private val _ = _
+
+scala> val tp = ArrayClass[scala.util.Random] // magic with tags
+tp: $r.global.Type = Array[scala.util.Random]
+
+scala> tp.memberType(Array_apply) // evidence
+res1: $r.global.Type = (i: Int)scala.util.Random
+
+scala> val m = LIT(10) MATCH (CASE(LIT(5)) ==> FALSE, DEFAULT ==> TRUE) // treedsl
+m: $r.treedsl.global.Match =
+10 match {
+ case 5 => false
+ case _ => true
+}
+
+scala> typed(m).tpe // typed is in scope
+res2: $r.treedsl.global.Type = Boolean
+
+scala>
diff --git a/test/files/run/repl-power.scala b/test/files/run/repl-power.scala index 27da3df106..f7c88c63ff 100644 --- a/test/files/run/repl-power.scala +++ b/test/files/run/repl-power.scala @@ -5,10 +5,9 @@ object Test extends ReplTest { :power // guarding against "error: reference to global is ambiguous" global.emptyValDef // "it is imported twice in the same scope by ..." -val tp = ArrayClass[scala.util.Random] // magic with manifests +val tp = ArrayClass[scala.util.Random] // magic with tags tp.memberType(Array_apply) // evidence val m = LIT(10) MATCH (CASE(LIT(5)) ==> FALSE, DEFAULT ==> TRUE) // treedsl typed(m).tpe // typed is in scope """.trim } - diff --git a/test/files/run/t0421.check b/test/files/run/t0421-new.check index cdcf042f19..cdcf042f19 100644 --- a/test/files/run/t0421.check +++ b/test/files/run/t0421-new.check diff --git a/test/files/run/t0421.scala b/test/files/run/t0421-new.scala index 8d51013924..7de6b7f2c4 100644 --- a/test/files/run/t0421.scala +++ b/test/files/run/t0421-new.scala @@ -1,23 +1,23 @@ // ticket #421 object Test extends App { - def transpose[A: ClassManifest](xss: Array[Array[A]]) = { + def transpose[A: ArrayTag](xss: Array[Array[A]]) = { for (i <- Array.range(0, xss(0).length)) yield for (xs <- xss) yield xs(i) } def scalprod(xs: Array[Double], ys: Array[Double]) = { - var acc = 0.0 - for ((x, y) <- xs zip ys) acc = acc + x * y + var acc = 0.0 + for ((x, y) <- xs zip ys) acc = acc + x * y acc } def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { - val ysst = transpose(yss) + val ysst = transpose(yss) val ysst1: Array[Array[Double]] = yss.transpose assert(ysst.deep == ysst1.deep) for (xs <- xss) yield - for (yst <- ysst) yield + for (yst <- ysst) yield scalprod(xs, yst) } @@ -25,6 +25,6 @@ object Test extends App { println(transpose(a1).deep.mkString("[", ",", "]")) println(matmul(Array(Array(2, 3)), Array(Array(5), Array(7))).deep.mkString("[", ",", "]")) - + println(matmul(Array(Array(4)), Array(Array(6, 8))).deep.mkString("[", ",", "]")) } diff --git a/test/files/run/t0677.scala b/test/files/run/t0677-new.scala index 6c8a3a7e99..bf7a3971dc 100644 --- a/test/files/run/t0677.scala +++ b/test/files/run/t0677-new.scala @@ -1,5 +1,5 @@ object Test extends App { - class X[T: ClassManifest] { + class X[T: ArrayTag] { val a = Array.ofDim[T](3, 4) } val x = new X[String] diff --git a/test/files/run/t1195.check b/test/files/run/t1195-new.check index 554e3fd03d..554e3fd03d 100644 --- a/test/files/run/t1195.check +++ b/test/files/run/t1195-new.check diff --git a/test/files/run/t1195.scala b/test/files/run/t1195-new.scala index 93b1dcbd07..6f28a4a167 100644 --- a/test/files/run/t1195.scala +++ b/test/files/run/t1195-new.scala @@ -7,7 +7,7 @@ object Test { val g1 = g() val h1 = h() - def m[T: Manifest](x: T) = println(manifest[T] + ", underlying = " + manifest[T].sym.typeSignature) + def m[T: TypeTag](x: T) = println(typeTag[T] + ", underlying = " + typeTag[T].sym.typeSignature) def main(args: Array[String]): Unit = { m(f) diff --git a/test/files/run/t2236.scala b/test/files/run/t2236-new.scala index 64ed18c805..bbabe8e7d9 100755..100644 --- a/test/files/run/t2236.scala +++ b/test/files/run/t2236-new.scala @@ -1,4 +1,4 @@ -class T[A](implicit val m:Manifest[A]) +class T[A](implicit val m:TypeTag[A]) class Foo class Bar extends T[Foo] object Test extends App { diff --git a/test/files/run/t2386-new.check b/test/files/run/t2386-new.check new file mode 100644 index 0000000000..98e226f946 --- /dev/null +++ b/test/files/run/t2386-new.check @@ -0,0 +1,2 @@ +a(0) = Array(1, 2)
+a(1) = Array("a", "b")
diff --git a/test/files/run/t2386-new.scala b/test/files/run/t2386-new.scala new file mode 100644 index 0000000000..15d1859759 --- /dev/null +++ b/test/files/run/t2386-new.scala @@ -0,0 +1,5 @@ +object Test extends App { + val a = Array(Array(1, 2), Array("a","b")) + println("a(0) = Array(" + (a(0) mkString ", ") + ")") + println("a(1) = Array(" + (a(1) map (s => "\"" + s + "\"") mkString ", ") + ")") +} diff --git a/test/files/run/t3507.check b/test/files/run/t3507-new.check index 6e4fa4170e..6e4fa4170e 100644 --- a/test/files/run/t3507.check +++ b/test/files/run/t3507-new.check diff --git a/test/files/run/t3507.scala b/test/files/run/t3507-new.scala index 3cdd40a881..c7a529e8b8 100644 --- a/test/files/run/t3507.scala +++ b/test/files/run/t3507-new.scala @@ -9,7 +9,7 @@ object Test extends App { var a: A = new A // mutable val c /*: object _1.b.c forSome { val _1: A } */ = a.m // widening using existential - def mani[T: Manifest](x: T) = println(manifest[T]) + def mani[T: TypeTag](x: T) = println(typeTag[T]) mani/*[object _1.b.c]*/(c) // kaboom in manifestOfType / TreeGen.mkAttributedQualifier // --> _1 is not in scope here }
\ No newline at end of file diff --git a/test/files/run/t3758.check b/test/files/run/t3758.check deleted file mode 100644 index 9c6ab655a3..0000000000 --- a/test/files/run/t3758.check +++ /dev/null @@ -1,6 +0,0 @@ -List(String)
-List(Int)
-List(Float)
-List(String)
-List(Int)
-List(Float)
diff --git a/test/files/run/t3758.scala b/test/files/run/t3758.scala deleted file mode 100644 index 10bfb5724b..0000000000 --- a/test/files/run/t3758.scala +++ /dev/null @@ -1,10 +0,0 @@ -object Test { - def main(args: Array[String]): Unit = { - println(classManifest[Array[String]].tpe.typeArguments) - println(classManifest[Array[Int]].tpe.typeArguments) - println(classManifest[Array[Float]].tpe.typeArguments) - println(manifest[Array[String]].tpe.typeArguments) - println(manifest[Array[Int]].tpe.typeArguments) - println(manifest[Array[Float]].tpe.typeArguments) - } -} diff --git a/test/files/run/t4110.check b/test/files/run/t4110-new.check index 28f220e1fe..28f220e1fe 100644 --- a/test/files/run/t4110.check +++ b/test/files/run/t4110-new.check diff --git a/test/files/run/t4110.scala b/test/files/run/t4110-new.scala index 4bd377b73e..3285b82c61 100644 --- a/test/files/run/t4110.scala +++ b/test/files/run/t4110-new.scala @@ -1,9 +1,9 @@ object Test extends App { - def inferredType[T : Manifest](v : T) = println(manifest[T]) + def inferredType[T : TypeTag](v : T) = println(typeTag[T]) trait A trait B - + inferredType(new A with B) val name = new A with B diff --git a/test/files/scalacheck/array.scala b/test/files/scalacheck/array-new.scala index f262bc6320..18d577ca6d 100644 --- a/test/files/scalacheck/array.scala +++ b/test/files/scalacheck/array-new.scala @@ -9,9 +9,9 @@ import scala.collection.mutable.ArraySeq object Test extends Properties("Array") { /** At this moment the authentic scalacheck Array Builder/Arb bits are commented out. */ - implicit def arbArray[T](implicit a: Arbitrary[T], m: Manifest[T]): Arbitrary[Array[T]] = + implicit def arbArray[T](implicit a: Arbitrary[T], m: ArrayTag[T]): Arbitrary[Array[T]] = Arbitrary(containerOf[List,T](arbitrary[T]) map (_.toArray)) - + val arrGen: Gen[Array[_]] = oneOf( arbitrary[Array[Int]], arbitrary[Array[Array[Int]]], @@ -20,7 +20,7 @@ object Test extends Properties("Array") { arbitrary[Array[Boolean]], arbitrary[Array[AnyVal]] ) - + // inspired by #1857 and #2352 property("eq/ne") = forAll(arrGen, arrGen) { (c1, c2) => (c1 eq c2) || (c1 ne c2) @@ -32,6 +32,5 @@ object Test extends Properties("Array") { val arr = Array.ofDim[String](i1, i2, i3) val flattened = arr flatMap (x => x) flatMap (x => x) flattened.length == i1 * i2 * i3 - } + } } - diff --git a/test/files/specialized/spec-matrix.check b/test/files/specialized/spec-matrix-new.check index 5ec3e84597..5ec3e84597 100644 --- a/test/files/specialized/spec-matrix.check +++ b/test/files/specialized/spec-matrix-new.check diff --git a/test/files/specialized/spec-matrix.scala b/test/files/specialized/spec-matrix-new.scala index 98735c8c03..65b46e8d48 100644 --- a/test/files/specialized/spec-matrix.scala +++ b/test/files/specialized/spec-matrix-new.scala @@ -1,9 +1,9 @@ /** Test matrix multiplication with specialization. */ -class Matrix[@specialized A: ClassManifest](val rows: Int, val cols: Int) { +class Matrix[@specialized A: ArrayTag](val rows: Int, val cols: Int) { private val arr: Array[Array[A]] = Array.ofDim[A](rows, cols) - + def apply(i: Int, j: Int): A = { if (i < 0 || i >= rows || j < 0 || j >= cols) throw new NoSuchElementException("Indexes out of bounds: " + (i, j)) @@ -29,7 +29,7 @@ object Test { def main(args: Array[String]) { val m = randomMatrix(200, 100) val n = randomMatrix(100, 200) - + val p = mult(m, n) println(p(0, 0)) println("Boxed doubles: " + runtime.BoxesRunTime.doubleBoxCount) @@ -38,7 +38,7 @@ object Test { def randomMatrix(n: Int, m: Int) = { val r = new util.Random(10) - val x = new Matrix[Double](n, m) + val x = new Matrix[Double](n, m) for (i <- 0 until n; j <- 0 until m) x(i, j) = (r.nextInt % 1000).toDouble x @@ -46,17 +46,17 @@ object Test { def printMatrix[Double](m: Matrix[Double]) { for (i <- 0 until m.rows) { - for (j <- 0 until m.cols) + for (j <- 0 until m.cols) print("%5.3f ".format(m(i, j))) println } } - def multManifest[@specialized(Int) T](m: Matrix[T], n: Matrix[T])(implicit cm: ClassManifest[T], num: Numeric[T]) { + def multTag[@specialized(Int) T](m: Matrix[T], n: Matrix[T])(implicit at: ArrayTag[T], num: Numeric[T]) { val p = new Matrix[T](m.rows, n.cols) import num._ - for (i <- 0 until m.rows) + for (i <- 0 until m.rows) for (j <- 0 until n.cols) { var sum = num.zero for (k <- 0 until n.rows) @@ -68,7 +68,7 @@ object Test { def mult(m: Matrix[Double], n: Matrix[Double]) = { val p = new Matrix[Double](m.rows, n.cols) - for (i <- 0 until m.rows) + for (i <- 0 until m.rows) for (j <- 0 until n.cols) { var sum = 0.0 for (k <- 0 until n.rows) diff --git a/test/pending/pos/inference.scala b/test/pending/pos/inference.scala index d28d003435..3672351fca 100644 --- a/test/pending/pos/inference.scala +++ b/test/pending/pos/inference.scala @@ -1,15 +1,15 @@ // inference illuminator object Test { - class D1[T1 : Manifest, T2 <: T1 : Manifest](x: T1) { println(manifest[(T1, T2)]) } - class D2[T1 : Manifest, T2 >: T1 : Manifest](x: T1) { println(manifest[(T1, T2)]) } - class D3[+T1 : Manifest, T2 <: T1 : Manifest](x: T1) { println(manifest[(T1, T2)]) } - class D4[-T1 : Manifest, T2 >: T1 : Manifest](x: T1) { println(manifest[(T1, T2)]) } - - class E1[T1 : Manifest, T2 <: T1 : Manifest](x: D1[T1, T2]) { println(manifest[(T1, T2)]) } - class E2[T1 : Manifest, T2 >: T1 : Manifest](x: D2[T1, T2]) { println(manifest[(T1, T2)]) } - class E3[+T1 : Manifest, T2 <: T1 : Manifest](x: D3[T1, T2]) { println(manifest[(T1, T2)]) } - class E4[-T1 : Manifest, T2 >: T1 : Manifest](x: D4[T1, T2]) { println(manifest[(T1, T2)]) } - + class D1[T1 : TypeTag, T2 <: T1 : TypeTag](x: T1) { println(typeTag[(T1, T2)]) } + class D2[T1 : TypeTag, T2 >: T1 : TypeTag](x: T1) { println(typeTag[(T1, T2)]) } + class D3[+T1 : TypeTag, T2 <: T1 : TypeTag](x: T1) { println(typeTag[(T1, T2)]) } + class D4[-T1 : TypeTag, T2 >: T1 : TypeTag](x: T1) { println(typeTag[(T1, T2)]) } + + class E1[T1 : TypeTag, T2 <: T1 : TypeTag](x: D1[T1, T2]) { println(typeTag[(T1, T2)]) } + class E2[T1 : TypeTag, T2 >: T1 : TypeTag](x: D2[T1, T2]) { println(typeTag[(T1, T2)]) } + class E3[+T1 : TypeTag, T2 <: T1 : TypeTag](x: D3[T1, T2]) { println(typeTag[(T1, T2)]) } + class E4[-T1 : TypeTag, T2 >: T1 : TypeTag](x: D4[T1, T2]) { println(typeTag[(T1, T2)]) } + def main(args: Array[String]): Unit = { // WHY YOU NO LIKE NOTHING SO MUCH SCALAC? val d1 = new D1(5) diff --git a/test/pending/shootout/meteor.scala b/test/pending/shootout/meteor.scala index 2fd702753a..154695533b 100644 --- a/test/pending/shootout/meteor.scala +++ b/test/pending/shootout/meteor.scala @@ -19,7 +19,7 @@ object meteor { -// Solver.scala +// Solver.scala // import scala.collection.mutable._ final class Solver (n: Int) { @@ -29,8 +29,8 @@ final class Solver (n: Int) { private val board = new Board() - val pieces = Array( - new Piece(0), new Piece(1), new Piece(2), new Piece(3), new Piece(4), + val pieces = Array( + new Piece(0), new Piece(1), new Piece(2), new Piece(3), new Piece(4), new Piece(5), new Piece(6), new Piece(7), new Piece(8), new Piece(9) ) val unplaced = new BitSet(pieces.length) @@ -71,8 +71,8 @@ final class Solver (n: Int) { private def puzzleSolved() = { val b = board.asString - if (first == null){ - first = b; last = b + if (first == null){ + first = b; last = b } else { if (b < first){ first = b } else { if (b > last){ last = b } } } @@ -81,7 +81,7 @@ final class Solver (n: Int) { private def shouldPrune() = { board.unmark - !board.cells.forall(c => c.contiguousEmptyCells % Piece.size == 0) + !board.cells.forall(c => c.contiguousEmptyCells % Piece.size == 0) } @@ -108,8 +108,8 @@ final class Solver (n: Int) { } /* - def printPieces() = - for (i <- Iterator.range(0,Board.pieces)) pieces(i).print + def printPieces() = + for (i <- Iterator.range(0,Board.pieces)) pieces(i).print */ } @@ -126,7 +126,7 @@ object Board { val size = rows * cols } -final class Board { +final class Board { val cells = boardCells() val cellsPieceWillFill = new Array[BoardCell](Piece.size) @@ -134,9 +134,9 @@ final class Board { def unmark() = for (c <- cells) c.unmark - def asString() = - new String( cells map( - c => if (c.piece == null) '-'.toByte + def asString() = + new String( cells map( + c => if (c.piece == null) '-'.toByte else (c.piece.number + 48).toByte )) def firstEmptyCellIndex() = cells.findIndexOf(c => c.isEmpty) @@ -144,13 +144,13 @@ final class Board { def add(pieceIndex: Int, boardIndex: Int, p: Piece) = { cellCount = 0 p.unmark - + find( p.cells(pieceIndex), cells(boardIndex)) - val boardHasSpace = cellCount == Piece.size && - cellsPieceWillFill.forall(c => c.isEmpty) + val boardHasSpace = cellCount == Piece.size && + cellsPieceWillFill.forall(c => c.isEmpty) - if (boardHasSpace) cellsPieceWillFill.foreach(c => c.piece = p) + if (boardHasSpace) cellsPieceWillFill.foreach(c => c.piece = p) boardHasSpace } @@ -180,10 +180,10 @@ final class Board { if (row % 2 == 1) { if (!isLast) c.next(Cell.NE) = a(i-(Board.cols-1)) - c.next(Cell.NW) = a(i-Board.cols) + c.next(Cell.NW) = a(i-Board.cols) if (row != m) { if (!isLast) c.next(Cell.SE) = a(i+(Board.cols+1)) - c.next(Cell.SW) = a(i+Board.cols) + c.next(Cell.SW) = a(i+Board.cols) } } else { if (row != 0) { @@ -212,9 +212,9 @@ final class Board { Console.print(i + "\t") for (j <- Iterator.range(0,Cell.sides)){ val c = cells(i).next(j) - if (c == null) - Console.print("-- ") - else + if (c == null) + Console.print("-- ") + else Console.printf("{0,number,00} ")(c.number) } Console.println("") @@ -241,7 +241,7 @@ final class Piece(_number: Int) { val number = _number val cells = for (i <- Array.range(0,Piece.size)) yield new PieceCell() - { + { number match { case 0 => make0 case 1 => make1 @@ -252,7 +252,7 @@ final class Piece(_number: Int) { case 6 => make6 case 7 => make7 case 8 => make8 - case 9 => make9 + case 9 => make9 } } @@ -395,12 +395,12 @@ final class Piece(_number: Int) { Console.print(i + "\t") for (j <- Iterator.range(0,Cell.sides)){ val c = cells(i).next(j) - if (c == null) - Console.print("-- ") - else + if (c == null) + Console.print("-- ") + else for (k <- Iterator.range(0,Piece.size)){ if (cells(k) == c) Console.printf(" {0,number,0} ")(k) - } + } } Console.println("") } @@ -418,13 +418,13 @@ final class Piece(_number: Int) { object Cell { val NW = 0; val NE = 1 val W = 2; val E = 3 - val SW = 4; val SE = 5 + val SW = 4; val SE = 5 val sides = 6 } abstract class Cell { - implicit def m: Manifest[T] + implicit def t: ClassTag[T] type T val next = new Array[T](Cell.sides) var marked = false @@ -437,7 +437,7 @@ abstract class Cell { final class BoardCell(_number: Int) extends { type T = BoardCell - implicit val m = manifest[BoardCell] + implicit val t = classTag[BoardCell] } with Cell { val number = _number var piece: Piece = _ @@ -448,10 +448,10 @@ final class BoardCell(_number: Int) extends { def contiguousEmptyCells(): Int = { if (!marked && isEmpty){ mark - var count = 1 + var count = 1 for (neighbour <- next) - if (neighbour != null && neighbour.isEmpty) + if (neighbour != null && neighbour.isEmpty) count = count + neighbour.contiguousEmptyCells count } else { 0 } diff --git a/test/scaladoc/resources/implicits-base-res.scala b/test/scaladoc/resources/implicits-base-res.scala index 3e3d0f01a6..65d7bdf67c 100644 --- a/test/scaladoc/resources/implicits-base-res.scala +++ b/test/scaladoc/resources/implicits-base-res.scala @@ -137,6 +137,8 @@ class ManifestA[W: Manifest](a: A[W]) { def convToManifestA(x: W): W = sys.error("dunno") } +// [Eugene to Vlad] how do I test typetags here? + /** MyTraversableOps class <br/> * - checks if any abstract members are added - should not happen! */ @@ -144,4 +146,3 @@ trait MyTraversableOps[S] { /** The convToTraversableOps: S documentation... */ def convToTraversableOps(x: S): S } - |