From 90451da3b1d8dfa25cb32dbc5a542f282c1a04ad Mon Sep 17 00:00:00 2001 From: michelou Date: Thu, 27 Apr 2006 16:47:13 +0000 Subject: removed leading/trailing tabs/blanks in files C... removed leading/trailing tabs/blanks in files Constructors.scala and LambdaLift.scala --- .../scala/tools/nsc/transform/Constructors.scala | 177 +++++++------- .../scala/tools/nsc/transform/LambdaLift.scala | 254 +++++++++++---------- 2 files changed, 221 insertions(+), 210 deletions(-) (limited to 'src') diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 1d167f78b3..34627ce939 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -1,78 +1,79 @@ -/* NSC -- new scala compiler - * Copyright 2005 LAMP/EPFL +/* NSC -- new Scala compiler + * Copyright 2005-2006 LAMP/EPFL * @author */ // $Id$ -package scala.tools.nsc.transform; -import symtab._; -import Flags._; -import scala.collection.mutable.ListBuffer; -import util.TreeSet; +package scala.tools.nsc.transform + +import symtab._ +import Flags._ +import scala.collection.mutable.ListBuffer +import util.TreeSet abstract class Constructors extends Transform { - import global._; - import definitions._; - import posAssigner.atPos; + import global._ + import definitions._ + import posAssigner.atPos /** the following two members override abstract members in Transform */ - val phaseName: String = "constructors"; + val phaseName: String = "constructors" - protected def newTransformer(unit: CompilationUnit): Transformer = new ConstructorTransformer; + protected def newTransformer(unit: CompilationUnit): Transformer = new ConstructorTransformer class ConstructorTransformer extends Transformer { def transformClassTemplate(impl: Template): Template = { - val clazz = impl.symbol.owner; - val stats = impl.body; - val localTyper = typer.atOwner(impl, clazz); - var constr: DefDef = null; - var constrParams: List[Symbol] = null; - var constrBody: Block = null; + val clazz = impl.symbol.owner + val stats = impl.body + val localTyper = typer.atOwner(impl, clazz) + var constr: DefDef = null + var constrParams: List[Symbol] = null + var constrBody: Block = null // decompose primary constructor into the three entities above. for (val stat <- stats) { - stat match { - case ddef @ DefDef(_, _, _, List(vparams), _, rhs @ Block(_, Literal(_))) => - if (ddef.symbol.isPrimaryConstructor) { - constr = ddef; - constrParams = vparams map (.symbol); - constrBody = rhs - } - case _ => - } + stat match { + case ddef @ DefDef(_, _, _, List(vparams), _, rhs @ Block(_, Literal(_))) => + if (ddef.symbol.isPrimaryConstructor) { + constr = ddef; + constrParams = vparams map (.symbol); + constrBody = rhs + } + case _ => + } } - val paramAccessors = clazz.constrParamAccessors; + val paramAccessors = clazz.constrParamAccessors def parameter(acc: Symbol) = { - val accname = nme.getterName(acc.originalName); + val accname = nme.getterName(acc.originalName) val ps = constrParams.filter { param => accname == param.name } if (ps.isEmpty) assert(false, "" + accname + " not in " + constrParams); ps.head } - var thisRefSeen: boolean = false; + var thisRefSeen: boolean = false val intoConstructorTransformer = new Transformer { - override def transform(tree: Tree): Tree = tree match { - case Apply(Select(This(_), _), List()) - if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) => + override def transform(tree: Tree): Tree = tree match { + case Apply(Select(This(_), _), List()) + if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) => gen.Ident(parameter(tree.symbol.accessed)) setPos tree.pos; - case Select(This(_), _) - if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) => - gen.Ident(parameter(tree.symbol)) setPos tree.pos; + case Select(This(_), _) + if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) => + gen.Ident(parameter(tree.symbol)) setPos tree.pos; case This(_) => thisRefSeen = true; super.transform(tree) case Super(_, _) => thisRefSeen = true; super.transform(tree) - case _ => - super.transform(tree) - } + case _ => + super.transform(tree) + } } def intoConstructor(oldowner: Symbol, tree: Tree) = - intoConstructorTransformer.transform( + intoConstructorTransformer.transform( new ChangeOwnerTraverser(oldowner, constr.symbol)(tree)); def canBeMoved(tree: Tree) = tree match { @@ -81,18 +82,18 @@ abstract class Constructors extends Transform { } def mkAssign(to: Symbol, from: Tree): Tree = - atPos(to.pos) { - localTyper.typed { - Assign(Select(This(clazz), to), from) - } - } + atPos(to.pos) { + localTyper.typed { + Assign(Select(This(clazz), to), from) + } + } def copyParam(to: Symbol, from: Symbol): Tree = { var result = mkAssign(to, Ident(from)); if (from.name == nme.OUTER) result = atPos(to.pos) { - localTyper.typed { + localTyper.typed { If(Apply(Select(Ident(from), nme.eq), List(Literal(Constant(null)))), Throw(New(TypeTree(NullPointerExceptionClass.tpe), List(List()))), result); @@ -101,66 +102,66 @@ abstract class Constructors extends Transform { result } - val defBuf = new ListBuffer[Tree]; - val constrStatBuf = new ListBuffer[Tree]; - val constrPrefixBuf = new ListBuffer[Tree]; - constrBody.stats foreach (constrStatBuf +=); + val defBuf = new ListBuffer[Tree] + val constrStatBuf = new ListBuffer[Tree] + val constrPrefixBuf = new ListBuffer[Tree] + constrBody.stats foreach (constrStatBuf +=) for (val stat <- stats) stat match { - case DefDef(mods, name, tparams, vparamss, tpt, rhs) => - stat.symbol.tpe match { - case MethodType(List(), tp @ ConstantType(c)) => - defBuf += copy.DefDef( - stat, mods, name, tparams, vparamss, tpt, - Literal(c) setPos rhs.pos setType tp) - case _ => - if (!stat.symbol.isPrimaryConstructor) defBuf += stat - } - case ValDef(mods, name, tpt, rhs) => - if (stat.symbol.tpe.isInstanceOf[ConstantType]) - assert(stat.symbol.getter(stat.symbol.owner) != NoSymbol, stat) - else { - if (rhs != EmptyTree) { + case DefDef(mods, name, tparams, vparamss, tpt, rhs) => + stat.symbol.tpe match { + case MethodType(List(), tp @ ConstantType(c)) => + defBuf += copy.DefDef( + stat, mods, name, tparams, vparamss, tpt, + Literal(c) setPos rhs.pos setType tp) + case _ => + if (!stat.symbol.isPrimaryConstructor) defBuf += stat + } + case ValDef(mods, name, tpt, rhs) => + if (stat.symbol.tpe.isInstanceOf[ConstantType]) + assert(stat.symbol.getter(stat.symbol.owner) != NoSymbol, stat) + else { + if (rhs != EmptyTree) { val rhs1 = intoConstructor(stat.symbol, rhs); (if (canBeMoved(stat)) constrPrefixBuf else constrStatBuf) += mkAssign( stat.symbol, rhs1) - } - defBuf += copy.ValDef(stat, mods, name, tpt, EmptyTree) - } + } + defBuf += copy.ValDef(stat, mods, name, tpt, EmptyTree) + } case ClassDef(_, _, _, _, _) => defBuf += (new ConstructorTransformer).transform(stat) - case _ => - constrStatBuf += intoConstructor(impl.symbol, stat) + case _ => + constrStatBuf += intoConstructor(impl.symbol, stat) } - val accessed = new TreeSet[Symbol]((x, y) => x isLess y); + val accessed = new TreeSet[Symbol]((x, y) => x isLess y) def isAccessed(sym: Symbol) = ( - sym.owner != clazz || - !(sym hasFlag PARAMACCESSOR) || - !(sym hasFlag LOCAL) || - (accessed contains sym) + sym.owner != clazz || + !(sym hasFlag PARAMACCESSOR) || + !(sym hasFlag LOCAL) || + (accessed contains sym) ); val accessTraverser = new Traverser { override def traverse(tree: Tree) = { - tree match { + tree match { case Select(_, _) => - if (!isAccessed(tree.symbol)) accessed addEntry tree.symbol; + if (!isAccessed(tree.symbol)) accessed addEntry tree.symbol case _ => } super.traverse(tree) - } + } } for (val stat <- defBuf.elements) accessTraverser.traverse(stat); val paramInits = for (val acc <- paramAccessors; isAccessed(acc)) - yield copyParam(acc, parameter(acc)) + yield copyParam(acc, parameter(acc)) defBuf += copy.DefDef( - constr, constr.mods, constr.name, constr.tparams, constr.vparamss, constr.tpt, - copy.Block( + constr, constr.mods, constr.name, constr.tparams, constr.vparamss, constr.tpt, + copy.Block( constrBody, paramInits ::: constrPrefixBuf.toList ::: constrStatBuf.toList, constrBody.expr)); @@ -168,11 +169,15 @@ abstract class Constructors extends Transform { copy.Template(impl, impl.parents, defBuf.toList filter (stat => isAccessed(stat.symbol))) } - override def transform(tree: Tree): Tree = tree match { - case ClassDef(mods, name, tparams, tpt, impl) if !tree.symbol.hasFlag(INTERFACE) => - copy.ClassDef(tree, mods, name, tparams, tpt, transformClassTemplate(impl)) - case _ => - super.transform(tree) + override def transform(tree: Tree): Tree = { + tree match { + case ClassDef(mods, name, tparams, tpt, impl) if !tree.symbol.hasFlag(INTERFACE) => + copy.ClassDef(tree, mods, name, tparams, tpt, transformClassTemplate(impl)) + case _ => + super.transform(tree) + } } - } + + } // ConstructorTransformer + } diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala index 6513c085bd..ccd30c1728 100644 --- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala +++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala @@ -1,68 +1,69 @@ -/* NSC -- new scala compiler - * Copyright 2005 LAMP/EPFL +/* NSC -- new Scala compiler + * Copyright 2005-2006 LAMP/EPFL * @author */ // $Id$ -package scala.tools.nsc.transform; -import symtab._; -import Flags._; -import util.TreeSet; -import scala.collection.mutable.{HashMap, ListBuffer}; +package scala.tools.nsc.transform + +import symtab._ +import Flags._ +import util.TreeSet +import scala.collection.mutable.{HashMap, ListBuffer} abstract class LambdaLift extends InfoTransform { - import global._; - import definitions._; - import typer.{typed, typedOperator}; - import posAssigner.atPos; + import global._ + import definitions._ + import typer.{typed, typedOperator} + import posAssigner.atPos /** the following two members override abstract members in Transform */ - val phaseName: String = "lambdalift"; + val phaseName: String = "lambdalift" private val lifted = new TypeMap { def apply(tp: Type): Type = tp match { case TypeRef(pre, sym, args) => - if (pre == NoPrefix && sym.isClass && !sym.isPackageClass) { + if (pre == NoPrefix && sym.isClass && !sym.isPackageClass) { assert(args.isEmpty); typeRef(apply(sym.owner.enclClass.thisType), sym, args) - } else mapOver(tp) + } else mapOver(tp) case ClassInfoType(parents, decls, clazz) => - val parents1 = List.mapConserve(parents)(this); - if (parents1 eq parents) tp - else ClassInfoType(parents1, decls, clazz) + val parents1 = List.mapConserve(parents)(this) + if (parents1 eq parents) tp + else ClassInfoType(parents1, decls, clazz) case _ => mapOver(tp) } } - def transformInfo(sym: Symbol, tp: Type): Type = lifted(tp); + def transformInfo(sym: Symbol, tp: Type): Type = lifted(tp) protected def newTransformer(unit: CompilationUnit): Transformer = - new LambdaLifter(unit); + new LambdaLifter(unit) class LambdaLifter(unit: CompilationUnit) extends explicitOuter.OuterPathTransformer { /** A map storing free variables of functions and classes */ - private val free = new HashMap[Symbol,SymSet]; + private val free = new HashMap[Symbol, SymSet] /** A map storing the free variable proxies of functions and classes */ - private val proxies = new HashMap[Symbol, List[Symbol]]; + private val proxies = new HashMap[Symbol, List[Symbol]] /** A hashtable storing calls between functions */ - private val called = new HashMap[Symbol, SymSet]; + private val called = new HashMap[Symbol, SymSet] /** The set of symbols that need to be renamed. */ - private val renamable = newSymSet; + private val renamable = newSymSet /** A flag to indicate whether new free variables have been found */ - private var changedFreeVars: boolean = _; + private var changedFreeVars: boolean = _ /** Buffers for lifted out classes and methods */ - private val liftedDefs = new HashMap[Symbol, ListBuffer[Tree]]; + private val liftedDefs = new HashMap[Symbol, ListBuffer[Tree]] - private type SymSet = TreeSet[Symbol]; + private type SymSet = TreeSet[Symbol] - private def newSymSet = new TreeSet[Symbol]((x, y) => x.isLess(y)); + private def newSymSet = new TreeSet[Symbol]((x, y) => x.isLess(y)) private def symSet(f: HashMap[Symbol, SymSet], sym: Symbol): SymSet = f.get(sym) match { case Some(ss) => ss @@ -74,8 +75,8 @@ abstract class LambdaLift extends InfoTransform { private def enclMethOrClass(sym: Symbol): Symbol = { def localToConstr(sym: Symbol) = - if (sym.isLocalDummy) sym.owner.primaryConstructor else sym; - var encl = localToConstr(sym); + if (sym.isLocalDummy) sym.owner.primaryConstructor else sym; + var encl = localToConstr(sym) while (!encl.isMethod && !encl.isClass) encl = localToConstr(outer(encl)); encl @@ -89,18 +90,18 @@ abstract class LambdaLift extends InfoTransform { * pre: sym.isLocal, (owner.isMethod || owner.isClass) */ private def markFree(sym: Symbol, owner: Symbol): boolean = { - if (settings.debug.value) log("mark " + sym + " of " + sym.owner + " free in " + owner); + if (settings.debug.value) log("mark " + sym + " of " + sym.owner + " free in " + owner) if (owner == enclMethOrClass(sym.owner)) true else if (owner.isPackageClass || !markFree(sym, enclMethOrClass(outer(owner)))) false else { - val ss = symSet(free, owner); - if (!(ss contains sym)) { - ss addEntry sym; - renamable addEntry sym; - changedFreeVars = true; - if (settings.debug.value) log("" + sym + " is free in " + owner); - if (sym.isVariable && !(sym hasFlag CAPTURED)) { - sym setFlag CAPTURED; + val ss = symSet(free, owner) + if (!(ss contains sym)) { + ss addEntry sym; + renamable addEntry sym; + changedFreeVars = true + if (settings.debug.value) log("" + sym + " is free in " + owner); + if (sym.isVariable && !(sym hasFlag CAPTURED)) { + sym setFlag CAPTURED val symClass = sym.tpe.symbol; atPhase(phase.next) { sym updateInfo ( @@ -108,25 +109,25 @@ abstract class LambdaLift extends InfoTransform { } } } - !owner.isClass + !owner.isClass } } private def markCalled(sym: Symbol, owner: Symbol): unit = { - if (settings.debug.value) log("mark " + sym + " of " + sym.owner + " called by " + owner); - symSet(called, owner) addEntry sym; + if (settings.debug.value) + log("mark " + sym + " of " + sym.owner + " called by " + owner); + symSet(called, owner) addEntry sym } /* - if (owner == enclMethOrClass(sym.owner)) true else if (owner.isPackageClass || !markCalled(sym, enclMethOrClass(outer(owner)))) false else { - val ss = symSet(called, owner); - if (!(ss contains sym)) { - ss addEntry sym; - if (settings.debug.value) log("" + sym + " is called by " + owner); + val ss = symSet(called, owner); + if (!(ss contains sym)) { + ss addEntry sym; + if (settings.debug.value) log("" + sym + " is called by " + owner); } - !owner.isClass + !owner.isClass } } */ @@ -141,37 +142,37 @@ abstract class LambdaLift extends InfoTransform { try { //debug val sym = tree.symbol; tree match { - case ClassDef(_, _, _, _, _) => - liftedDefs(tree.symbol) = new ListBuffer; - if (sym.isLocal) renamable addEntry sym; - case DefDef(_, _, _, _, _, _) => - if (sym.isLocal) { - renamable addEntry sym; - sym setFlag (PRIVATE | LOCAL | FINAL) - } else if (sym.isPrimaryConstructor) { - symSet(called, sym) addEntry sym.owner - } - case Ident(name) => - if (sym == NoSymbol) { - assert(name == nme.WILDCARD) + case ClassDef(_, _, _, _, _) => + liftedDefs(tree.symbol) = new ListBuffer + if (sym.isLocal) renamable addEntry sym + case DefDef(_, _, _, _, _, _) => + if (sym.isLocal) { + renamable addEntry sym; + sym setFlag (PRIVATE | LOCAL | FINAL) + } else if (sym.isPrimaryConstructor) { + symSet(called, sym) addEntry sym.owner + } + case Ident(name) => + if (sym == NoSymbol) { + assert(name == nme.WILDCARD) } else if (sym.isLocal) { - val owner = enclMethOrClass(currentOwner); + val owner = enclMethOrClass(currentOwner); if (sym.isTerm && !sym.isMethod) markFree(sym, owner) else if (sym.isMethod) markCalled(sym, owner) //symSet(called, owner) addEntry sym; } - case Select(_, _) => + case Select(_, _) => if (sym.isConstructor && sym.owner.isLocal) { - val owner = enclMethOrClass(currentOwner); + val owner = enclMethOrClass(currentOwner); markCalled(sym, owner) //symSet(called, owner) addEntry sym; } case _ => } super.traverse(tree) } catch {//debug - case ex: Throwable => - System.out.println("exception when traversing " + tree); - throw ex + case ex: Throwable => + System.out.println("exception when traversing " + tree); + throw ex } } } @@ -182,14 +183,14 @@ abstract class LambdaLift extends InfoTransform { * all class/function symbols that are owned by some function. */ private def computeFreeVars: unit = { - freeVarTraverser.traverse(unit.body); + freeVarTraverser.traverse(unit.body) do { - changedFreeVars = false; - for (val caller <- called.keys; - val callee <- called(caller).elements; - val fv <- freeVars(callee)) - markFree(fv, caller); + changedFreeVars = false + for (val caller <- called.keys; + val callee <- called(caller).elements; + val fv <- freeVars(callee)) + markFree(fv, caller); } while (changedFreeVars); for (val sym <- renamable.elements) { @@ -216,7 +217,9 @@ abstract class LambdaLift extends InfoTransform { private def proxy(sym: Symbol) = { def searchIn(owner: Symbol): Symbol = { - if (settings.debug.value) log("searching for " + sym + "(" + sym.owner + ") in " + owner + " " + enclMethOrClass(owner));//debug + if (settings.debug.value) + log("searching for " + sym + "(" + sym.owner + ") in " + owner + + " " + enclMethOrClass(owner));//debug proxies.get(enclMethOrClass(owner)) match { case Some(ps) => ps filter (p => p.name == sym.name) match { @@ -226,19 +229,21 @@ abstract class LambdaLift extends InfoTransform { case None => searchIn(outer(owner)) } } - if (settings.debug.value) log("proxy " + sym + " in " + sym.owner + " from " + currentOwner.ownerChain + " " + enclMethOrClass(sym.owner));//debug + if (settings.debug.value) + log("proxy " + sym + " in " + sym.owner + " from " + currentOwner.ownerChain + + " " + enclMethOrClass(sym.owner));//debug if (enclMethOrClass(sym.owner) == enclMethOrClass(currentOwner)) sym else searchIn(currentOwner) } private def memberRef(sym: Symbol) = { - val clazz = sym.owner.enclClass; + val clazz = sym.owner.enclClass val qual = if (clazz == currentOwner.enclClass) gen.This(clazz) - else { - sym resetFlag(LOCAL | PRIVATE); - if (clazz.isStaticOwner) gen.mkQualifier(clazz.thisType) - else outerPath(outerValue, clazz) - } + else { + sym resetFlag(LOCAL | PRIVATE) + if (clazz.isStaticOwner) gen.mkQualifier(clazz.thisType) + else outerPath(outerValue, clazz) + } Select(qual, sym) setType sym.tpe } @@ -252,8 +257,8 @@ abstract class LambdaLift extends InfoTransform { } private def addFreeArgs(pos: int, sym: Symbol, args: List[Tree]) = { - def freeArg(fv: Symbol) = atPos(pos)(proxyRef(fv)); - val fvs = freeVars(sym).toList; + def freeArg(fv: Symbol) = atPos(pos)(proxyRef(fv)) + val fvs = freeVars(sym).toList if (fvs.isEmpty) args else args ::: (fvs map freeArg) } @@ -263,7 +268,7 @@ abstract class LambdaLift extends InfoTransform { tree match { case DefDef(mods, name, tparams, List(vparams), tpt, rhs) => sym.updateInfo( - lifted(MethodType(sym.info.paramTypes ::: (ps map (.tpe)), sym.info.resultType))); + lifted(MethodType(sym.info.paramTypes ::: (ps map (.tpe)), sym.info.resultType))); copy.DefDef(tree, mods, name, tparams, List(vparams ::: freeParams), tpt, rhs) case ClassDef(mods, name, tparams, tpt, impl @ Template(parents, body)) => copy.ClassDef(tree, mods, name, tparams, tpt, @@ -274,28 +279,28 @@ abstract class LambdaLift extends InfoTransform { } private def liftDef(tree: Tree): Tree = { - val sym = tree.symbol; - sym.owner = sym.owner.enclClass; - if (sym.isClass) sym.owner = sym.owner.toInterface; - if (sym.isMethod) sym setFlag LIFTED; - liftedDefs(sym.owner) += tree; - sym.owner.info.decls enterUnique sym; - if (settings.debug.value) log("lifted: " + sym + sym.locationString); + val sym = tree.symbol + sym.owner = sym.owner.enclClass + if (sym.isClass) sym.owner = sym.owner.toInterface + if (sym.isMethod) sym setFlag LIFTED + liftedDefs(sym.owner) += tree + sym.owner.info.decls enterUnique sym + if (settings.debug.value) log("lifted: " + sym + sym.locationString) EmptyTree } private def postTransform(tree: Tree): Tree = { - val sym = tree.symbol; + val sym = tree.symbol tree match { case ClassDef(_, _, _, _, _) => - val tree1 = addFreeParams(tree, sym); + val tree1 = addFreeParams(tree, sym) if (sym.isLocal) liftDef(tree1) else tree1 - case DefDef(_, _, _, _, _, _) => - val tree1 = addFreeParams(tree, sym); + case DefDef(_, _, _, _, _, _) => + val tree1 = addFreeParams(tree, sym) if (sym.isLocal) liftDef(tree1) else tree1 - case ValDef(mods, name, tpt, rhs) => + case ValDef(mods, name, tpt, rhs) => if (sym.isCapturedVariable) { - val tpt1 = TypeTree(sym.tpe) setPos tpt.pos; + val tpt1 = TypeTree(sym.tpe) setPos tpt.pos val rhs1 = atPos(rhs.pos) { typed { @@ -306,28 +311,28 @@ abstract class LambdaLift extends InfoTransform { } else tree case Return(Block(stats, value)) => Block(stats, copy.Return(tree, value)) setType tree.tpe setPos tree.pos - case Return(expr) => - assert(sym == currentOwner.enclMethod, sym) + case Return(expr) => + assert(sym == currentOwner.enclMethod, sym) tree - case Apply(fn, args) => - copy.Apply(tree, fn, addFreeArgs(tree.pos, sym, args)); - case Assign(Apply(TypeApply(sel @ Select(qual, _), _), List()), rhs) => - // eliminate casts introduced by selecting a captured variable field - // on the lhs of an assignment. - assert(sel.symbol == Object_asInstanceOf); - copy.Assign(tree, qual, rhs) + case Apply(fn, args) => + copy.Apply(tree, fn, addFreeArgs(tree.pos, sym, args)) + case Assign(Apply(TypeApply(sel @ Select(qual, _), _), List()), rhs) => + // eliminate casts introduced by selecting a captured variable field + // on the lhs of an assignment. + assert(sel.symbol == Object_asInstanceOf) + copy.Assign(tree, qual, rhs) case Ident(name) => - val tree1 = + val tree1 = if (sym != NoSymbol && sym.isTerm && !sym.isLabel) - if (sym.isMethod) - atPos(tree.pos)(memberRef(sym)) - else if (sym.isLocal && enclMethOrClass(sym.owner) != enclMethOrClass(currentOwner)) - atPos(tree.pos)(proxyRef(sym)) - else tree - else tree; + if (sym.isMethod) + atPos(tree.pos)(memberRef(sym)) + else if (sym.isLocal && enclMethOrClass(sym.owner) != enclMethOrClass(currentOwner)) + atPos(tree.pos)(proxyRef(sym)) + else tree + else tree; if (sym.isCapturedVariable) atPos(tree.pos) { - val tp = tree.tpe; + val tp = tree.tpe val elemTree = typed { Select(tree1 setType sym.tpe, nme.elem) } if (elemTree.tpe.symbol != tp.symbol) gen.cast(elemTree, tp) else elemTree } @@ -338,27 +343,28 @@ abstract class LambdaLift extends InfoTransform { } override def transform(tree: Tree): Tree = { - postTransform(super.transform(tree) setType lifted(tree.tpe)); + postTransform(super.transform(tree) setType lifted(tree.tpe)) } /** Transform statements and add lifted definitions to them. */ override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] = { def addLifted(stat: Tree): Tree = stat match { - case ClassDef(mods, name, tparams, tpt, impl @ Template(parents, body)) => - val lifted = liftedDefs(stat.symbol).toList map addLifted; - val result = copy.ClassDef( + case ClassDef(mods, name, tparams, tpt, impl @ Template(parents, body)) => + val lifted = liftedDefs(stat.symbol).toList map addLifted + val result = copy.ClassDef( stat, mods, name, tparams, tpt, copy.Template(impl, parents, body ::: lifted)); - liftedDefs -= stat.symbol; - result - case _ => - stat + liftedDefs -= stat.symbol; + result + case _ => + stat } super.transformStats(stats, exprOwner) map addLifted } override def transformUnit(unit: CompilationUnit): unit = { - computeFreeVars; - atPhase(phase.next)(super.transformUnit(unit)); + computeFreeVars + atPhase(phase.next)(super.transformUnit(unit)) assert(liftedDefs.size == 0, liftedDefs.keys.toList) } - } + } // class LambdaLifter + } -- cgit v1.2.3