case ValDef(_, _, Tree tpe, Tree rhs):
case ValDef(_, _, _, Tree rhs):
    public Tree transform(Tree tree) {	//global.debugPrinter.print("lifting ").print(tree).println().end();//DEBUG	//System.out.print(tree.type + " --> ");//DEBUG	tree.type = descr.transform(tree.type, currentOwner);	//System.out.println(tree.type);//DEBUG        switch (tree) {	case Block(Tree[] stats):	    for (int i = 0; i < stats.length; i++)		liftSymbol(stats[i]);	    return copy.Block(tree, transform(stats));	case ClassDef(int mods, _, AbsTypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):	    Symbol sym = tree.symbol();	    if ((mods & LIFTED) != 0) {		((ClassDef) tree).mods &= ~LIFTED;		Tree tree1 = copy.ClassDef(		    tree, sym,		    addTypeParams(transform(tparams, sym), newtparams(sym.primaryConstructor())),		    new ValDef[][]{			addParams(transform(vparams, sym)[0], newparams(sym.primaryConstructor()))}, 		    transform(tpe, sym), 		    transform(impl, sym));		liftedDefs.append(tree1);		return Tree.Empty;	    } else {		assert !sym.isLocal() : sym;		return copy.ClassDef(		    tree, sym,		    transform(tparams, sym), 		    transform(vparams, sym), 		    transform(tpe, sym),		    transform(impl, sym));	    }	case DefDef(int mods, _, AbsTypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):	    Symbol sym = tree.symbol();	    if ((mods & LIFTED) != 0) {		((DefDef) tree).mods &= ~LIFTED;		Tree tree1 = copy.DefDef(		    tree, sym,		    addTypeParams(transform(tparams, sym), newtparams(sym)),		    new ValDef[][]{			addParams(transform(vparams, sym)[0], newparams(sym))}, 		    transform(tpe, sym), 		    transform(rhs, sym));		liftedDefs.append(tree1);		return Tree.Empty;	    } else {		assert !sym.isLocal() : sym;		return copy.DefDef(		    tree, sym,		    transform(tparams, sym), transform(vparams, sym), transform(tpe, sym),		    transform(rhs, sym));	    }	case AbsTypeDef(int mods, Name name, Tree rhs, Tree lobound):	    // ignore type definition as owner.	    // reason: it might be in a refinement	    // todo: handle type parameters?	    return copy.AbsTypeDef(		tree, tree.symbol(), 		transform(rhs, currentOwner),		transform(lobound, currentOwner));	case AliasTypeDef(int mods, Name name, AbsTypeDef[] tparams, Tree rhs):	    // ignore type definition as owner.	    // reason: it might be in a refinement	    // todo: handle type parameters?	    return copy.AliasTypeDef(		tree, tree.symbol(), 		transform(tparams, currentOwner),		transform(rhs, currentOwner));	    	case ValDef(_, _, Tree tpe, Tree rhs):	    Symbol sym = tree.symbol();	    Tree tpe1 = transform(tpe);	    Tree rhs1 = transform(rhs, sym);	    if ((sym.flags & CAPTURED) != 0) {		assert sym.isLocal();		Type boxedType = sym.nextType();		tpe1 = gen.mkType(tpe.pos, boxedType);		rhs1 = gen.New(                    gen.mkPrimaryConstr(rhs.pos, boxedType, new Tree[]{rhs1}));	    }	    return copy.ValDef(tree, sym, tpe1, rhs1);	    	case Sequence(Tree[] args): 	    Tree tree1 = gen.mkNewList(tree.pos, tree.type.typeArgs()[0], transform(args));	    //new scalac.ast.printer.TextTreePrinter().print("TUPLE: ").print(tree).print("\n ==> \n").print(tree1).println().end();//DEBUG	    return tree1;	case Return(Tree expr):	    if (tree.symbol() != currentOwner.enclMethod()) {		unit.error(tree.pos, "non-local return not yet implemented");	    }	    return super.transform(tree);	case Apply(Tree fn, Tree[] args):	    Symbol fsym = TreeInfo.methSymbol(fn);	    Tree fn1 = transform(fn);	    switch (fn1) {	    case TypeApply(Tree fn2, Tree[] targs):                if (args.length == 1 && fn2.symbol() == definitions.PREDEF_ARRAY()) {                    switch (args[0]) {                    case Sequence(Tree[] items):                        assert targs.length == 1: tree;                        Tree array = gen.mkNewArray(                            args[0].pos,                            targs[0].type(),                            transform(items),                            currentOwner);                        // fn2 may be like "{ println("hello"); Predef}.Array"                        switch (fn2) {                        case Select(Tree qualifier, _):                            return gen.Block(                                args[0].pos,                                new Tree[] {qualifier, array});                        default:                            throw Debug.abort("illegal case", fn2);                        }                    }                }		fn1 = copy.TypeApply(		    fn1, fn2, addFreeArgs(tree.pos, get(free.ftvs, fsym), targs, true));		break;	    default: 		Tree[] targs = addFreeArgs(		    tree.pos, get(free.ftvs, fsym), Tree.EMPTY_ARRAY, true);		if (targs.length > 0)		    fn1 = gen.TypeApply(fn1, targs);	    }	    Tree[] args1 = transform(args);	    return copy.Apply(		tree, fn1, addFreeArgs(tree.pos, get(free.fvs, fsym), args1, false));	case Ident(Name name):	    Symbol sym = tree.symbol();	    if (isLocal(sym, currentOwner) && 		(sym.kind == TYPE || (sym.kind == VAL && !sym.isMethod()))) {		sym = descr.proxy(sym, currentOwner);	    }	    Tree tree1 = (sym.owner().kind == CLASS) 		? gen.mkRef(tree.pos, sym)		: copy.Ident(tree, sym).setType(sym.nextType());	    if (name != sym.name) {		if (tree1 instanceof Ident) ((Ident)tree1).name = sym.name;		else ((Select)tree1).selector = sym.name;	    }	    if ((sym.flags & CAPTURED) != 0) return gen.Select(tree1, definitions.REF_ELEM());	    else return tree1;	default:	    return super.transform(tree);        }    }