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

equal deleted inserted replaced

-:d5fe2c1cecfc
+:e1aa25ccdabb
 make.at(tree.pos);
 return makeLit(sym.type, cv);
 }
 // Otherwise replace the variable by its proxy.
 sym = proxies.lookup(proxyName(sym.name)).sym;
-assert sym != null && (sym.flags_field & FINAL) != 0;
+Assert.check(sym != null && (sym.flags_field & FINAL) != 0);
 tree = make.at(tree.pos).Ident(sym);
 }
 JCExpression base = (tree.getTag() == JCTree.SELECT) ? ((JCFieldAccess) tree).selected : null;
 switch (sym.kind) {
 case TYP:
 /** Add all required access methods for a private symbol to enclosing class.
 *  @param sym       The symbol.
 */
 void makeAccessible(Symbol sym) {
 JCClassDecl cdef = classDef(sym.owner.enclClass());
-assert cdef != null : "class def not found: " + sym + " in " + sym.owner;
+if (cdef == null) Assert.error("class def not found: " + sym + " in " + sym.owner);
 if (sym.name == names.init) {
 cdef.defs = cdef.defs.prepend(
 accessConstructorDef(cdef.pos, sym, accessConstrs.get(sym)));
 } else {
 MethodSymbol[] accessors = accessSyms.get(sym);
 if (resource instanceof JCVariableDecl) {
 JCVariableDecl var = (JCVariableDecl) resource;
 expr = make.Ident(var.sym).setType(resource.type);
 stats.add(var);
 } else {
-assert resource instanceof JCExpression;
+Assert.check(resource instanceof JCExpression);
 VarSymbol syntheticTwrVar =
 new VarSymbol(SYNTHETIC | FINAL,
 makeSyntheticName(names.fromString("twrVar" +
 depth), twrVars),
 (resource.type.tag == TypeTags.BOT) ?
 */
 JCExpression makeOuterThis(DiagnosticPosition pos, TypeSymbol c) {
 List<VarSymbol> ots = outerThisStack;
 if (ots.isEmpty()) {
 log.error(pos, "no.encl.instance.of.type.in.scope", c);
-assert false;
+Assert.error();
 return makeNull();
 }
 VarSymbol ot = ots.head;
 JCExpression tree = access(make.at(pos).Ident(ot));
 TypeSymbol otc = ot.type.tsym;
 ots = ots.tail;
 if (ots.isEmpty()) {
 log.error(pos,
 "no.encl.instance.of.type.in.scope",
 c);
-assert false; // should have been caught in Attr
+Assert.error(); // should have been caught in Attr
 return tree;
 }
 ot = ots.head;
 } while (ot.owner != otc);
 if (otc.owner.kind != PCK && !otc.hasOuterInstance()) {
 chk.earlyRefError(pos, c);
-assert false; // should have been caught in Attr
+Assert.error(); // should have been caught in Attr
 return makeNull();
 }
 tree = access(make.at(pos).Select(tree, ot));
 otc = ot.type.tsym;
 }
 JCExpression makeOwnerThisN(DiagnosticPosition pos, Symbol sym, boolean preciseMatch) {
 Symbol c = sym.owner;
 List<VarSymbol> ots = outerThisStack;
 if (ots.isEmpty()) {
 log.error(pos, "no.encl.instance.of.type.in.scope", c);
-assert false;
+Assert.error();
 return makeNull();
 }
 VarSymbol ot = ots.head;
 JCExpression tree = access(make.at(pos).Ident(ot));
 TypeSymbol otc = ot.type.tsym;
 ots = ots.tail;
 if (ots.isEmpty()) {
 log.error(pos,
 "no.encl.instance.of.type.in.scope",
 c);
-assert false;
+Assert.error();
 return tree;
 }
 ot = ots.head;
 } while (ot.owner != otc);
 tree = access(make.at(pos).Select(tree, ot));
 *  name is the name of a free variable.
 */
 JCStatement initField(int pos, Name name) {
 Scope.Entry e = proxies.lookup(name);
 Symbol rhs = e.sym;
-assert rhs.owner.kind == MTH;
+Assert.check(rhs.owner.kind == MTH);
 Symbol lhs = e.next().sym;
-assert rhs.owner.owner == lhs.owner;
+Assert.check(rhs.owner.owner == lhs.owner);
 make.at(pos);
 return
 make.Exec(
 make.Assign(
 make.Select(make.This(lhs.owner.erasure(types)), lhs),
 /** Return tree simulating the assignment <this.this$n = this$n>.
 */
 JCStatement initOuterThis(int pos) {
 VarSymbol rhs = outerThisStack.head;
-assert rhs.owner.kind == MTH;
+Assert.check(rhs.owner.kind == MTH);
 VarSymbol lhs = outerThisStack.tail.head;
-assert rhs.owner.owner == lhs.owner;
+Assert.check(rhs.owner.owner == lhs.owner);
 make.at(pos);
 return
 make.Exec(
 make.Assign(
 make.Select(make.This(lhs.owner.erasure(types)), lhs),
 return make.Block(0, List.of(tryCatch));
 }
 // where
 /** Create an attributed tree of the form left.name(). */
 private JCMethodInvocation makeCall(JCExpression left, Name name, List<JCExpression> args) {
-assert left.type != null;
+Assert.checkNonNull(left.type);
 Symbol funcsym = lookupMethod(make_pos, name, left.type,
 TreeInfo.types(args));
 return make.App(make.Select(left, funcsym), args);
 }
 */
 MethodSymbol valueOfSym = lookupMethod(tree.pos(),
 names.valueOf,
 tree.sym.type,
 List.of(syms.stringType));
-assert (valueOfSym.flags() & STATIC) != 0;
+Assert.check((valueOfSym.flags() & STATIC) != 0);
 VarSymbol nameArgSym = valueOfSym.params.head;
 JCIdent nameVal = make.Ident(nameArgSym);
 JCStatement enum_ValueOf =
 make.Return(make.TypeCast(tree.sym.type,
 makeCall(make.Ident(syms.enumSym),
 JCExpression expression = oneCase.getExpression();
 if (expression != null) { // expression for a "default" case is null
 String labelExpr = (String) expression.type.constValue();
 Integer mapping = caseLabelToPosition.put(labelExpr, casePosition);
-assert mapping == null;
+Assert.checkNull(mapping);
 int hashCode = labelExpr.hashCode();
 Set<String> stringSet = hashToString.get(hashCode);
 if (stringSet == null) {
 stringSet = new LinkedHashSet<String>(1, 1.0f);
 stringSet.add(labelExpr);
 hashToString.put(hashCode, stringSet);
 } else {
 boolean added = stringSet.add(labelExpr);
-assert added;
+Assert.check(added);
 }
 }
 casePosition++;
 }
 JCSwitch switch1 = make.Switch(hashCodeCall,
 caseBuffer.toList());
 for(Map.Entry<Integer, Set<String>> entry : hashToString.entrySet()) {
 int hashCode = entry.getKey();
 Set<String> stringsWithHashCode = entry.getValue();
-assert stringsWithHashCode.size() >= 1;
+Assert.check(stringsWithHashCode.size() >= 1);
 JCStatement elsepart = null;
 for(String caseLabel : stringsWithHashCode ) {
 JCMethodInvocation stringEqualsCall = makeCall(make.Ident(dollar_s),
 names.equals,
 Symbol ordinalSym = lookupMethod(cdef.pos(),
 names.ordinal,
 cdef.type,
 List.<Type>nil());
-assert(ordinalSym != null);
+Assert.check(ordinalSym instanceof MethodSymbol);
-assert(ordinalSym instanceof MethodSymbol);
 JCStatement ret = make.Return(make.Ident(ordinalSymbol));
 cdef.defs = cdef.defs.append(make.MethodDef((MethodSymbol)ordinalSym,
 make.Block(0L, List.of(ret))));
 Symbol nameSym = lookupMethod(cdef.pos(),
 names._name,
 cdef.type,
 List.<Type>nil());
-assert(nameSym != null);
+Assert.check(nameSym instanceof MethodSymbol);
-assert(nameSym instanceof MethodSymbol);
 JCStatement ret = make.Return(make.Ident(nameSymbol));
 cdef.defs = cdef.defs.append(make.MethodDef((MethodSymbol)nameSym,
 make.Block(0L, List.of(ret))));
 Symbol compareToSym = lookupMethod(cdef.pos(),
 names.compareTo,
 cdef.type,
 List.of(cdef.sym.type));
-assert(compareToSym != null);
+Assert.check(compareToSym instanceof MethodSymbol);
-assert(compareToSym instanceof MethodSymbol);
 JCMethodDecl compareToDecl = (JCMethodDecl) TreeInfo.declarationFor(compareToSym, cdef);
 ListBuffer<JCStatement> blockStatements = new ListBuffer<JCStatement>();

changeset 8032	e1aa25ccdabb
parent 8031	d5fe2c1cecfc
child 8242	3873b4aaf4a8