1 /*
   2  * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.javac.comp;
  27 
  28 import java.util.*;
  29 
  30 import javax.lang.model.element.ElementKind;
  31 
  32 import com.sun.tools.javac.code.*;
  33 import com.sun.tools.javac.code.Symbol.*;
  34 import com.sun.tools.javac.tree.*;
  35 import com.sun.tools.javac.tree.JCTree.*;
  36 import com.sun.tools.javac.util.*;
  37 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
  38 import com.sun.tools.javac.util.List;
  39 
  40 import static com.sun.tools.javac.code.Flags.*;
  41 import static com.sun.tools.javac.code.Kinds.*;
  42 import static com.sun.tools.javac.code.TypeTags.*;
  43 
  44 /** This pass translates Generic Java to conventional Java.
  45  *
  46  *  <p><b>This is NOT part of any supported API.
  47  *  If you write code that depends on this, you do so at your own risk.
  48  *  This code and its internal interfaces are subject to change or
  49  *  deletion without notice.</b>
  50  */
  51 public class TransTypes extends TreeTranslator {
  52     /** The context key for the TransTypes phase. */
  53     protected static final Context.Key<TransTypes> transTypesKey =
  54         new Context.Key<TransTypes>();
  55 
  56     /** Get the instance for this context. */
  57     public static TransTypes instance(Context context) {
  58         TransTypes instance = context.get(transTypesKey);
  59         if (instance == null)
  60             instance = new TransTypes(context);
  61         return instance;
  62     }
  63 
  64     private Names names;
  65     private Log log;
  66     private Symtab syms;
  67     private TreeMaker make;
  68     private Enter enter;
  69     private boolean allowEnums;
  70     private Types types;
  71     private final Resolve resolve;
  72     private final TypeAnnotations typeAnnotations;
  73 
  74     /**
  75      * Flag to indicate whether or not to generate bridge methods.
  76      * For pre-Tiger source there is no need for bridge methods, so it
  77      * can be skipped to get better performance for -source 1.4 etc.
  78      */
  79     private final boolean addBridges;
  80 
  81     protected TransTypes(Context context) {
  82         context.put(transTypesKey, this);
  83         names = Names.instance(context);
  84         log = Log.instance(context);
  85         syms = Symtab.instance(context);
  86         enter = Enter.instance(context);
  87         overridden = new HashMap<MethodSymbol,MethodSymbol>();
  88         Source source = Source.instance(context);
  89         allowEnums = source.allowEnums();
  90         addBridges = source.addBridges();
  91         types = Types.instance(context);
  92         make = TreeMaker.instance(context);
  93         resolve = Resolve.instance(context);
  94         typeAnnotations = TypeAnnotations.instance(context);
  95     }
  96 
  97     /** A hashtable mapping bridge methods to the methods they override after
  98      *  type erasure.
  99      */
 100     Map<MethodSymbol,MethodSymbol> overridden;
 101 
 102     /** Construct an attributed tree for a cast of expression to target type,
 103      *  unless it already has precisely that type.
 104      *  @param tree    The expression tree.
 105      *  @param target  The target type.
 106      */
 107     JCExpression cast(JCExpression tree, Type target) {
 108         int oldpos = make.pos;
 109         make.at(tree.pos);
 110         if (!types.isSameType(tree.type, target)) {
 111             if (!resolve.isAccessible(env, target.tsym))
 112                 resolve.logAccessError(env, tree, target);
 113             tree = make.TypeCast(make.Type(target), tree).setType(target);
 114         }
 115         make.pos = oldpos;
 116         return tree;
 117     }
 118 
 119     /** Construct an attributed tree to coerce an expression to some erased
 120      *  target type, unless the expression is already assignable to that type.
 121      *  If target type is a constant type, use its base type instead.
 122      *  @param tree    The expression tree.
 123      *  @param target  The target type.
 124      */
 125     JCExpression coerce(JCExpression tree, Type target) {
 126         Type btarget = target.baseType();
 127         if (tree.type.isPrimitive() == target.isPrimitive()) {
 128             return types.isAssignable(tree.type, btarget, Warner.noWarnings)
 129                 ? tree
 130                 : cast(tree, btarget);
 131         }
 132         return tree;
 133     }
 134 
 135     /** Given an erased reference type, assume this type as the tree's type.
 136      *  Then, coerce to some given target type unless target type is null.
 137      *  This operation is used in situations like the following:
 138      *
 139      *  class Cell<A> { A value; }
 140      *  ...
 141      *  Cell<Integer> cell;
 142      *  Integer x = cell.value;
 143      *
 144      *  Since the erasure of Cell.value is Object, but the type
 145      *  of cell.value in the assignment is Integer, we need to
 146      *  adjust the original type of cell.value to Object, and insert
 147      *  a cast to Integer. That is, the last assignment becomes:
 148      *
 149      *  Integer x = (Integer)cell.value;
 150      *
 151      *  @param tree       The expression tree whose type might need adjustment.
 152      *  @param erasedType The expression's type after erasure.
 153      *  @param target     The target type, which is usually the erasure of the
 154      *                    expression's original type.
 155      */
 156     JCExpression retype(JCExpression tree, Type erasedType, Type target) {
 157 //      System.err.println("retype " + tree + " to " + erasedType);//DEBUG
 158         if (erasedType.tag > lastBaseTag) {
 159             if (target != null && target.isPrimitive())
 160                 target = erasure(tree.type);
 161             tree.type = erasedType;
 162             if (target != null) return coerce(tree, target);
 163         }
 164         return tree;
 165     }
 166 
 167     /** Translate method argument list, casting each argument
 168      *  to its corresponding type in a list of target types.
 169      *  @param _args            The method argument list.
 170      *  @param parameters       The list of target types.
 171      *  @param varargsElement   The erasure of the varargs element type,
 172      *  or null if translating a non-varargs invocation
 173      */
 174     <T extends JCTree> List<T> translateArgs(List<T> _args,
 175                                            List<Type> parameters,
 176                                            Type varargsElement) {
 177         if (parameters.isEmpty()) return _args;
 178         List<T> args = _args;
 179         while (parameters.tail.nonEmpty()) {
 180             args.head = translate(args.head, parameters.head);
 181             args = args.tail;
 182             parameters = parameters.tail;
 183         }
 184         Type parameter = parameters.head;
 185         assert varargsElement != null || args.length() == 1;
 186         if (varargsElement != null) {
 187             while (args.nonEmpty()) {
 188                 args.head = translate(args.head, varargsElement);
 189                 args = args.tail;
 190             }
 191         } else {
 192             args.head = translate(args.head, parameter);
 193         }
 194         return _args;
 195     }
 196 
 197     /** Add a bridge definition and enter corresponding method symbol in
 198      *  local scope of origin.
 199      *
 200      *  @param pos     The source code position to be used for the definition.
 201      *  @param meth    The method for which a bridge needs to be added
 202      *  @param impl    That method's implementation (possibly the method itself)
 203      *  @param origin  The class to which the bridge will be added
 204      *  @param hypothetical
 205      *                 True if the bridge method is not strictly necessary in the
 206      *                 binary, but is represented in the symbol table to detect
 207      *                 erasure clashes.
 208      *  @param bridges The list buffer to which the bridge will be added
 209      */
 210     void addBridge(DiagnosticPosition pos,
 211                    MethodSymbol meth,
 212                    MethodSymbol impl,
 213                    ClassSymbol origin,
 214                    boolean hypothetical,
 215                    ListBuffer<JCTree> bridges) {
 216         make.at(pos);
 217         Type origType = types.memberType(origin.type, meth);
 218         Type origErasure = erasure(origType);
 219 
 220         // Create a bridge method symbol and a bridge definition without a body.
 221         Type bridgeType = meth.erasure(types);
 222         long flags = impl.flags() & AccessFlags | SYNTHETIC | BRIDGE;
 223         if (hypothetical) flags |= HYPOTHETICAL;
 224         MethodSymbol bridge = new MethodSymbol(flags,
 225                                                meth.name,
 226                                                bridgeType,
 227                                                origin);
 228         if (!hypothetical) {
 229             JCMethodDecl md = make.MethodDef(bridge, null);
 230 
 231             // The bridge calls this.impl(..), if we have an implementation
 232             // in the current class, super.impl(...) otherwise.
 233             JCExpression receiver = (impl.owner == origin)
 234                 ? make.This(origin.erasure(types))
 235                 : make.Super(types.supertype(origin.type).tsym.erasure(types), origin);
 236 
 237             // The type returned from the original method.
 238             Type calltype = erasure(impl.type.getReturnType());
 239 
 240             // Construct a call of  this.impl(params), or super.impl(params),
 241             // casting params and possibly results as needed.
 242             JCExpression call =
 243                 make.Apply(
 244                            null,
 245                            make.Select(receiver, impl).setType(calltype),
 246                            translateArgs(make.Idents(md.params), origErasure.getParameterTypes(), null))
 247                 .setType(calltype);
 248             JCStatement stat = (origErasure.getReturnType().tag == VOID)
 249                 ? make.Exec(call)
 250                 : make.Return(coerce(call, bridgeType.getReturnType()));
 251             md.body = make.Block(0, List.of(stat));
 252 
 253             // Add bridge to `bridges' buffer
 254             bridges.append(md);
 255         }
 256 
 257         // Add bridge to scope of enclosing class and `overridden' table.
 258         origin.members().enter(bridge);
 259         overridden.put(bridge, meth);
 260     }
 261 
 262     /** Add bridge if given symbol is a non-private, non-static member
 263      *  of the given class, which is either defined in the class or non-final
 264      *  inherited, and one of the two following conditions holds:
 265      *  1. The method's type changes in the given class, as compared to the
 266      *     class where the symbol was defined, (in this case
 267      *     we have extended a parameterized class with non-trivial parameters).
 268      *  2. The method has an implementation with a different erased return type.
 269      *     (in this case we have used co-variant returns).
 270      *  If a bridge already exists in some other class, no new bridge is added.
 271      *  Instead, it is checked that the bridge symbol overrides the method symbol.
 272      *  (Spec ???).
 273      *  todo: what about bridges for privates???
 274      *
 275      *  @param pos     The source code position to be used for the definition.
 276      *  @param sym     The symbol for which a bridge might have to be added.
 277      *  @param origin  The class in which the bridge would go.
 278      *  @param bridges The list buffer to which the bridge would be added.
 279      */
 280     void addBridgeIfNeeded(DiagnosticPosition pos,
 281                            Symbol sym,
 282                            ClassSymbol origin,
 283                            ListBuffer<JCTree> bridges) {
 284         if (sym.kind == MTH &&
 285             sym.name != names.init &&
 286             (sym.flags() & (PRIVATE | SYNTHETIC | STATIC)) == 0 &&
 287             sym.isMemberOf(origin, types))
 288         {
 289             MethodSymbol meth = (MethodSymbol)sym;
 290             MethodSymbol bridge = meth.binaryImplementation(origin, types);
 291             MethodSymbol impl = meth.implementation(origin, types, true);
 292             if (bridge == null ||
 293                 bridge == meth ||
 294                 (impl != null && !bridge.owner.isSubClass(impl.owner, types))) {
 295                 // No bridge was added yet.
 296                 if (impl != null && isBridgeNeeded(meth, impl, origin.type)) {
 297                     addBridge(pos, meth, impl, origin, bridge==impl, bridges);
 298                 } else if (impl == meth
 299                            && impl.owner != origin
 300                            && (impl.flags() & FINAL) == 0
 301                            && (meth.flags() & (ABSTRACT|PUBLIC)) == PUBLIC
 302                            && (origin.flags() & PUBLIC) > (impl.owner.flags() & PUBLIC)) {
 303                     // this is to work around a horrible but permanent
 304                     // reflection design error.
 305                     addBridge(pos, meth, impl, origin, false, bridges);
 306                 }
 307             } else if ((bridge.flags() & SYNTHETIC) != 0) {
 308                 MethodSymbol other = overridden.get(bridge);
 309                 if (other != null && other != meth) {
 310                     if (impl == null || !impl.overrides(other, origin, types, true)) {
 311                         // Bridge for other symbol pair was added
 312                         log.error(pos, "name.clash.same.erasure.no.override",
 313                                   other, other.location(origin.type, types),
 314                                   meth,  meth.location(origin.type, types));
 315                     }
 316                 }
 317             } else if (!bridge.overrides(meth, origin, types, true)) {
 318                 // Accidental binary override without source override.
 319                 if (bridge.owner == origin ||
 320                     types.asSuper(bridge.owner.type, meth.owner) == null)
 321                     // Don't diagnose the problem if it would already
 322                     // have been reported in the superclass
 323                     log.error(pos, "name.clash.same.erasure.no.override",
 324                               bridge, bridge.location(origin.type, types),
 325                               meth,  meth.location(origin.type, types));
 326             }
 327         }
 328     }
 329     // where
 330         /**
 331          * @param method The symbol for which a bridge might have to be added
 332          * @param impl The implementation of method
 333          * @param dest The type in which the bridge would go
 334          */
 335         private boolean isBridgeNeeded(MethodSymbol method,
 336                                        MethodSymbol impl,
 337                                        Type dest) {
 338             if (impl != method) {
 339                 // If either method or impl have different erasures as
 340                 // members of dest, a bridge is needed.
 341                 Type method_erasure = method.erasure(types);
 342                 if (!isSameMemberWhenErased(dest, method, method_erasure))
 343                     return true;
 344                 Type impl_erasure = impl.erasure(types);
 345                 if (!isSameMemberWhenErased(dest, impl, impl_erasure))
 346                     return true;
 347 
 348                 // If the erasure of the return type is different, a
 349                 // bridge is needed.
 350                 return !types.isSameType(impl_erasure.getReturnType(),
 351                                          method_erasure.getReturnType());
 352             } else {
 353                // method and impl are the same...
 354                 if ((method.flags() & ABSTRACT) != 0) {
 355                     // ...and abstract so a bridge is not needed.
 356                     // Concrete subclasses will bridge as needed.
 357                     return false;
 358                 }
 359 
 360                 // The erasure of the return type is always the same
 361                 // for the same symbol.  Reducing the three tests in
 362                 // the other branch to just one:
 363                 return !isSameMemberWhenErased(dest, method, method.erasure(types));
 364             }
 365         }
 366         /**
 367          * Lookup the method as a member of the type.  Compare the
 368          * erasures.
 369          * @param type the class where to look for the method
 370          * @param method the method to look for in class
 371          * @param erasure the erasure of method
 372          */
 373         private boolean isSameMemberWhenErased(Type type,
 374                                                MethodSymbol method,
 375                                                Type erasure) {
 376             return types.isSameType(erasure(types.memberType(type, method)),
 377                                     erasure);
 378         }
 379 
 380     void addBridges(DiagnosticPosition pos,
 381                     TypeSymbol i,
 382                     ClassSymbol origin,
 383                     ListBuffer<JCTree> bridges) {
 384         for (Scope.Entry e = i.members().elems; e != null; e = e.sibling)
 385             addBridgeIfNeeded(pos, e.sym, origin, bridges);
 386         for (List<Type> l = types.interfaces(i.type); l.nonEmpty(); l = l.tail)
 387             addBridges(pos, l.head.tsym, origin, bridges);
 388     }
 389 
 390     /** Add all necessary bridges to some class appending them to list buffer.
 391      *  @param pos     The source code position to be used for the bridges.
 392      *  @param origin  The class in which the bridges go.
 393      *  @param bridges The list buffer to which the bridges are added.
 394      */
 395     void addBridges(DiagnosticPosition pos, ClassSymbol origin, ListBuffer<JCTree> bridges) {
 396         Type st = types.supertype(origin.type);
 397         while (st.tag == CLASS) {
 398 //          if (isSpecialization(st))
 399             addBridges(pos, st.tsym, origin, bridges);
 400             st = types.supertype(st);
 401         }
 402         for (List<Type> l = types.interfaces(origin.type); l.nonEmpty(); l = l.tail)
 403 //          if (isSpecialization(l.head))
 404             addBridges(pos, l.head.tsym, origin, bridges);
 405     }
 406 
 407 /* ************************************************************************
 408  * Visitor methods
 409  *************************************************************************/
 410 
 411     /** Visitor argument: proto-type.
 412      */
 413     private Type pt;
 414 
 415     /** Visitor method: perform a type translation on tree.
 416      */
 417     public <T extends JCTree> T translate(T tree, Type pt) {
 418         Type prevPt = this.pt;
 419         try {
 420             this.pt = pt;
 421             return translate(tree);
 422         } finally {
 423             this.pt = prevPt;
 424         }
 425     }
 426 
 427     /** Visitor method: perform a type translation on list of trees.
 428      */
 429     public <T extends JCTree> List<T> translate(List<T> trees, Type pt) {
 430         Type prevPt = this.pt;
 431         List<T> res;
 432         try {
 433             this.pt = pt;
 434             res = translate(trees);
 435         } finally {
 436             this.pt = prevPt;
 437         }
 438         return res;
 439     }
 440 
 441     public void visitClassDef(JCClassDecl tree) {
 442         typeAnnotations.taFillAndLift(tree, true);
 443         translateClass(tree.sym);
 444         result = tree;
 445     }
 446 
 447     JCMethodDecl currentMethod = null;
 448     public void visitMethodDef(JCMethodDecl tree) {
 449         tree.sym.typeAnnotations = tree.sym.typeAnnotations;
 450         JCMethodDecl previousMethod = currentMethod;
 451         try {
 452             currentMethod = tree;
 453             tree.restype = translate(tree.restype, null);
 454             tree.typarams = List.nil();
 455             tree.params = translateVarDefs(tree.params);
 456             tree.thrown = translate(tree.thrown, null);
 457             tree.body = translate(tree.body, tree.sym.erasure(types).getReturnType());
 458             tree.type = erasure(tree.type);
 459             result = tree;
 460         } finally {
 461             currentMethod = previousMethod;
 462         }
 463 
 464         // Check that we do not introduce a name clash by erasing types.
 465         for (Scope.Entry e = tree.sym.owner.members().lookup(tree.name);
 466              e.sym != null;
 467              e = e.next()) {
 468             if (e.sym != tree.sym &&
 469                 types.isSameType(erasure(e.sym.type), tree.type)) {
 470                 log.error(tree.pos(),
 471                           "name.clash.same.erasure", tree.sym,
 472                           e.sym);
 473                 return;
 474             }
 475         }
 476     }
 477 
 478     public void visitVarDef(JCVariableDecl tree) {
 479         tree.vartype = translate(tree.vartype, null);
 480         tree.init = translate(tree.init, tree.sym.erasure(types));
 481         tree.type = erasure(tree.type);
 482         result = tree;
 483     }
 484 
 485     public void visitDoLoop(JCDoWhileLoop tree) {
 486         tree.body = translate(tree.body);
 487         tree.cond = translate(tree.cond, syms.booleanType);
 488         result = tree;
 489     }
 490 
 491     public void visitWhileLoop(JCWhileLoop tree) {
 492         tree.cond = translate(tree.cond, syms.booleanType);
 493         tree.body = translate(tree.body);
 494         result = tree;
 495     }
 496 
 497     public void visitForLoop(JCForLoop tree) {
 498         tree.init = translate(tree.init, null);
 499         if (tree.cond != null)
 500             tree.cond = translate(tree.cond, syms.booleanType);
 501         tree.step = translate(tree.step, null);
 502         tree.body = translate(tree.body);
 503         result = tree;
 504     }
 505 
 506     public void visitForeachLoop(JCEnhancedForLoop tree) {
 507         tree.var = translate(tree.var, null);
 508         Type iterableType = tree.expr.type;
 509         tree.expr = translate(tree.expr, erasure(tree.expr.type));
 510         if (types.elemtype(tree.expr.type) == null)
 511             tree.expr.type = iterableType; // preserve type for Lower
 512         tree.body = translate(tree.body);
 513         result = tree;
 514     }
 515 
 516     public void visitSwitch(JCSwitch tree) {
 517         Type selsuper = types.supertype(tree.selector.type);
 518         boolean enumSwitch = selsuper != null &&
 519             selsuper.tsym == syms.enumSym;
 520         Type target = enumSwitch ? erasure(tree.selector.type) : syms.intType;
 521         tree.selector = translate(tree.selector, target);
 522         tree.cases = translateCases(tree.cases);
 523         result = tree;
 524     }
 525 
 526     public void visitCase(JCCase tree) {
 527         tree.pat = translate(tree.pat, null);
 528         tree.stats = translate(tree.stats);
 529         result = tree;
 530     }
 531 
 532     public void visitSynchronized(JCSynchronized tree) {
 533         tree.lock = translate(tree.lock, erasure(tree.lock.type));
 534         tree.body = translate(tree.body);
 535         result = tree;
 536     }
 537 
 538     public void visitTry(JCTry tree) {
 539         tree.body = translate(tree.body);
 540         tree.catchers = translateCatchers(tree.catchers);
 541         tree.finalizer = translate(tree.finalizer);
 542         tree.resources = translate(tree.resources, syms.autoCloseableType);
 543         result = tree;
 544     }
 545 
 546     public void visitConditional(JCConditional tree) {
 547         tree.cond = translate(tree.cond, syms.booleanType);
 548         tree.truepart = translate(tree.truepart, erasure(tree.type));
 549         tree.falsepart = translate(tree.falsepart, erasure(tree.type));
 550         tree.type = erasure(tree.type);
 551         result = retype(tree, tree.type, pt);
 552     }
 553 
 554    public void visitIf(JCIf tree) {
 555         tree.cond = translate(tree.cond, syms.booleanType);
 556         tree.thenpart = translate(tree.thenpart);
 557         tree.elsepart = translate(tree.elsepart);
 558         result = tree;
 559     }
 560 
 561     public void visitExec(JCExpressionStatement tree) {
 562         tree.expr = translate(tree.expr, null);
 563         result = tree;
 564     }
 565 
 566     public void visitReturn(JCReturn tree) {
 567         tree.expr = translate(tree.expr, currentMethod.sym.erasure(types).getReturnType());
 568         result = tree;
 569     }
 570 
 571     public void visitThrow(JCThrow tree) {
 572         tree.expr = translate(tree.expr, erasure(tree.expr.type));
 573         result = tree;
 574     }
 575 
 576     public void visitAssert(JCAssert tree) {
 577         tree.cond = translate(tree.cond, syms.booleanType);
 578         if (tree.detail != null)
 579             tree.detail = translate(tree.detail, erasure(tree.detail.type));
 580         result = tree;
 581     }
 582 
 583     public void visitApply(JCMethodInvocation tree) {
 584         tree.meth = translate(tree.meth, null);
 585         Symbol meth = TreeInfo.symbol(tree.meth);
 586         Type mt = meth.erasure(types);
 587         List<Type> argtypes = mt.getParameterTypes();
 588         if (allowEnums &&
 589             meth.name==names.init &&
 590             meth.owner == syms.enumSym)
 591             argtypes = argtypes.tail.tail;
 592         if (tree.varargsElement != null)
 593             tree.varargsElement = types.erasure(tree.varargsElement);
 594         else
 595             assert tree.args.length() == argtypes.length();
 596         tree.args = translateArgs(tree.args, argtypes, tree.varargsElement);
 597 
 598         // Insert casts of method invocation results as needed.
 599         result = retype(tree, mt.getReturnType(), pt);
 600     }
 601 
 602     public void visitNewClass(JCNewClass tree) {
 603         if (tree.encl != null)
 604             tree.encl = translate(tree.encl, erasure(tree.encl.type));
 605         tree.clazz = translate(tree.clazz, null);
 606         if (tree.varargsElement != null)
 607             tree.varargsElement = types.erasure(tree.varargsElement);
 608         tree.args = translateArgs(
 609             tree.args, tree.constructor.erasure(types).getParameterTypes(), tree.varargsElement);
 610         tree.def = translate(tree.def, null);
 611         tree.type = erasure(tree.type);
 612         result = tree;
 613     }
 614 
 615     public void visitNewArray(JCNewArray tree) {
 616         tree.elemtype = translate(tree.elemtype, null);
 617         translate(tree.dims, syms.intType);
 618         if (tree.type != null) {
 619             tree.elems = translate(tree.elems, erasure(types.elemtype(tree.type)));
 620             tree.type = erasure(tree.type);
 621         } else {
 622             tree.elems = translate(tree.elems, null);
 623         }
 624 
 625         result = tree;
 626     }
 627 
 628     public void visitParens(JCParens tree) {
 629         tree.expr = translate(tree.expr, pt);
 630         tree.type = erasure(tree.type);
 631         result = tree;
 632     }
 633 
 634     public void visitAssign(JCAssign tree) {
 635         tree.lhs = translate(tree.lhs, null);
 636         tree.rhs = translate(tree.rhs, erasure(tree.lhs.type));
 637         tree.type = erasure(tree.type);
 638         result = tree;
 639     }
 640 
 641     public void visitAssignop(JCAssignOp tree) {
 642         tree.lhs = translate(tree.lhs, null);
 643         tree.rhs = translate(tree.rhs, tree.operator.type.getParameterTypes().tail.head);
 644         tree.type = erasure(tree.type);
 645         result = tree;
 646     }
 647 
 648     public void visitUnary(JCUnary tree) {
 649         tree.arg = translate(tree.arg, tree.operator.type.getParameterTypes().head);
 650         result = tree;
 651     }
 652 
 653     public void visitBinary(JCBinary tree) {
 654         tree.lhs = translate(tree.lhs, tree.operator.type.getParameterTypes().head);
 655         tree.rhs = translate(tree.rhs, tree.operator.type.getParameterTypes().tail.head);
 656         result = tree;
 657     }
 658 
 659     public void visitTypeCast(JCTypeCast tree) {
 660         tree.clazz = translate(tree.clazz, null);
 661         tree.type = erasure(tree.type);
 662         tree.expr = translate(tree.expr, tree.type);
 663         result = tree;
 664     }
 665 
 666     public void visitTypeTest(JCInstanceOf tree) {
 667         tree.expr = translate(tree.expr, null);
 668         tree.clazz = translate(tree.clazz, null);
 669         result = tree;
 670     }
 671 
 672     public void visitIndexed(JCArrayAccess tree) {
 673         tree.indexed = translate(tree.indexed, erasure(tree.indexed.type));
 674         tree.index = translate(tree.index, syms.intType);
 675 
 676         // Insert casts of indexed expressions as needed.
 677         result = retype(tree, types.elemtype(tree.indexed.type), pt);
 678     }
 679 
 680     // There ought to be nothing to rewrite here;
 681     // we don't generate code.
 682     public void visitAnnotation(JCAnnotation tree) {
 683         result = tree;
 684     }
 685 
 686     public void visitIdent(JCIdent tree) {
 687         Type et = tree.sym.erasure(types);
 688 
 689         // Map type variables to their bounds.
 690         if (tree.sym.kind == TYP && tree.sym.type.tag == TYPEVAR) {
 691             result = make.at(tree.pos).Type(et);
 692         } else
 693         // Map constants expressions to themselves.
 694         if (tree.type.constValue() != null) {
 695             result = tree;
 696         }
 697         // Insert casts of variable uses as needed.
 698         else if (tree.sym.kind == VAR) {
 699             result = retype(tree, et, pt);
 700         }
 701         else {
 702             tree.type = erasure(tree.type);
 703             result = tree;
 704         }
 705     }
 706 
 707     public void visitSelect(JCFieldAccess tree) {
 708         Type t = tree.selected.type;
 709         while (t.tag == TYPEVAR)
 710             t = t.getUpperBound();
 711         if (t.isCompound()) {
 712             if ((tree.sym.flags() & IPROXY) != 0) {
 713                 tree.sym = ((MethodSymbol)tree.sym).
 714                     implemented((TypeSymbol)tree.sym.owner, types);
 715             }
 716             tree.selected = cast(
 717                 translate(tree.selected, erasure(tree.selected.type)),
 718                 erasure(tree.sym.owner.type));
 719         } else
 720             tree.selected = translate(tree.selected, erasure(t));
 721 
 722         // Map constants expressions to themselves.
 723         if (tree.type.constValue() != null) {
 724             result = tree;
 725         }
 726         // Insert casts of variable uses as needed.
 727         else if (tree.sym.kind == VAR) {
 728             result = retype(tree, tree.sym.erasure(types), pt);
 729         }
 730         else {
 731             tree.type = erasure(tree.type);
 732             result = tree;
 733         }
 734     }
 735 
 736     public void visitTypeArray(JCArrayTypeTree tree) {
 737         tree.elemtype = translate(tree.elemtype, null);
 738         tree.type = erasure(tree.type);
 739         result = tree;
 740     }
 741 
 742     /** Visitor method for parameterized types.
 743      */
 744     public void visitTypeApply(JCTypeApply tree) {
 745         JCTree clazz = translate(tree.clazz, null);
 746         result = clazz;
 747     }
 748 
 749 /**************************************************************************
 750  * utility methods
 751  *************************************************************************/
 752 
 753     private Type erasure(Type t) {
 754         return types.erasure(t);
 755     }
 756 
 757 /**************************************************************************
 758  * main method
 759  *************************************************************************/
 760 
 761     private Env<AttrContext> env;
 762 
 763     void translateClass(ClassSymbol c) {
 764         Type st = types.supertype(c.type);
 765 
 766         // process superclass before derived
 767         if (st.tag == CLASS)
 768             translateClass((ClassSymbol)st.tsym);
 769 
 770         Env<AttrContext> myEnv = enter.typeEnvs.remove(c);
 771         if (myEnv == null)
 772             return;
 773         Env<AttrContext> oldEnv = env;
 774         try {
 775             env = myEnv;
 776             // class has not been translated yet
 777 
 778             TreeMaker savedMake = make;
 779             Type savedPt = pt;
 780             make = make.forToplevel(env.toplevel);
 781             pt = null;
 782             try {
 783                 JCClassDecl tree = (JCClassDecl) env.tree;
 784                 tree.typarams = List.nil();
 785                 super.visitClassDef(tree);
 786                 make.at(tree.pos);
 787                 if (addBridges) {
 788                     ListBuffer<JCTree> bridges = new ListBuffer<JCTree>();
 789                     if ((tree.sym.flags() & INTERFACE) == 0)
 790                         addBridges(tree.pos(), tree.sym, bridges);
 791                     tree.defs = bridges.toList().prependList(tree.defs);
 792                 }
 793                 tree.type = erasure(tree.type);
 794             } finally {
 795                 make = savedMake;
 796                 pt = savedPt;
 797             }
 798         } finally {
 799             env = oldEnv;
 800         }
 801     }
 802 
 803     /** Translate a toplevel class definition.
 804      *  @param cdef    The definition to be translated.
 805      */
 806     public JCTree translateTopLevelClass(JCTree cdef, TreeMaker make) {
 807         // note that this method does NOT support recursion.
 808         this.make = make;
 809         pt = null;
 810         return translate(cdef, null);
 811     }
 812 }