jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java

equal deleted inserted replaced

-:3b3e23e67329
+:3651128c74eb
 *  If you write code that depends on this, you do so at your own risk.
 *  This code and its internal interfaces are subject to change or
 *  deletion without notice.</b>
 */
 public class DeferredAttr extends JCTree.Visitor {
-protected static final Context.Key<DeferredAttr> deferredAttrKey =
+protected static final Context.Key<DeferredAttr> deferredAttrKey = new Context.Key<>();
-new Context.Key<DeferredAttr>();
 final Attr attr;
 final Check chk;
 final JCDiagnostic.Factory diags;
 final Enter enter;
 * stores a pointer to the speculative tree and the resolution phase in which the entry
 * has been added.
 */
 class SpeculativeCache {
-private Map<Symbol, List<Entry>> cache =
+private Map<Symbol, List<Entry>> cache = new WeakHashMap<>();
-new WeakHashMap<Symbol, List<Entry>>();
 class Entry {
 JCTree speculativeTree;
 ResultInfo resultInfo;
 */
 SPECULATIVE,
 /**
 * This is the plain type-checking mode. Produces side-effects on the underlying AST node
 */
-CHECK;
+CHECK
 }
 /**
 * Routine that performs speculative type-checking; the input AST node is
 * cloned (to avoid side-effects cause by Attr) and compiler state is
 * restored after type-checking. All diagnostics (but critical ones) are
 * disabled during speculative type-checking.
 */
 JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
-final JCTree newTree = new TreeCopier<Object>(make).copy(tree);
+final JCTree newTree = new TreeCopier<>(make).copy(tree);
 Env<AttrContext> speculativeEnv = env.dup(newTree, env.info.dup(env.info.scope.dupUnshared()));
 speculativeEnv.info.scope.owner = env.info.scope.owner;
 Log.DeferredDiagnosticHandler deferredDiagnosticHandler =
 new Log.DeferredDiagnosticHandler(log, new Filter<JCDiagnostic>() {
 public boolean accepts(final JCDiagnostic d) {
 tree.pos() == d.getDiagnosticPosition()) {
 found = true;
 }
 super.scan(tree);
 }
-};
+}
 PosScanner posScanner = new PosScanner();
 posScanner.scan(newTree);
 return posScanner.found;
 }
 });
 /** Warner object to report warnings */
 final Warner warn;
 /** list of deferred attribution nodes to be processed */
-ArrayList<DeferredAttrNode> deferredAttrNodes = new ArrayList<DeferredAttrNode>();
+ArrayList<DeferredAttrNode> deferredAttrNodes = new ArrayList<>();
 DeferredAttrContext(AttrMode mode, Symbol msym, MethodResolutionPhase phase,
 InferenceContext inferenceContext, DeferredAttrContext parent, Warner warn) {
 this.mode = mode;
 this.msym = msym;
 * some inference variable might get eagerly instantiated so that all nodes
 * can be type-checked.
 */
 void complete() {
 while (!deferredAttrNodes.isEmpty()) {
-Map<Type, Set<Type>> depVarsMap = new LinkedHashMap<Type, Set<Type>>();
+Map<Type, Set<Type>> depVarsMap = new LinkedHashMap<>();
 List<Type> stuckVars = List.nil();
 boolean progress = false;
 //scan a defensive copy of the node list - this is because a deferred
 //attribution round can add new nodes to the list
 for (DeferredAttrNode deferredAttrNode : List.from(deferredAttrNodes)) {
 //update dependency map
 for (Type t : List.from(deferredAttrNode.deferredStuckPolicy.depVars())
 .intersect(inferenceContext.restvars())) {
 Set<Type> prevDeps = depVarsMap.get(t);
 if (prevDeps == null) {
-prevDeps = new LinkedHashSet<Type>();
+prevDeps = new LinkedHashSet<>();
 depVarsMap.put(t, prevDeps);
 }
 prevDeps.addAll(restStuckVars);
 }
 } else {
 */
 class CheckStuckPolicy extends PolyScanner implements DeferredStuckPolicy, Infer.FreeTypeListener {
 Type pt;
 Infer.InferenceContext inferenceContext;
-Set<Type> stuckVars = new LinkedHashSet<Type>();
+Set<Type> stuckVars = new LinkedHashSet<>();
-Set<Type> depVars = new LinkedHashSet<Type>();
+Set<Type> depVars = new LinkedHashSet<>();
 @Override
 public boolean isStuck() {
 return !stuckVars.isEmpty();
 }

changeset 22163	3651128c74eb
parent 21718	74a5882faf79
child 24066	1dfb66929538