jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/Infer.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 Infer {
-protected static final Context.Key<Infer> inferKey =
+protected static final Context.Key<Infer> inferKey = new Context.Key<>();
-new Context.Key<Infer>();
 Resolve rs;
 Check chk;
 Symtab syms;
 Types types;
 for (Type t : undetvars) {
 UndetVar uv = (UndetVar)t;
 uv.listener = null;
 }
 }
-};
+}
 /** max number of incorporation rounds */
 static final int MAX_INCORPORATION_STEPS = 100;
 /**
 * This enumeration defines an entry point for doing inference variable
 * bound incorporation - it can be used to inject custom incorporation
 return opKind.apply(op1, op2, warn, types);
 }
 }
 /** an incorporation cache keeps track of all executed incorporation-related operations */
-Map<IncorporationBinaryOp, Boolean> incorporationCache =
+Map<IncorporationBinaryOp, Boolean> incorporationCache = new HashMap<>();
-new HashMap<IncorporationBinaryOp, Boolean>();
 /**
 * Make sure that the upper bounds we got so far lead to a solvable inference
 * variable by making sure that a glb exists.
 */
 @Override
 public boolean accepts(Type t) {
 return !t.isErroneous() && !inferenceContext.free(t) &&
 !t.hasTag(BOT);
 }
