From 3621100820d0541e4863ceed8523b887894069e1 Mon Sep 17 00:00:00 2001 From: Aleksandar Pokopec Date: Mon, 21 Feb 2011 17:14:36 +0000 Subject: Fixed a bug where newly introduced type paramet... Fixed a bug where newly introduced type parameters didn't have all the substitutions done correctly. Fixes #4266. No review. --- .../tools/nsc/transform/SpecializeTypes.scala | 13 ++++++++-- .../scala/tools/nsc/typechecker/Duplicators.scala | 28 +++++++++++++++++++--- 2 files changed, 36 insertions(+), 5 deletions(-) (limited to 'src/compiler') diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index ceeac9d5a5..cfbc387ef6 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -445,10 +445,12 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { */ def produceTypeParameters(syms: List[Symbol], nowner: Symbol, env: TypeEnv) = { val cloned = for (s <- syms) yield if (!env.contains(s)) s.cloneSymbol(nowner) else env(s).typeSymbol + // log("producing type params: " + cloned.map(t => (t, t.tpe.bounds.hi))) for ((orig, cln) <- syms zip cloned) { cln.removeAnnotation(SpecializedClass) if (env.contains(orig)) cln.setInfo(TypeBounds(cln.info.bounds.lo, AnyRefClass.tpe)) } + for (sym <- cloned) sym.setInfo(sym.info.substSym(syms, cloned)) cloned } @@ -506,7 +508,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { val survivedParams = survivingParams(clazz.info.typeParams, env) oldClassTParams = survivedParams newClassTParams = produceTypeParameters(survivedParams, cls, env) map subst(env) - log("new tparams " + newClassTParams.zip(newClassTParams map {_.tpe})) + // log("new tparams " + newClassTParams.zip(newClassTParams map {s => (s.tpe, s.tpe.bounds.hi)}) + ", in env: " + env) def applyContext(tpe: Type) = subst(env, tpe).subst(survivedParams, newClassTParams map (_.tpe)) @@ -1058,6 +1060,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { decl.setInfo(if (decl.isConstructor) tpe match { case MethodType(args, resTpe) => MethodType(args, decl.owner.tpe) } else tpe) + // log((decl, decl.tpe.bounds.hi)) + // decl } /** Type transformation. It is applied to all symbols, compiled or loaded. @@ -1515,7 +1519,12 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { if (settings.debug.value) log("now typing: " + meth + " in " + symbol.owner.fullName) val d = new Duplicator try { - d.retyped(localTyper.context1.asInstanceOf[d.Context], + // log("duplicating tree: " + tree + "; " + symbol.owner) + // log("source: " + source + "; owner: " + source.owner) + // log("source encl class: " + source.enclClass) + // log("symbol encl class: " + symbol.enclClass) + // log(meth) + d.retyped(localTyper.context1.asInstanceOf[d.Context], meth, source.enclClass, symbol.enclClass, diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala index ba827f1421..cb03c61b50 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala @@ -170,6 +170,17 @@ abstract class Duplicators extends Analyzer { typed(ddef) } + private def inspectTpe(tpe: Type) = { + tpe match { + case MethodType(_, res) => + res + ", " + res.bounds.hi + ", " + (res.bounds.hi match { + case TypeRef(_, _, args) if (args.length > 0) => args(0) + ", " + args(0).bounds.hi + case _ => "non-tref: " + res.bounds.hi.getClass + }) + case _ => + } + } + /** Special typer method for re-type checking trees. It expects a typed tree. * Returns a typed tree that has fresh symbols for all definitions in the original tree. * @@ -224,11 +235,13 @@ abstract class Duplicators extends Analyzer { super.typed(vdef, mode, pt) case ldef @ LabelDef(name, params, rhs) => + // log("label def: " + ldef) ldef.tpe = null val params1 = params map { p => Ident(updateSym(p.symbol)) } super.typed(treeCopy.LabelDef(tree, name, params1, rhs), mode, pt) case Bind(name, _) => + // log("bind: " + tree) invalidate(tree) tree.tpe = null super.typed(tree, mode, pt) @@ -240,21 +253,29 @@ abstract class Duplicators extends Analyzer { super.typed(tree, mode, pt) case Select(th @ This(_), sel) if (oldClassOwner ne null) && (th.symbol == oldClassOwner) => - log("selection on this, no type ascription required") + // log("selection on this, no type ascription required") // we use the symbol name instead of the tree name because the symbol may have been // name mangled, rendering the tree name obsolete - super.typed(atPos(tree.pos)(Select(This(newClassOwner), tree.symbol.name)), mode, pt) + // log(tree) + val t = super.typed(atPos(tree.pos)(Select(This(newClassOwner), tree.symbol.name)), mode, pt) + // log("typed to: " + t + "; tpe = " + t.tpe + "; " + inspectTpe(t.tpe)) + t case This(_) if (oldClassOwner ne null) && (tree.symbol == oldClassOwner) => // val tree1 = Typed(This(newClassOwner), TypeTree(fixType(tree.tpe.widen))) + // log("selection on this: " + tree) val tree1 = This(newClassOwner) + // log("tree1: " + tree1) if (settings.debug.value) log("mapped " + tree + " to " + tree1) super.typed(atPos(tree.pos)(tree1), mode, pt) case This(_) => + // log("selection on this, plain: " + tree) tree.symbol = updateSym(tree.symbol) tree.tpe = null - super.typed(tree, mode, pt) + val tree1 = super.typed(tree, mode, pt) + // log("plain this typed to: " + tree1) + tree1 case Super(qual, mix) if (oldClassOwner ne null) && (tree.symbol == oldClassOwner) => val tree1 = Super(qual, mix) @@ -281,6 +302,7 @@ abstract class Duplicators extends Analyzer { tree case _ => + // log("default: " + tree) if (tree.hasSymbol && tree.symbol != NoSymbol && (tree.symbol.owner == definitions.AnyClass)) { tree.symbol = NoSymbol // maybe we can find a more specific member in a subclass of Any (see AnyVal members, like ==) } -- cgit v1.2.3