jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Lower.java

-:b2064a216117
+:30c36e23f154
 //where
 JCExpression loadFreevar(DiagnosticPosition pos, VarSymbol v) {
 return access(v, make.at(pos).Ident(v), null, false);
 }
-/** Construct a tree simulating the expression <C.this>.
+/** Construct a tree simulating the expression {@code C.this}.
 *  @param pos           The source code position to be used for the tree.
 *  @param c             The qualifier class.
 */
 JCExpression makeThis(DiagnosticPosition pos, TypeSymbol c) {
 if (currentClass == c) {
 private JCExpression makeNonNullCheck(JCExpression expression) {
 return makeBinary(NE, expression, makeNull());
 }
 /** Construct a tree that represents the outer instance
-*  <C.this>. Never pick the current `this'.
+*  {@code C.this}. Never pick the current `this'.
 *  @param pos           The source code position to be used for the tree.
 *  @param c             The qualifier class.
 */
 JCExpression makeOuterThis(DiagnosticPosition pos, TypeSymbol c) {
 List<VarSymbol> ots = outerThisStack;
 }
 return tree;
 }
 /** Construct a tree that represents the closest outer instance
-*  <C.this> such that the given symbol is a member of C.
+*  {@code C.this} such that the given symbol is a member of C.
 *  @param pos           The source code position to be used for the tree.
 *  @param sym           The accessed symbol.
 *  @param preciseMatch  should we accept a type that is a subtype of
 *                       sym's owner, even if it doesn't contain sym
 *                       due to hiding, overriding, or non-inheritance
 otc = ot.type.tsym;
 }
 return tree;
 }
-/** Return tree simulating the assignment <this.name = name>, where
+/** Return tree simulating the assignment {@code this.name = name}, where
 *  name is the name of a free variable.
 */
 JCStatement initField(int pos, Name name) {
 Scope.Entry e = proxies.lookup(name);
 Symbol rhs = e.sym;
 make.Assign(
 make.Select(make.This(lhs.owner.erasure(types)), lhs),
 make.Ident(rhs)).setType(lhs.erasure(types)));
 }
-/** Return tree simulating the assignment <this.this$n = this$n>.
+/** Return tree simulating the assignment {@code this.this$n = this$n}.
 */
 JCStatement initOuterThis(int pos) {
 VarSymbol rhs = outerThisStack.head;
 Assert.check(rhs.owner.kind == MTH);
 VarSymbol lhs = outerThisStack.tail.head;
 *     for ( T v : arrayexpr ) stmt;
 * </pre>
 *
 * (where arrayexpr is of an array type) gets translated to
 *
-* <pre>
+* <pre>{@code
 *     for ( { arraytype #arr = arrayexpr;
 *             int #len = array.length;
 *             int #i = 0; };
 *           #i < #len; i$++ ) {
 *         T v = arr$[#i];
 *         stmt;
 *     }
-* </pre>
+* }</pre>
 *
 * where #arr, #len, and #i are freshly named synthetic local variables.
 */
 private void visitArrayForeachLoop(JCEnhancedForLoop tree) {
 make_at(tree.expr.pos());
 *
 * <pre>
 *     for ( T v : coll ) stmt ;
 * </pre>
 *
-* (where coll implements Iterable<? extends T>) gets translated to
+* (where coll implements {@code Iterable<? extends T>}) gets translated to
 *
-* <pre>
+* <pre>{@code
 *     for ( Iterator<? extends T> #i = coll.iterator(); #i.hasNext(); ) {
 *         T v = (T) #i.next();
 *         stmt;
 *     }
-* </pre>
+* }</pre>
 *
 * where #i is a freshly named synthetic local variable.
 */
 private void visitIterableForeachLoop(JCEnhancedForLoop tree) {
 make_at(tree.expr.pos());

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Lower.java

src/share/classes/com/sun/tools/javac/comp/Lower.java