-};
+}
 /**
 * This enumeration defines all possible bound-checking related errors.
 */
 enum BoundErrorKind {
 abstract class LeafSolver implements GraphStrategy {
 public Node pickNode(InferenceGraph g) {
 if (g.nodes.isEmpty()) {
 //should not happen
 throw new NodeNotFoundException(g);
-};
+}
 return g.nodes.get(0);
 }
 boolean isSubtype(Type s, Type t, Warner warn, Infer infer) {
 return doIncorporationOp(IncorporationBinaryOpKind.IS_SUBTYPE, s, t, warn, infer);
 Pair<List<Node>, Integer> cachedPath = treeCache.get(n);
 if (cachedPath == null) {
 //cache miss
 if (n.isLeaf()) {
 //if leaf, stop
-cachedPath = new Pair<List<Node>, Integer>(List.of(n), n.data.length());
+cachedPath = new Pair<>(List.of(n), n.data.length());
 } else {
 //if non-leaf, proceed recursively
-Pair<List<Node>, Integer> path = new Pair<List<Node>, Integer>(List.of(n), n.data.length());
+Pair<List<Node>, Integer> path = new Pair<>(List.of(n), n.data.length());
 for (Node n2 : n.getAllDependencies()) {
 if (n2 == n) continue;
 Pair<List<Node>, Integer> subpath = computeTreeToLeafs(n2);
-path = new Pair<List<Node>, Integer>(
+path = new Pair<>(path.fst.prependList(subpath.fst),
-path.fst.prependList(subpath.fst),
+path.snd + subpath.snd);
-path.snd + subpath.snd);
 }
 cachedPath = path;
 }
 //save results in cache
 treeCache.put(n, cachedPath);
 }
 return cachedPath;
 }
 /** cache used to avoid redundant computation of tree costs */
-final Map<Node, Pair<List<Node>, Integer>> treeCache =
+final Map<Node, Pair<List<Node>, Integer>> treeCache = new HashMap<>();
-new HashMap<Node, Pair<List<Node>, Integer>>();
 /** constant value used to mark non-existent paths */
-final Pair<List<Node>, Integer> noPath =
+final Pair<List<Node>, Integer> noPath = new Pair<>(null, Integer.MAX_VALUE);
-new Pair<List<Node>, Integer>(null, Integer.MAX_VALUE);
 /**
 * Pick the leaf that minimize cost
 */
 @Override
 /** map listing all dependencies (grouped by kind) */
 EnumMap<DependencyKind, Set<Node>> deps;
 Node(Type ivar) {
 super(ListBuffer.of(ivar));
-this.deps = new EnumMap<DependencyKind, Set<Node>>(DependencyKind.class);
+this.deps = new EnumMap<>(DependencyKind.class);
 }
 @Override
 public GraphUtils.DependencyKind[] getSupportedDependencyKinds() {
 return DependencyKind.values();
 /**
 * Retrieves all dependencies with given kind(s).
 */
 protected Set<Node> getDependencies(DependencyKind... depKinds) {
-Set<Node> buf = new LinkedHashSet<Node>();
+Set<Node> buf = new LinkedHashSet<>();
 for (DependencyKind dk : depKinds) {
 Set<Node> depsByKind = deps.get(dk);
 if (depsByKind != null) {
 buf.addAll(depsByKind);
 }
 * Adds dependency with given kind.
 */
 protected void addDependency(DependencyKind dk, Node depToAdd) {
 Set<Node> depsByKind = deps.get(dk);
 if (depsByKind == null) {
-depsByKind = new LinkedHashSet<Node>();
+depsByKind = new LinkedHashSet<>();
 deps.put(dk, depsByKind);
 }
 depsByKind.add(depToAdd);
 }
 * Compute closure of a give node, by recursively walking
 * through all its dependencies (of given kinds)
 */
 protected Set<Node> closure(DependencyKind... depKinds) {
 boolean progress = true;
-Set<Node> closure = new HashSet<Node>();
+Set<Node> closure = new HashSet<>();
 closure.add(this);
 while (progress) {
 progress = false;
-for (Node n1 : new HashSet<Node>(closure)) {
+for (Node n1 : new HashSet<>(closure)) {
 progress = closure.addAll(n1.getDependencies(depKinds));
 }
 }
 return closure;
 }
 for (DependencyKind dk : DependencyKind.values()) {
 addDependencies(dk, n.getDependencies(dk));
 }
 }
 //update deps
-EnumMap<DependencyKind, Set<Node>> deps2 = new EnumMap<DependencyKind, Set<Node>>(DependencyKind.class);
+EnumMap<DependencyKind, Set<Node>> deps2 = new EnumMap<>(DependencyKind.class);
 for (DependencyKind dk : DependencyKind.values()) {
 for (Node d : getDependencies(dk)) {
 Set<Node> depsByKind = deps2.get(dk);
 if (depsByKind == null) {
-depsByKind = new LinkedHashSet<Node>();
+depsByKind = new LinkedHashSet<>();
 deps2.put(dk, depsByKind);
 }
 if (data.contains(d.data.first())) {
 depsByKind.add(this);
 } else {
 * in the graph. For each component containing more than one node, a super node is
 * created, effectively replacing the original cyclic nodes.
 */
 void initNodes(Map<Type, Set<Type>> stuckDeps) {
 //add nodes
-nodes = new ArrayList<Node>();
+nodes = new ArrayList<>();
 for (Type t : inferenceContext.restvars()) {
 nodes.add(new Node(t));
 }
 //add dependencies
 for (Node n_i : nodes) {
 n_i.addDependency(DependencyKind.STUCK, n_j);
 }
 }
 }
 //merge cyclic nodes
-ArrayList<Node> acyclicNodes = new ArrayList<Node>();
+ArrayList<Node> acyclicNodes = new ArrayList<>();
 for (List<? extends Node> conSubGraph : GraphUtils.tarjan(nodes)) {
 if (conSubGraph.length() > 1) {
 Node root = conSubGraph.head;
 root.mergeWith(conSubGraph.tail);
 for (Node n : conSubGraph) {
 List<Type> undetvars;
 /** list of inference vars in this context */
 List<Type> inferencevars;
-java.util.Map<FreeTypeListener, List<Type>> freeTypeListeners =
+Map<FreeTypeListener, List<Type>> freeTypeListeners = new HashMap<>();
-new java.util.HashMap<FreeTypeListener, List<Type>>();
 List<FreeTypeListener> freetypeListeners = List.nil();
 public InferenceContext(List<Type> inferencevars) {
 this.undetvars = Type.map(inferencevars, fromTypeVarFun);
 }
 void notifyChange(List<Type> inferredVars) {
 InferenceException thrownEx = null;
 for (Map.Entry<FreeTypeListener, List<Type>> entry :
-new HashMap<FreeTypeListener, List<Type>>(freeTypeListeners).entrySet()) {
+new HashMap<>(freeTypeListeners).entrySet()) {
 if (!Type.containsAny(entry.getValue(), inferencevars.diff(inferredVars))) {
 try {
 entry.getKey().typesInferred(this);
 freeTypeListeners.remove(entry.getKey());
 } catch (InferenceException ex) {
 }, List.of(t));
 }
 }
 private void solve(GraphStrategy ss, Warner warn) {
-solve(ss, new HashMap<Type, Set<Type>>(), warn);
+solve(ss, new HashMap<>(), warn);
 }
 /**
 * Solve with given graph strategy.
 */

changeset 22163	3651128c74eb
parent 21488	4a69e26aa999
child 22165	ec53c8946fc2