From 7a740005ace3d8c81825a45bfad18df0f5ce3989 Mon Sep 17 00:00:00 2001 From: paltherr Date: Tue, 28 Oct 2003 13:20:52 +0000 Subject: - Changed rewrite schema => regenerate whole tree --- .../transformer/ExplicitOuterClassesPhase.java | 143 +++++++++++++++++++++ 1 file changed, 143 insertions(+) (limited to 'sources') diff --git a/sources/scalac/transformer/ExplicitOuterClassesPhase.java b/sources/scalac/transformer/ExplicitOuterClassesPhase.java index 62364d3342..466486d07a 100644 --- a/sources/scalac/transformer/ExplicitOuterClassesPhase.java +++ b/sources/scalac/transformer/ExplicitOuterClassesPhase.java @@ -18,6 +18,7 @@ import scalac.PhaseDescriptor; import scalac.Unit; import scalac.ast.Transformer; import scalac.ast.Tree; +import scalac.ast.Tree.Ident; import scalac.ast.Tree.Template; import scalac.symtab.Modifiers; import scalac.symtab.Symbol; @@ -243,6 +244,145 @@ public class ExplicitOuterClassesPhase extends Phase { public Tree transform(Tree tree) { switch (tree) { + case Empty: + return tree; + + case ClassDef(_, _, _, _, _, Template impl): + Symbol clasz = tree.symbol(); + context = new Context(context, clasz, new HashMap()); + Tree[] parents = transform(impl.parents); + Tree[] body = transform(impl.body); + body = Tree.concat(body, genSuperMethods()); + context = context.outer; + if (context != null) clasz.flags |= Modifiers.STATIC; + return gen.ClassDef(clasz, parents, impl.symbol(), body); + + case PackageDef(Tree packaged, Template(_, Tree[] body)): + return gen.PackageDef(packaged.symbol(), transform(body)); + + case ValDef(_, _, _, Tree rhs): + return gen.ValDef(tree.symbol(), transform(rhs)); + + case DefDef(_, _, _, _, _, Tree rhs): + Symbol method = tree.symbol(); + Context backup = context; + if (method.isConstructor()) + context = context.getConstructorContext(method); + rhs = transform(rhs); + context = backup; + return gen.DefDef(method, rhs); + + case AbsTypeDef(_, _, _, _): + case AliasTypeDef(_, _, _, _): + // eliminate // !!! + return Tree.Empty; + + case LabelDef(_, Ident[] params, Tree rhs): + Symbol label = tree.symbol(); + rhs = transform(rhs); + return gen.LabelDef(label, Tree.symbolOf(params), rhs); + + case Block(Tree[] stats): + return gen.Block(tree.pos, transform(stats)); + + case Assign(Tree lhs, Tree rhs): + return gen.Assign(tree.pos, transform(lhs), transform(rhs)); + + case If(Tree cond, Tree thenp, Tree elsep): + cond = transform(cond); + thenp = transform(thenp); + elsep = transform(elsep); + return gen.If(tree.pos, cond, thenp, elsep); + + case Switch(Tree test, int[] tags, Tree[] bodies, Tree otherwise): + test = transform(test); + bodies = transform(bodies); + otherwise = transform(otherwise); + return gen.Switch(tree.pos, test, tags, bodies, otherwise); + + case Return(Tree expr): + return gen.Return(tree.pos, tree.symbol(), expr); + + case New(Template(Tree[] base, Tree[] body)): + assert base.length == 1 && body.length == 0: tree; + return gen.New(tree.pos, transform(base[0])); + + case Typed(Tree expr, Tree tpe): // !!! + return transform(expr); + + case TypeApply(Tree tfun, Tree[] targs): + tfun = transform(tfun); + targs = transform(targs); + return gen.TypeApply(tree.pos, tfun, targs); + + case Apply(Tree vfun, Tree[] vargs): + switch (vfun) { + case TypeApply(Tree tfun, Tree[] targs): + if (!tfun.symbol().isConstructor()) break; + return transform(tree, vargs, vfun, targs, tfun); + default: + if (!vfun.symbol().isConstructor()) break; + return transform(tree, vargs, vfun, Tree.EMPTY_ARRAY,vfun); + } + vfun = transform(vfun); + vargs = transform(vargs); + return gen.Apply(tree.pos, vfun, vargs); + + case This(_): + return genOuterRef(tree.pos, tree.symbol()); + + case Select(Tree qualifier, _): + Symbol symbol = tree.symbol(); + switch (qualifier) { + case Super(_, _): + Symbol clasz = qualifier.symbol(); + if (clasz == context.clasz) { + qualifier = gen.Super(tree.pos, qualifier.symbol()); + } else { + qualifier = genOuterRef(qualifier.pos, clasz); + symbol = getSuperMethod(clasz, symbol); + } + break; + default: + qualifier = transform(qualifier); + break; + } + return gen.Select(tree.pos, qualifier, symbol); + + case Ident(_): + Symbol symbol = tree.symbol(); + Symbol owner = symbol.owner(); + if (owner.isClass()) { + // !!! A this node is missing here. This should + // never happen if all trees were correct. + Tree qualifier = genOuterRef(tree.pos, owner); + return gen.Select(qualifier, symbol); + } + if (owner.isConstructor()) { + Symbol clasz = owner.constructorClass(); + if (clasz != context.clasz) { + Tree qualifier = genOuterRef(tree.pos, clasz); + return gen.Select(qualifier, symbol); + } + } + return gen.Ident(tree.pos, symbol); + + case Literal(Object value): + return gen.mkLit(tree.pos, value); + + case TypeTerm(): + Type type = typeTransformer.apply(tree.type()); + if (context != null) type = context.subst.apply(type); + return gen.TypeTerm(tree.pos, type); + + default: + throw Debug.abort("illegal case", tree); + } + + /* + + switch (tree) { + case ClassDef(_, _, _, _, _, Template impl): Symbol clasz = tree.symbol(); context = new Context(context, clasz, new HashMap()); @@ -302,6 +442,9 @@ public class ExplicitOuterClassesPhase extends Phase { Type type = typeTransformer.apply(tree.type()); if (context != null) type = context.subst.apply(type); return super.transform(tree).setType(type); + + */ + } /* Add outer type and value arguments to constructor calls. */ -- cgit v1.2.3