From 5bcdedd615aaa18c44b408db74776949f09e307d Mon Sep 17 00:00:00 2001 From: Matthias Zenger Date: Wed, 2 Jul 2003 12:40:42 +0000 Subject: Added a new apply method to each phase which al... Added a new apply method to each phase which allows to apply only a single compilation unit. For some phases this might probably not work as it is right now. At some stage, these phases have to be adapted accordingly. --- sources/scalac/transformer/LambdaLiftPhase.java | 198 ++++++++++++------------ 1 file changed, 101 insertions(+), 97 deletions(-) (limited to 'sources/scalac/transformer/LambdaLiftPhase.java') diff --git a/sources/scalac/transformer/LambdaLiftPhase.java b/sources/scalac/transformer/LambdaLiftPhase.java index df31745da5..73e26e7986 100644 --- a/sources/scalac/transformer/LambdaLiftPhase.java +++ b/sources/scalac/transformer/LambdaLiftPhase.java @@ -22,8 +22,8 @@ public class LambdaLiftPhase extends PhaseDescriptor implements Kinds, Modifiers public void initialize(Global global, int id) { super.initialize(global, id); - this.global = global; - this.nextPhase = id + 1; + this.global = global; + this.nextPhase = id + 1; } public String name () { @@ -42,88 +42,92 @@ public class LambdaLiftPhase extends PhaseDescriptor implements Kinds, Modifiers new LambdaLift(global, this).apply(); } - public Type transformInfo(Symbol sym, Type tp) { - if (global.debug) - global.log("transform info for " + sym + ":" + tp + sym.locationString()); - Type tp1 = tp; - if (sym != Symbol.NONE) { - switch (tp) { - case MethodType(_, _): - case PolyType(_, _): - tp1 = transform(tp, sym); - break; - default: - if (sym.kind == CLASS) - tp1 = transform(tp, sym); - else - tp1 = transform(tp, sym.owner()); - } + public void apply(Unit unit) { + new LambdaLift(unit.global, this).apply(unit); } - if ((sym.flags & Modifiers.CAPTURED) != 0) return refType(tp1); - else return tp1; + + public Type transformInfo(Symbol sym, Type tp) { + if (global.debug) + global.log("transform info for " + sym + ":" + tp + sym.locationString()); + Type tp1 = tp; + if (sym != Symbol.NONE) { + switch (tp) { + case MethodType(_, _): + case PolyType(_, _): + tp1 = transform(tp, sym); + break; + default: + if (sym.kind == CLASS) + tp1 = transform(tp, sym); + else + tp1 = transform(tp, sym.owner()); + } + } + if ((sym.flags & Modifiers.CAPTURED) != 0) return refType(tp1); + else return tp1; } /** Add proxies as type arguments for propagated type parameters. */ Type transform(Type tp, Symbol owner) { - return transformTypeMap.setOwner(owner).apply(tp); + return transformTypeMap.setOwner(owner).apply(tp); } private class TransformTypeMap extends Type.MapOnlyTypes { - Symbol owner; -// ArrayList/**/ excluded = new ArrayList(); + Symbol owner; +// ArrayList/**/ excluded = new ArrayList(); Type.Map setOwner(Symbol owner) { this.owner = owner; return this; } - public Type apply(Type tp) { - switch (tp) { - case TypeRef(Type pre, Symbol sym, Type[] targs): - switch (pre) { - case ThisType(_): - if (sym.kind == CLASS && sym.constructor().isUpdated(nextPhase)) { - Symbol[] tparams = - sym.constructor().infoAt(nextPhase).typeParams(); - int i = tparams.length; - while (i > 0 && (tparams[i-1].flags & SYNTHETIC) != 0) - i--; - if (i < tparams.length) { - if (global.debug) - global.log("adding proxies for " + sym + ": " + ArrayApply.toString(tparams)); - - Type[] targs1 = new Type[tparams.length]; - System.arraycopy(map(targs), 0, targs1, 0, targs.length); - while (i < tparams.length) { - targs1[i] = proxy(tparams[i], owner).type(); - i++; - } - return Type.TypeRef(pre, sym, targs1); - } - } else if (sym.isLocal()) { - assert targs.length == 0; - return proxy(sym, owner).type(); - } - } - break; + public Type apply(Type tp) { + switch (tp) { + case TypeRef(Type pre, Symbol sym, Type[] targs): + switch (pre) { + case ThisType(_): + if (sym.kind == CLASS && sym.constructor().isUpdated(nextPhase)) { + Symbol[] tparams = + sym.constructor().infoAt(nextPhase).typeParams(); + int i = tparams.length; + while (i > 0 && (tparams[i-1].flags & SYNTHETIC) != 0) + i--; + if (i < tparams.length) { + if (global.debug) + global.log("adding proxies for " + sym + ": " + ArrayApply.toString(tparams)); + + Type[] targs1 = new Type[tparams.length]; + System.arraycopy(map(targs), 0, targs1, 0, targs.length); + while (i < tparams.length) { + targs1[i] = proxy(tparams[i], owner).type(); + i++; + } + return Type.TypeRef(pre, sym, targs1); + } + } else if (sym.isLocal()) { + assert targs.length == 0; + return proxy(sym, owner).type(); + } + } + break; /* - case PolyType(Symbol[] tparams, _): - if (tparams.length != 0) { - int len = excluded.size(); - for (int i = 0; i < tparams.length; i++) - excluded.add(tparams[i]); - Type tp1 = map(tp); - for (int i = 0; i < tparams.length; i++) - excluded.remove(excluded.size() - 1); - return tp1; - } + case PolyType(Symbol[] tparams, _): + if (tparams.length != 0) { + int len = excluded.size(); + for (int i = 0; i < tparams.length; i++) + excluded.add(tparams[i]); + Type tp1 = map(tp); + for (int i = 0; i < tparams.length; i++) + excluded.remove(excluded.size() - 1); + return tp1; + } */ - } - return map(tp); - } - - /** All symbols are mapped to themselves. - */ - public Scope map(Scope s) { return s; } - public Symbol map(Symbol s) { return s; } - public Symbol[] map(Symbol[] ss) { return ss; } + } + return map(tp); + } + + /** All symbols are mapped to themselves. + */ + public Scope map(Scope s) { return s; } + public Symbol map(Symbol s) { return s; } + public Symbol[] map(Symbol[] ss) { return ss; } } private TransformTypeMap transformTypeMap = new TransformTypeMap(); @@ -132,36 +136,36 @@ public class LambdaLiftPhase extends PhaseDescriptor implements Kinds, Modifiers * or `fv' itself if this is the closest definition. */ Symbol proxy(Symbol fv, Symbol owner) { - if (global.debug) - global.log("proxy " + fv + " of " + fv.owner() + " in " + LambdaLift.asFunction(owner)); - Symbol o = owner; - while (o.kind != NONE) { - if (global.debug) - global.log("looking in " + LambdaLift.asFunction(o) + " " + - ArrayApply.toString(o.typeParams())); - Symbol fowner = LambdaLift.asFunction(o); - if (fv.owner() == fowner) return fv; - Type ft = (fowner.isUpdated(nextPhase)) ? fowner.typeAt(nextPhase) - : fowner.type(); - Symbol[] ownerparams = fv.isType() ? ft.typeParams() - : ft.firstParams(); - for (int i = 0; i < ownerparams.length; i++) { - if (ownerparams[i].name == fv.name) - return ownerparams[i]; - } - assert o.owner() != o; - o = o.owner(); - } - return fv; - //throw new ApplicationError("proxy " + fv + " in " + owner); + if (global.debug) + global.log("proxy " + fv + " of " + fv.owner() + " in " + LambdaLift.asFunction(owner)); + Symbol o = owner; + while (o.kind != NONE) { + if (global.debug) + global.log("looking in " + LambdaLift.asFunction(o) + " " + + ArrayApply.toString(o.typeParams())); + Symbol fowner = LambdaLift.asFunction(o); + if (fv.owner() == fowner) return fv; + Type ft = (fowner.isUpdated(nextPhase)) ? fowner.typeAt(nextPhase) + : fowner.type(); + Symbol[] ownerparams = fv.isType() ? ft.typeParams() + : ft.firstParams(); + for (int i = 0; i < ownerparams.length; i++) { + if (ownerparams[i].name == fv.name) + return ownerparams[i]; + } + assert o.owner() != o; + o = o.owner(); + } + return fv; + //throw new ApplicationError("proxy " + fv + " in " + owner); } /** The type scala.Ref[tp] */ Type refType(Type tp) { - Symbol refClass = global.definitions.getClass(Names.scala_Ref); - assert refClass.kind == Kinds.CLASS; - return Type.TypeRef(global.definitions.SCALA_TYPE, refClass, new Type[]{tp}); + Symbol refClass = global.definitions.getClass(Names.scala_Ref); + assert refClass.kind == Kinds.CLASS; + return Type.TypeRef(global.definitions.SCALA_TYPE, refClass, new Type[]{tp}); } public Checker[] postCheckers(Global global) { @@ -169,7 +173,7 @@ public class LambdaLiftPhase extends PhaseDescriptor implements Kinds, Modifiers new CheckSymbols(global), new CheckTypes(global), new CheckOwners(global), - new CheckNames(global) + new CheckNames(global) }; } } -- cgit v1.2.3