1 /*
   2  * Copyright (c) 1999, 2018, 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 com.sun.tools.javac.code.*;
  31 import com.sun.tools.javac.code.Attribute.TypeCompound;
  32 import com.sun.tools.javac.code.Source.Feature;
  33 import com.sun.tools.javac.code.Symbol.*;
  34 import com.sun.tools.javac.code.Type.IntersectionClassType;
  35 import com.sun.tools.javac.code.Types.FunctionDescriptorLookupError;
  36 import com.sun.tools.javac.resources.CompilerProperties.Errors;
  37 import com.sun.tools.javac.tree.*;
  38 import com.sun.tools.javac.tree.JCTree.*;
  39 import com.sun.tools.javac.tree.JCTree.JCMemberReference.ReferenceKind;
  40 import com.sun.tools.javac.util.*;
  41 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
  42 import com.sun.tools.javac.util.List;
  43 
  44 import static com.sun.tools.javac.code.Flags.*;
  45 import static com.sun.tools.javac.code.Kinds.Kind.*;
  46 import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
  47 import static com.sun.tools.javac.code.TypeTag.CLASS;
  48 import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
  49 import static com.sun.tools.javac.code.TypeTag.VOID;
  50 import static com.sun.tools.javac.comp.CompileStates.CompileState;
  51 
  52 /** This pass translates Generic Java to conventional Java.
  53  *
  54  *  <p><b>This is NOT part of any supported API.
  55  *  If you write code that depends on this, you do so at your own risk.
  56  *  This code and its internal interfaces are subject to change or
  57  *  deletion without notice.</b>
  58  */
  59 public class TransTypes extends TreeTranslator {
  60     /** The context key for the TransTypes phase. */
  61     protected static final Context.Key<TransTypes> transTypesKey = new Context.Key<>();
  62 
  63     /** Get the instance for this context. */
  64     public static TransTypes instance(Context context) {
  65         TransTypes instance = context.get(transTypesKey);
  66         if (instance == null)
  67             instance = new TransTypes(context);
  68         return instance;
  69     }
  70 
  71     private Names names;
  72     private Log log;
  73     private Symtab syms;
  74     private TreeMaker make;
  75     private Enter enter;
  76     private Types types;
  77     private Annotate annotate;
  78     private Attr attr;
  79     private final Resolve resolve;
  80     private final CompileStates compileStates;
  81 
  82     /** Switch: is complex graph inference supported? */
  83     private final boolean allowGraphInference;
  84 
  85     /** Switch: are default methods supported? */
  86     private final boolean allowInterfaceBridges;
  87 
  88     protected TransTypes(Context context) {
  89         context.put(transTypesKey, this);
  90         compileStates = CompileStates.instance(context);
  91         names = Names.instance(context);
  92         log = Log.instance(context);
  93         syms = Symtab.instance(context);
  94         enter = Enter.instance(context);
  95         types = Types.instance(context);
  96         make = TreeMaker.instance(context);
  97         resolve = Resolve.instance(context);
  98         Source source = Source.instance(context);
  99         allowInterfaceBridges = Feature.DEFAULT_METHODS.allowedInSource(source);
 100         allowGraphInference = Feature.GRAPH_INFERENCE.allowedInSource(source);
 101         annotate = Annotate.instance(context);
 102         attr = Attr.instance(context);
 103     }
 104 
 105     /** Construct an attributed tree for a cast of expression to target type,
 106      *  unless it already has precisely that type.
 107      *  @param tree    The expression tree.
 108      *  @param target  The target type.
 109      */
 110     JCExpression cast(JCExpression tree, Type target) {
 111         int oldpos = make.pos;
 112         make.at(tree.pos);
 113         if (!types.isSameType(tree.type, target)) {
 114             if (!resolve.isAccessible(env, target.tsym))
 115                 resolve.logAccessErrorInternal(env, tree, target);
 116             tree = make.TypeCast(make.Type(target), tree).setType(target);
 117         }
 118         make.pos = oldpos;
 119         return tree;
 120     }
 121 
 122     /** Construct an attributed tree to coerce an expression to some erased
 123      *  target type, unless the expression is already assignable to that type.
 124      *  If target type is a constant type, use its base type instead.
 125      *  @param tree    The expression tree.
 126      *  @param target  The target type.
 127      */
 128     public JCExpression coerce(Env<AttrContext> env, JCExpression tree, Type target) {
 129         Env<AttrContext> prevEnv = this.env;
 130         try {
 131             this.env = env;
 132             return coerce(tree, target);
 133         }
 134         finally {
 135             this.env = prevEnv;
 136         }
 137     }
 138     JCExpression coerce(JCExpression tree, Type target) {
 139         Type btarget = target.baseType();
 140         if (tree.type.isPrimitive() == target.isPrimitive()) {
 141             return types.isAssignable(tree.type, btarget, types.noWarnings)
 142                 ? tree
 143                 : cast(tree, btarget);
 144         }
 145         return tree;
 146     }
 147 
 148     /** Given an erased reference type, assume this type as the tree's type.
 149      *  Then, coerce to some given target type unless target type is null.
 150      *  This operation is used in situations like the following:
 151      *
 152      *  <pre>{@code
 153      *  class Cell<A> { A value; }
 154      *  ...
 155      *  Cell<Integer> cell;
 156      *  Integer x = cell.value;
 157      *  }</pre>
 158      *
 159      *  Since the erasure of Cell.value is Object, but the type
 160      *  of cell.value in the assignment is Integer, we need to
 161      *  adjust the original type of cell.value to Object, and insert
 162      *  a cast to Integer. That is, the last assignment becomes:
 163      *
 164      *  <pre>{@code
 165      *  Integer x = (Integer)cell.value;
 166      *  }</pre>
 167      *
 168      *  @param tree       The expression tree whose type might need adjustment.
 169      *  @param erasedType The expression's type after erasure.
 170      *  @param target     The target type, which is usually the erasure of the
 171      *                    expression's original type.
 172      */
 173     JCExpression retype(JCExpression tree, Type erasedType, Type target) {
 174 //      System.err.println("retype " + tree + " to " + erasedType);//DEBUG
 175         if (!erasedType.isPrimitive()) {
 176             if (target != null && target.isPrimitive()) {
 177                 target = erasure(tree.type);
 178             }
 179             tree.type = erasedType;
 180             if (target != null) {
 181                 return coerce(tree, target);
 182             }
 183         }
 184         return tree;
 185     }
 186 
 187     /** Translate method argument list, casting each argument
 188      *  to its corresponding type in a list of target types.
 189      *  @param _args            The method argument list.
 190      *  @param parameters       The list of target types.
 191      *  @param varargsElement   The erasure of the varargs element type,
 192      *  or null if translating a non-varargs invocation
 193      */
 194     <T extends JCTree> List<T> translateArgs(List<T> _args,
 195                                            List<Type> parameters,
 196                                            Type varargsElement) {
 197         if (parameters.isEmpty()) return _args;
 198         List<T> args = _args;
 199         while (parameters.tail.nonEmpty()) {
 200             args.head = translate(args.head, parameters.head);
 201             args = args.tail;
 202             parameters = parameters.tail;
 203         }
 204         Type parameter = parameters.head;
 205         Assert.check(varargsElement != null || args.length() == 1);
 206         if (varargsElement != null) {
 207             while (args.nonEmpty()) {
 208                 args.head = translate(args.head, varargsElement);
 209                 args = args.tail;
 210             }
 211         } else {
 212             args.head = translate(args.head, parameter);
 213         }
 214         return _args;
 215     }
 216 
 217     public <T extends JCTree> List<T> translateArgs(List<T> _args,
 218                                            List<Type> parameters,
 219                                            Type varargsElement,
 220                                            Env<AttrContext> localEnv) {
 221         Env<AttrContext> prevEnv = env;
 222         try {
 223             env = localEnv;
 224             return translateArgs(_args, parameters, varargsElement);
 225         }
 226         finally {
 227             env = prevEnv;
 228         }
 229     }
 230 
 231     /** Add a bridge definition and enter corresponding method symbol in
 232      *  local scope of origin.
 233      *
 234      *  @param pos     The source code position to be used for the definition.
 235      *  @param meth    The method for which a bridge needs to be added
 236      *  @param impl    That method's implementation (possibly the method itself)
 237      *  @param origin  The class to which the bridge will be added
 238      *  @param bridges The list buffer to which the bridge will be added
 239      */
 240     void addBridge(DiagnosticPosition pos,
 241                    MethodSymbol meth,
 242                    MethodSymbol impl,
 243                    ClassSymbol origin,
 244                    ListBuffer<JCTree> bridges) {
 245         make.at(pos);
 246         Type implTypeErasure = erasure(impl.type);
 247 
 248         // Create a bridge method symbol and a bridge definition without a body.
 249         Type bridgeType = meth.erasure(types);
 250         long flags = impl.flags() & AccessFlags | SYNTHETIC | BRIDGE |
 251                 (origin.isInterface() ? DEFAULT : 0);
 252         MethodSymbol bridge = new MethodSymbol(flags,
 253                                                meth.name,
 254                                                bridgeType,
 255                                                origin);
 256         /* once JDK-6996415 is solved it should be checked if this approach can
 257          * be applied to method addOverrideBridgesIfNeeded
 258          */
 259         bridge.params = createBridgeParams(impl, bridge, bridgeType);
 260         bridge.setAttributes(impl);
 261 
 262         JCMethodDecl md = make.MethodDef(bridge, null);
 263 
 264         // The bridge calls this.impl(..), if we have an implementation
 265         // in the current class, super.impl(...) otherwise.
 266         JCExpression receiver = (impl.owner == origin)
 267             ? make.This(origin.erasure(types))
 268             : make.Super(types.supertype(origin.type).tsym.erasure(types), origin);
 269 
 270         // The type returned from the original method.
 271         Type calltype = implTypeErasure.getReturnType();
 272 
 273         // Construct a call of  this.impl(params), or super.impl(params),
 274         // casting params and possibly results as needed.
 275         JCExpression call =
 276             make.Apply(
 277                        null,
 278                        make.Select(receiver, impl).setType(calltype),
 279                        translateArgs(make.Idents(md.params), implTypeErasure.getParameterTypes(), null))
 280             .setType(calltype);
 281         JCStatement stat = (implTypeErasure.getReturnType().hasTag(VOID))
 282             ? make.Exec(call)
 283             : make.Return(coerce(call, bridgeType.getReturnType()));
 284         md.body = make.Block(0, List.of(stat));
 285 
 286         // Add bridge to `bridges' buffer
 287         bridges.append(md);
 288 
 289         // Add bridge to scope of enclosing class and keep track of the bridge span.
 290         origin.members().enter(bridge);
 291     }
 292 
 293     private List<VarSymbol> createBridgeParams(MethodSymbol impl, MethodSymbol bridge,
 294             Type bridgeType) {
 295         List<VarSymbol> bridgeParams = null;
 296         if (impl.params != null) {
 297             bridgeParams = List.nil();
 298             List<VarSymbol> implParams = impl.params;
 299             Type.MethodType mType = (Type.MethodType)bridgeType;
 300             List<Type> argTypes = mType.argtypes;
 301             while (implParams.nonEmpty() && argTypes.nonEmpty()) {
 302                 VarSymbol param = new VarSymbol(implParams.head.flags() | SYNTHETIC | PARAMETER,
 303                         implParams.head.name, argTypes.head, bridge);
 304                 param.setAttributes(implParams.head);
 305                 bridgeParams = bridgeParams.append(param);
 306                 implParams = implParams.tail;
 307                 argTypes = argTypes.tail;
 308             }
 309         }
 310         return bridgeParams;
 311     }
 312 
 313     /** Add bridge if given symbol is a non-private, non-static member
 314      *  of the given class, which is either defined in the class or non-final
 315      *  inherited, and one of the two following conditions holds:
 316      *  1. The method's type changes in the given class, as compared to the
 317      *     class where the symbol was defined, (in this case
 318      *     we have extended a parameterized class with non-trivial parameters).
 319      *  2. The method has an implementation with a different erased return type.
 320      *     (in this case we have used co-variant returns).
 321      *  If a bridge already exists in some other class, no new bridge is added.
 322      *  Instead, it is checked that the bridge symbol overrides the method symbol.
 323      *  (Spec ???).
 324      *  todo: what about bridges for privates???
 325      *
 326      *  @param pos     The source code position to be used for the definition.
 327      *  @param sym     The symbol for which a bridge might have to be added.
 328      *  @param origin  The class in which the bridge would go.
 329      *  @param bridges The list buffer to which the bridge would be added.
 330      */
 331     void addBridgeIfNeeded(DiagnosticPosition pos,
 332                            Symbol sym,
 333                            ClassSymbol origin,
 334                            ListBuffer<JCTree> bridges) {
 335         if (sym.kind == MTH &&
 336                 sym.name != names.init &&
 337                 (sym.flags() & (PRIVATE | STATIC)) == 0 &&
 338                 (sym.flags() & SYNTHETIC) != SYNTHETIC &&
 339                 sym.isMemberOf(origin, types)) {
 340             MethodSymbol meth = (MethodSymbol)sym;
 341             MethodSymbol bridge = meth.binaryImplementation(origin, types);
 342             MethodSymbol impl = meth.implementation(origin, types, true);
 343             if (bridge == null ||
 344                 bridge == meth ||
 345                 (impl != null && !bridge.owner.isSubClass(impl.owner, types))) {
 346                 // No bridge was added yet.
 347                 if (impl != null && bridge != impl && isBridgeNeeded(meth, impl, origin.type)) {
 348                     addBridge(pos, meth, impl, origin, bridges);
 349                 } else if (impl == meth
 350                            && impl.owner != origin
 351                            && (impl.flags() & FINAL) == 0
 352                            && (meth.flags() & (ABSTRACT|PUBLIC)) == PUBLIC
 353                            && (origin.flags() & PUBLIC) > (impl.owner.flags() & PUBLIC)) {
 354                     // this is to work around a horrible but permanent
 355                     // reflection design error.
 356                     addBridge(pos, meth, impl, origin, bridges);
 357                 }
 358             }
 359         }
 360     }
 361     // where
 362 
 363         /**
 364          * @param method The symbol for which a bridge might have to be added
 365          * @param impl The implementation of method
 366          * @param dest The type in which the bridge would go
 367          */
 368         private boolean isBridgeNeeded(MethodSymbol method,
 369                                        MethodSymbol impl,
 370                                        Type dest) {
 371             if (impl != method) {
 372                 // If either method or impl have different erasures as
 373                 // members of dest, a bridge is needed.
 374                 Type method_erasure = method.erasure(types);
 375                 if (!isSameMemberWhenErased(dest, method, method_erasure))
 376                     return true;
 377                 Type impl_erasure = impl.erasure(types);
 378                 if (!isSameMemberWhenErased(dest, impl, impl_erasure))
 379                     return true;
 380 
 381                 /* Bottom line: A bridge is needed if the erasure of the implementation
 382                    is different from that of the method that it overrides.
 383                 */
 384                 return !types.isSameType(impl_erasure, method_erasure);
 385             } else {
 386                // method and impl are the same...
 387                 if ((method.flags() & ABSTRACT) != 0) {
 388                     // ...and abstract so a bridge is not needed.
 389                     // Concrete subclasses will bridge as needed.
 390                     return false;
 391                 }
 392 
 393                 // The erasure of the return type is always the same
 394                 // for the same symbol.  Reducing the three tests in
 395                 // the other branch to just one:
 396                 return !isSameMemberWhenErased(dest, method, method.erasure(types));
 397             }
 398         }
 399         /**
 400          * Lookup the method as a member of the type.  Compare the
 401          * erasures.
 402          * @param type the class where to look for the method
 403          * @param method the method to look for in class
 404          * @param erasure the erasure of method
 405          */
 406         private boolean isSameMemberWhenErased(Type type,
 407                                                MethodSymbol method,
 408                                                Type erasure) {
 409             return types.isSameType(erasure(types.memberType(type, method)),
 410                                     erasure);
 411         }
 412 
 413     void addBridges(DiagnosticPosition pos,
 414                     TypeSymbol i,
 415                     ClassSymbol origin,
 416                     ListBuffer<JCTree> bridges) {
 417         for (Symbol sym : i.members().getSymbols(NON_RECURSIVE))
 418             addBridgeIfNeeded(pos, sym, origin, bridges);
 419         for (List<Type> l = types.interfaces(i.type); l.nonEmpty(); l = l.tail)
 420             addBridges(pos, l.head.tsym, origin, bridges);
 421     }
 422 
 423     /** Add all necessary bridges to some class appending them to list buffer.
 424      *  @param pos     The source code position to be used for the bridges.
 425      *  @param origin  The class in which the bridges go.
 426      *  @param bridges The list buffer to which the bridges are added.
 427      */
 428     void addBridges(DiagnosticPosition pos, ClassSymbol origin, ListBuffer<JCTree> bridges) {
 429         Type st = types.supertype(origin.type);
 430         while (st.hasTag(CLASS)) {
 431 //          if (isSpecialization(st))
 432             addBridges(pos, st.tsym, origin, bridges);
 433             st = types.supertype(st);
 434         }
 435         for (List<Type> l = types.interfaces(origin.type); l.nonEmpty(); l = l.tail)
 436 //          if (isSpecialization(l.head))
 437             addBridges(pos, l.head.tsym, origin, bridges);
 438     }
 439 
 440 /* ************************************************************************
 441  * Visitor methods
 442  *************************************************************************/
 443 
 444     /** Visitor argument: proto-type.
 445      */
 446     private Type pt;
 447 
 448     /** Visitor method: perform a type translation on tree.
 449      */
 450     public <T extends JCTree> T translate(T tree, Type pt) {
 451         Type prevPt = this.pt;
 452         try {
 453             this.pt = pt;
 454             return translate(tree);
 455         } finally {
 456             this.pt = prevPt;
 457         }
 458     }
 459 
 460     /** Visitor method: perform a type translation on list of trees.
 461      */
 462     public <T extends JCTree> List<T> translate(List<T> trees, Type pt) {
 463         Type prevPt = this.pt;
 464         List<T> res;
 465         try {
 466             this.pt = pt;
 467             res = translate(trees);
 468         } finally {
 469             this.pt = prevPt;
 470         }
 471         return res;
 472     }
 473 
 474     public void visitClassDef(JCClassDecl tree) {
 475         translateClass(tree.sym);
 476         result = tree;
 477     }
 478 
 479     Type returnType = null;
 480     public void visitMethodDef(JCMethodDecl tree) {
 481         Type prevRetType = returnType;
 482         try {
 483             returnType = erasure(tree.type).getReturnType();
 484             tree.restype = translate(tree.restype, null);
 485             tree.typarams = List.nil();
 486             tree.params = translateVarDefs(tree.params);
 487             tree.recvparam = translate(tree.recvparam, null);
 488             tree.thrown = translate(tree.thrown, null);
 489             tree.body = translate(tree.body, tree.sym.erasure(types).getReturnType());
 490             tree.type = erasure(tree.type);
 491             result = tree;
 492         } finally {
 493             returnType = prevRetType;
 494         }
 495     }
 496 
 497     public void visitVarDef(JCVariableDecl tree) {
 498         tree.vartype = translate(tree.vartype, null);
 499         tree.init = translate(tree.init, tree.sym.erasure(types));
 500         tree.type = erasure(tree.type);
 501         result = tree;
 502     }
 503 
 504     public void visitDoLoop(JCDoWhileLoop tree) {
 505         tree.body = translate(tree.body);
 506         tree.cond = translate(tree.cond, syms.booleanType);
 507         result = tree;
 508     }
 509 
 510     public void visitWhileLoop(JCWhileLoop tree) {
 511         tree.cond = translate(tree.cond, syms.booleanType);
 512         tree.body = translate(tree.body);
 513         result = tree;
 514     }
 515 
 516     public void visitForLoop(JCForLoop tree) {
 517         tree.init = translate(tree.init, null);
 518         if (tree.cond != null)
 519             tree.cond = translate(tree.cond, syms.booleanType);
 520         tree.step = translate(tree.step, null);
 521         tree.body = translate(tree.body);
 522         result = tree;
 523     }
 524 
 525     public void visitForeachLoop(JCEnhancedForLoop tree) {
 526         tree.var = translate(tree.var, null);
 527         Type iterableType = tree.expr.type;
 528         tree.expr = translate(tree.expr, erasure(tree.expr.type));
 529         if (types.elemtype(tree.expr.type) == null)
 530             tree.expr.type = iterableType; // preserve type for Lower
 531         tree.body = translate(tree.body);
 532         result = tree;
 533     }
 534 
 535     public void visitLambda(JCLambda tree) {
 536         Type prevRetType = returnType;
 537         try {
 538             returnType = erasure(tree.getDescriptorType(types)).getReturnType();
 539             tree.params = translate(tree.params);
 540             tree.body = translate(tree.body, tree.body.type == null || returnType.hasTag(VOID) ? null : returnType);
 541             if (!tree.type.isIntersection()) {
 542                 tree.type = erasure(tree.type);
 543             } else {
 544                 tree.type = types.erasure(types.findDescriptorSymbol(tree.type.tsym).owner.type);
 545             }
 546             result = tree;
 547         }
 548         finally {
 549             returnType = prevRetType;
 550         }
 551     }
 552 
 553     public void visitSwitch(JCSwitch tree) {
 554         Type selsuper = types.supertype(tree.selector.type);
 555         boolean enumSwitch = selsuper != null &&
 556             selsuper.tsym == syms.enumSym;
 557         Type target = enumSwitch ? erasure(tree.selector.type) : syms.intType;
 558         tree.selector = translate(tree.selector, target);
 559         tree.cases = translateCases(tree.cases);
 560         result = tree;
 561     }
 562 
 563     public void visitCase(JCCase tree) {
 564         tree.pat = translate(tree.pat, null);
 565         tree.stats = translate(tree.stats);
 566         result = tree;
 567     }
 568 
 569     public void visitSynchronized(JCSynchronized tree) {
 570         tree.lock = translate(tree.lock, erasure(tree.lock.type));
 571         tree.body = translate(tree.body);
 572         result = tree;
 573     }
 574 
 575     public void visitTry(JCTry tree) {
 576         tree.resources = translate(tree.resources, syms.autoCloseableType);
 577         tree.body = translate(tree.body);
 578         tree.catchers = translateCatchers(tree.catchers);
 579         tree.finalizer = translate(tree.finalizer);
 580         result = tree;
 581     }
 582 
 583     public void visitConditional(JCConditional tree) {
 584         tree.cond = translate(tree.cond, syms.booleanType);
 585         tree.truepart = translate(tree.truepart, erasure(tree.type));
 586         tree.falsepart = translate(tree.falsepart, erasure(tree.type));
 587         tree.type = erasure(tree.type);
 588         result = retype(tree, tree.type, pt);
 589     }
 590 
 591    public void visitIf(JCIf tree) {
 592         tree.cond = translate(tree.cond, syms.booleanType);
 593         tree.thenpart = translate(tree.thenpart);
 594         tree.elsepart = translate(tree.elsepart);
 595         result = tree;
 596     }
 597 
 598     public void visitExec(JCExpressionStatement tree) {
 599         tree.expr = translate(tree.expr, null);
 600         result = tree;
 601     }
 602 
 603     public void visitReturn(JCReturn tree) {
 604         if (!returnType.hasTag(VOID))
 605             tree.expr = translate(tree.expr, returnType);
 606         result = tree;
 607     }
 608 
 609     public void visitThrow(JCThrow tree) {
 610         tree.expr = translate(tree.expr, erasure(tree.expr.type));
 611         result = tree;
 612     }
 613 
 614     public void visitAssert(JCAssert tree) {
 615         tree.cond = translate(tree.cond, syms.booleanType);
 616         if (tree.detail != null)
 617             tree.detail = translate(tree.detail, erasure(tree.detail.type));
 618         result = tree;
 619     }
 620 
 621     public void visitApply(JCMethodInvocation tree) {
 622         tree.meth = translate(tree.meth, null);
 623         Symbol meth = TreeInfo.symbol(tree.meth);
 624         Type mt = meth.erasure(types);
 625         boolean useInstantiatedPtArgs =
 626                 allowGraphInference && !types.isSignaturePolymorphic((MethodSymbol)meth.baseSymbol());
 627         List<Type> argtypes = useInstantiatedPtArgs ?
 628                 tree.meth.type.getParameterTypes() :
 629                 mt.getParameterTypes();
 630         if (meth.name == names.init && meth.owner == syms.enumSym)
 631             argtypes = argtypes.tail.tail;
 632         if (tree.varargsElement != null)
 633             tree.varargsElement = types.erasure(tree.varargsElement);
 634         else
 635             if (tree.args.length() != argtypes.length()) {
 636                 Assert.error(String.format("Incorrect number of arguments; expected %d, found %d",
 637                         tree.args.length(), argtypes.length()));
 638             }
 639         tree.args = translateArgs(tree.args, argtypes, tree.varargsElement);
 640 
 641         tree.type = types.erasure(tree.type);
 642         // Insert casts of method invocation results as needed.
 643         result = retype(tree, mt.getReturnType(), pt);
 644     }
 645 
 646     public void visitNewClass(JCNewClass tree) {
 647         if (tree.encl != null) {
 648             if (tree.def == null) {
 649                 tree.encl = translate(tree.encl, erasure(tree.encl.type));
 650             } else {
 651                 tree.args = tree.args.prepend(attr.makeNullCheck(tree.encl));
 652                 tree.encl = null;
 653             }
 654         }
 655 
 656         Type erasedConstructorType = tree.constructorType != null ?
 657                 erasure(tree.constructorType) :
 658                 null;
 659 
 660         List<Type> argtypes = erasedConstructorType != null && allowGraphInference ?
 661                 erasedConstructorType.getParameterTypes() :
 662                 tree.constructor.erasure(types).getParameterTypes();
 663 
 664         tree.clazz = translate(tree.clazz, null);
 665         if (tree.varargsElement != null)
 666             tree.varargsElement = types.erasure(tree.varargsElement);
 667         tree.args = translateArgs(
 668             tree.args, argtypes, tree.varargsElement);
 669         tree.def = translate(tree.def, null);
 670         if (erasedConstructorType != null)
 671             tree.constructorType = erasedConstructorType;
 672         tree.type = erasure(tree.type);
 673         result = tree;
 674     }
 675 
 676     public void visitNewArray(JCNewArray tree) {
 677         tree.elemtype = translate(tree.elemtype, null);
 678         translate(tree.dims, syms.intType);
 679         if (tree.type != null) {
 680             tree.elems = translate(tree.elems, erasure(types.elemtype(tree.type)));
 681             tree.type = erasure(tree.type);
 682         } else {
 683             tree.elems = translate(tree.elems, null);
 684         }
 685 
 686         result = tree;
 687     }
 688 
 689     public void visitParens(JCParens tree) {
 690         tree.expr = translate(tree.expr, pt);
 691         tree.type = erasure(tree.expr.type);
 692         result = tree;
 693     }
 694 
 695     public void visitAssign(JCAssign tree) {
 696         tree.lhs = translate(tree.lhs, null);
 697         tree.rhs = translate(tree.rhs, erasure(tree.lhs.type));
 698         tree.type = erasure(tree.lhs.type);
 699         result = retype(tree, tree.type, pt);
 700     }
 701 
 702     public void visitAssignop(JCAssignOp tree) {
 703         tree.lhs = translate(tree.lhs, null);
 704         tree.rhs = translate(tree.rhs, tree.operator.type.getParameterTypes().tail.head);
 705         tree.type = erasure(tree.type);
 706         result = tree;
 707     }
 708 
 709     public void visitUnary(JCUnary tree) {
 710         tree.arg = translate(tree.arg, (tree.getTag() == Tag.NULLCHK)
 711             ? tree.type
 712             : tree.operator.type.getParameterTypes().head);
 713         result = tree;
 714     }
 715 
 716     public void visitBinary(JCBinary tree) {
 717         tree.lhs = translate(tree.lhs, tree.operator.type.getParameterTypes().head);
 718         tree.rhs = translate(tree.rhs, tree.operator.type.getParameterTypes().tail.head);
 719         result = tree;
 720     }
 721 
 722     public void visitAnnotatedType(JCAnnotatedType tree) {
 723         // For now, we need to keep the annotations in the tree because of the current
 724         // MultiCatch implementation wrt type annotations
 725         List<TypeCompound> mirrors = annotate.fromAnnotations(tree.annotations);
 726         tree.underlyingType = translate(tree.underlyingType);
 727         tree.type = tree.underlyingType.type.annotatedType(mirrors);
 728         result = tree;
 729     }
 730 
 731     public void visitTypeCast(JCTypeCast tree) {
 732         tree.clazz = translate(tree.clazz, null);
 733         Type originalTarget = tree.type;
 734         tree.type = erasure(tree.type);
 735         JCExpression newExpression = translate(tree.expr, tree.type);
 736         if (newExpression != tree.expr) {
 737             JCTypeCast typeCast = newExpression.hasTag(Tag.TYPECAST)
 738                 ? (JCTypeCast) newExpression
 739                 : null;
 740             tree.expr = typeCast != null && types.isSameType(typeCast.type, originalTarget)
 741                 ? typeCast.expr
 742                 : newExpression;
 743         }
 744         if (originalTarget.isIntersection()) {
 745             Type.IntersectionClassType ict = (Type.IntersectionClassType)originalTarget;
 746             for (Type c : ict.getExplicitComponents()) {
 747                 Type ec = erasure(c);
 748                 if (!types.isSameType(ec, tree.type)) {
 749                     tree.expr = coerce(tree.expr, ec);
 750                 }
 751             }
 752         }
 753         result = tree;
 754     }
 755 
 756     public void visitTypeTest(JCInstanceOf tree) {
 757         tree.expr = translate(tree.expr, null);
 758         tree.clazz = translate(tree.clazz, null);
 759         result = tree;
 760     }
 761 
 762     public void visitIndexed(JCArrayAccess tree) {
 763         tree.indexed = translate(tree.indexed, erasure(tree.indexed.type));
 764         tree.index = translate(tree.index, syms.intType);
 765 
 766         // Insert casts of indexed expressions as needed.
 767         result = retype(tree, types.elemtype(tree.indexed.type), pt);
 768     }
 769 
 770     // There ought to be nothing to rewrite here;
 771     // we don't generate code.
 772     public void visitAnnotation(JCAnnotation tree) {
 773         result = tree;
 774     }
 775 
 776     public void visitIdent(JCIdent tree) {
 777         Type et = tree.sym.erasure(types);
 778 
 779         // Map type variables to their bounds.
 780         if (tree.sym.kind == TYP && tree.sym.type.hasTag(TYPEVAR)) {
 781             result = make.at(tree.pos).Type(et);
 782         } else
 783         // Map constants expressions to themselves.
 784         if (tree.type.constValue() != null) {
 785             result = tree;
 786         }
 787         // Insert casts of variable uses as needed.
 788         else if (tree.sym.kind == VAR) {
 789             result = retype(tree, et, pt);
 790         }
 791         else {
 792             tree.type = erasure(tree.type);
 793             result = tree;
 794         }
 795     }
 796 
 797     public void visitSelect(JCFieldAccess tree) {
 798         Type t = types.skipTypeVars(tree.selected.type, false);
 799         if (t.isCompound()) {
 800             tree.selected = coerce(
 801                 translate(tree.selected, erasure(tree.selected.type)),
 802                 erasure(tree.sym.owner.type));
 803         } else
 804             tree.selected = translate(tree.selected, erasure(t));
 805 
 806         // Map constants expressions to themselves.
 807         if (tree.type.constValue() != null) {
 808             result = tree;
 809         }
 810         // Insert casts of variable uses as needed.
 811         else if (tree.sym.kind == VAR) {
 812             result = retype(tree, tree.sym.erasure(types), pt);
 813         }
 814         else {
 815             tree.type = erasure(tree.type);
 816             result = tree;
 817         }
 818     }
 819 
 820     public void visitReference(JCMemberReference tree) {
 821         Type t = types.skipTypeVars(tree.expr.type, false);
 822         Type receiverTarget = t.isCompound() ? erasure(tree.sym.owner.type) : erasure(t);
 823         if (tree.kind == ReferenceKind.UNBOUND) {
 824             tree.expr = make.Type(receiverTarget);
 825         } else {
 826             tree.expr = translate(tree.expr, receiverTarget);
 827         }
 828         if (!tree.type.isIntersection()) {
 829             tree.type = erasure(tree.type);
 830         } else {
 831             tree.type = types.erasure(types.findDescriptorSymbol(tree.type.tsym).owner.type);
 832         }
 833         if (tree.varargsElement != null)
 834             tree.varargsElement = erasure(tree.varargsElement);
 835         result = tree;
 836     }
 837 
 838     public void visitTypeArray(JCArrayTypeTree tree) {
 839         tree.elemtype = translate(tree.elemtype, null);
 840         tree.type = erasure(tree.type);
 841         result = tree;
 842     }
 843 
 844     /** Visitor method for parameterized types.
 845      */
 846     public void visitTypeApply(JCTypeApply tree) {
 847         JCTree clazz = translate(tree.clazz, null);
 848         result = clazz;
 849     }
 850 
 851     public void visitTypeIntersection(JCTypeIntersection tree) {
 852         tree.bounds = translate(tree.bounds, null);
 853         tree.type = erasure(tree.type);
 854         result = tree;
 855     }
 856 
 857 /**************************************************************************
 858  * utility methods
 859  *************************************************************************/
 860 
 861     private Type erasure(Type t) {
 862         return types.erasure(t);
 863     }
 864 
 865 /**************************************************************************
 866  * main method
 867  *************************************************************************/
 868 
 869     private Env<AttrContext> env;
 870 
 871     private static final String statePreviousToFlowAssertMsg =
 872             "The current compile state [%s] of class %s is previous to FLOW";
 873 
 874     void translateClass(ClassSymbol c) {
 875         Type st = types.supertype(c.type);
 876         // process superclass before derived
 877         if (st.hasTag(CLASS)) {
 878             translateClass((ClassSymbol)st.tsym);
 879         }
 880 
 881         Env<AttrContext> myEnv = enter.getEnv(c);
 882         if (myEnv == null || (c.flags_field & TYPE_TRANSLATED) != 0) {
 883             return;
 884         }
 885         c.flags_field |= TYPE_TRANSLATED;
 886 
 887         /*  The two assertions below are set for early detection of any attempt
 888          *  to translate a class that:
 889          *
 890          *  1) has no compile state being it the most outer class.
 891          *     We accept this condition for inner classes.
 892          *
 893          *  2) has a compile state which is previous to Flow state.
 894          */
 895         boolean envHasCompState = compileStates.get(myEnv) != null;
 896         if (!envHasCompState && c.outermostClass() == c) {
 897             Assert.error("No info for outermost class: " + myEnv.enclClass.sym);
 898         }
 899 
 900         if (envHasCompState &&
 901                 CompileState.FLOW.isAfter(compileStates.get(myEnv))) {
 902             Assert.error(String.format(statePreviousToFlowAssertMsg,
 903                     compileStates.get(myEnv), myEnv.enclClass.sym));
 904         }
 905 
 906         Env<AttrContext> oldEnv = env;
 907         try {
 908             env = myEnv;
 909             // class has not been translated yet
 910 
 911             TreeMaker savedMake = make;
 912             Type savedPt = pt;
 913             make = make.forToplevel(env.toplevel);
 914             pt = null;
 915             try {
 916                 JCClassDecl tree = (JCClassDecl) env.tree;
 917                 tree.typarams = List.nil();
 918                 super.visitClassDef(tree);
 919                 make.at(tree.pos);
 920                 ListBuffer<JCTree> bridges = new ListBuffer<>();
 921                 if (allowInterfaceBridges || (tree.sym.flags() & INTERFACE) == 0) {
 922                     addBridges(tree.pos(), c, bridges);
 923                 }
 924                 tree.defs = bridges.toList().prependList(tree.defs);
 925                 tree.type = erasure(tree.type);
 926             } finally {
 927                 make = savedMake;
 928                 pt = savedPt;
 929             }
 930         } finally {
 931             env = oldEnv;
 932         }
 933     }
 934 
 935     /** Translate a toplevel class definition.
 936      *  @param cdef    The definition to be translated.
 937      */
 938     public JCTree translateTopLevelClass(JCTree cdef, TreeMaker make) {
 939         // note that this method does NOT support recursion.
 940         this.make = make;
 941         pt = null;
 942         return translate(cdef, null);
 943     }
 944 }