diff options
Diffstat (limited to 'src/compiler/scala/tools/nsc/typechecker')
4 files changed, 20 insertions, 18 deletions
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) { |