1 /* 2 * Copyright (c) 2009, 2019, 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.util; 27 28 import java.nio.file.Path; 29 import java.util.EnumMap; 30 import java.util.EnumSet; 31 import java.util.HashMap; 32 import java.util.LinkedHashMap; 33 import java.util.Locale; 34 import java.util.Map; 35 36 import com.sun.tools.javac.code.Printer; 37 import com.sun.tools.javac.code.Symbol; 38 import com.sun.tools.javac.code.Symbol.*; 39 import com.sun.tools.javac.code.Symtab; 40 import com.sun.tools.javac.code.Type; 41 import com.sun.tools.javac.code.Type.*; 42 import com.sun.tools.javac.code.Types; 43 import com.sun.tools.javac.resources.CompilerProperties.Fragments; 44 45 import static com.sun.tools.javac.code.Flags.*; 46 import static com.sun.tools.javac.code.TypeTag.*; 47 import static com.sun.tools.javac.code.Kinds.*; 48 import static com.sun.tools.javac.code.Kinds.Kind.*; 49 import static com.sun.tools.javac.util.LayoutCharacters.*; 50 import static com.sun.tools.javac.util.RichDiagnosticFormatter.RichConfiguration.*; 51 52 /** 53 * A rich diagnostic formatter is a formatter that provides better integration 54 * with javac's type system. A diagnostic is first preprocessed in order to keep 55 * track of each types/symbols in it; after this information is collected, 56 * the diagnostic is rendered using a standard formatter, whose type/symbol printer 57 * has been replaced by a more refined version provided by this rich formatter. 58 * The rich formatter currently enables three different features: (i) simple class 59 * names - that is class names are displayed used a non qualified name (thus 60 * omitting package info) whenever possible - (ii) where clause list - a list of 61 * additional subdiagnostics that provide specific info about type-variables, 62 * captured types, intersection types that occur in the diagnostic that is to be 63 * formatted and (iii) type-variable disambiguation - when the diagnostic refers 64 * to two different type-variables with the same name, their representation is 65 * disambiguated by appending an index to the type variable name. 66 * 67 * <p><b>This is NOT part of any supported API. 68 * If you write code that depends on this, you do so at your own risk. 69 * This code and its internal interfaces are subject to change or 70 * deletion without notice.</b> 71 */ 72 public class RichDiagnosticFormatter extends 73 ForwardingDiagnosticFormatter<JCDiagnostic, AbstractDiagnosticFormatter> { 74 75 final Symtab syms; 76 final Types types; 77 final JCDiagnostic.Factory diags; 78 final JavacMessages messages; 79 80 /* name simplifier used by this formatter */ 81 protected ClassNameSimplifier nameSimplifier; 82 83 /* type/symbol printer used by this formatter */ 84 private RichPrinter printer; 85 86 /* map for keeping track of a where clause associated to a given type */ 87 Map<WhereClauseKind, Map<Type, JCDiagnostic>> whereClauses; 88 89 /** Get the DiagnosticFormatter instance for this context. */ instance(Context context)90 public static RichDiagnosticFormatter instance(Context context) { 91 RichDiagnosticFormatter instance = context.get(RichDiagnosticFormatter.class); 92 if (instance == null) 93 instance = new RichDiagnosticFormatter(context); 94 return instance; 95 } 96 RichDiagnosticFormatter(Context context)97 protected RichDiagnosticFormatter(Context context) { 98 super((AbstractDiagnosticFormatter)Log.instance(context).getDiagnosticFormatter()); 99 setRichPrinter(new RichPrinter()); 100 this.syms = Symtab.instance(context); 101 this.diags = JCDiagnostic.Factory.instance(context); 102 this.types = Types.instance(context); 103 this.messages = JavacMessages.instance(context); 104 whereClauses = new EnumMap<>(WhereClauseKind.class); 105 configuration = new RichConfiguration(Options.instance(context), formatter); 106 for (WhereClauseKind kind : WhereClauseKind.values()) 107 whereClauses.put(kind, new LinkedHashMap<Type, JCDiagnostic>()); 108 } 109 110 @Override format(JCDiagnostic diag, Locale l)111 public String format(JCDiagnostic diag, Locale l) { 112 StringBuilder sb = new StringBuilder(); 113 nameSimplifier = new ClassNameSimplifier(); 114 for (WhereClauseKind kind : WhereClauseKind.values()) 115 whereClauses.get(kind).clear(); 116 preprocessDiagnostic(diag); 117 sb.append(formatter.format(diag, l)); 118 if (getConfiguration().isEnabled(RichFormatterFeature.WHERE_CLAUSES)) { 119 List<JCDiagnostic> clauses = getWhereClauses(); 120 String indent = formatter.isRaw() ? "" : 121 formatter.indentString(DetailsInc); 122 for (JCDiagnostic d : clauses) { 123 String whereClause = formatter.format(d, l); 124 if (whereClause.length() > 0) { 125 sb.append('\n' + indent + whereClause); 126 } 127 } 128 } 129 return sb.toString(); 130 } 131 132 @Override formatMessage(JCDiagnostic diag, Locale l)133 public String formatMessage(JCDiagnostic diag, Locale l) { 134 nameSimplifier = new ClassNameSimplifier(); 135 preprocessDiagnostic(diag); 136 return super.formatMessage(diag, l); 137 } 138 139 /** 140 * Sets the type/symbol printer used by this formatter. 141 * @param printer the rich printer to be set 142 */ setRichPrinter(RichPrinter printer)143 protected void setRichPrinter(RichPrinter printer) { 144 this.printer = printer; 145 formatter.setPrinter(printer); 146 } 147 148 /** 149 * Returns the type/symbol printer used by this formatter. 150 * @return type/symbol rich printer 151 */ getRichPrinter()152 protected RichPrinter getRichPrinter() { 153 return printer; 154 } 155 156 /** 157 * Preprocess a given diagnostic by looking both into its arguments and into 158 * its subdiagnostics (if any). This preprocessing is responsible for 159 * generating info corresponding to features like where clauses, name 160 * simplification, etc. 161 * 162 * @param diag the diagnostic to be preprocessed 163 */ preprocessDiagnostic(JCDiagnostic diag)164 protected void preprocessDiagnostic(JCDiagnostic diag) { 165 for (Object o : diag.getArgs()) { 166 if (o != null) { 167 preprocessArgument(o); 168 } 169 } 170 if (diag.isMultiline()) { 171 for (JCDiagnostic d : diag.getSubdiagnostics()) 172 preprocessDiagnostic(d); 173 } 174 } 175 176 /** 177 * Preprocess a diagnostic argument. A type/symbol argument is 178 * preprocessed by specialized type/symbol preprocessors. 179 * 180 * @param arg the argument to be translated 181 */ preprocessArgument(Object arg)182 protected void preprocessArgument(Object arg) { 183 if (arg instanceof Type) { 184 preprocessType((Type)arg); 185 } 186 else if (arg instanceof Symbol) { 187 preprocessSymbol((Symbol)arg); 188 } 189 else if (arg instanceof JCDiagnostic) { 190 preprocessDiagnostic((JCDiagnostic)arg); 191 } 192 else if (arg instanceof Iterable<?> && !(arg instanceof Path)) { 193 for (Object o : (Iterable<?>)arg) { 194 preprocessArgument(o); 195 } 196 } 197 } 198 199 /** 200 * Build a list of multiline diagnostics containing detailed info about 201 * type-variables, captured types, and intersection types 202 * 203 * @return where clause list 204 */ getWhereClauses()205 protected List<JCDiagnostic> getWhereClauses() { 206 List<JCDiagnostic> clauses = List.nil(); 207 for (WhereClauseKind kind : WhereClauseKind.values()) { 208 List<JCDiagnostic> lines = List.nil(); 209 for (Map.Entry<Type, JCDiagnostic> entry : whereClauses.get(kind).entrySet()) { 210 lines = lines.prepend(entry.getValue()); 211 } 212 if (!lines.isEmpty()) { 213 String key = kind.key(); 214 if (lines.size() > 1) 215 key += ".1"; 216 JCDiagnostic d = diags.fragment(key, whereClauses.get(kind).keySet()); 217 d = new JCDiagnostic.MultilineDiagnostic(d, lines.reverse()); 218 clauses = clauses.prepend(d); 219 } 220 } 221 return clauses.reverse(); 222 } 223 indexOf(Type type, WhereClauseKind kind)224 private int indexOf(Type type, WhereClauseKind kind) { 225 int index = 1; 226 for (Type t : whereClauses.get(kind).keySet()) { 227 if (t.tsym == type.tsym) { 228 return index; 229 } 230 if (kind != WhereClauseKind.TYPEVAR || 231 t.toString().equals(type.toString())) { 232 index++; 233 } 234 } 235 return -1; 236 } 237 unique(TypeVar typevar)238 private boolean unique(TypeVar typevar) { 239 typevar = (TypeVar) typevar.stripMetadata(); 240 241 int found = 0; 242 for (Type t : whereClauses.get(WhereClauseKind.TYPEVAR).keySet()) { 243 if (t.stripMetadata().toString().equals(typevar.toString())) { 244 found++; 245 } 246 } 247 if (found < 1) 248 throw new AssertionError("Missing type variable in where clause: " + typevar); 249 return found == 1; 250 } 251 //where 252 /** 253 * This enum defines all possible kinds of where clauses that can be 254 * attached by a rich diagnostic formatter to a given diagnostic 255 */ 256 enum WhereClauseKind { 257 258 /** where clause regarding a type variable */ 259 TYPEVAR("where.description.typevar"), 260 /** where clause regarding a captured type */ 261 CAPTURED("where.description.captured"), 262 /** where clause regarding an intersection type */ 263 INTERSECTION("where.description.intersection"); 264 265 /** resource key for this where clause kind */ 266 private final String key; 267 WhereClauseKind(String key)268 WhereClauseKind(String key) { 269 this.key = key; 270 } 271 key()272 String key() { 273 return key; 274 } 275 } 276 277 // <editor-fold defaultstate="collapsed" desc="name simplifier"> 278 /** 279 * A name simplifier keeps track of class names usages in order to determine 280 * whether a class name can be compacted or not. Short names are not used 281 * if a conflict is detected, e.g. when two classes with the same simple 282 * name belong to different packages - in this case the formatter reverts 283 * to fullnames as compact names might lead to a confusing diagnostic. 284 */ 285 protected class ClassNameSimplifier { 286 287 /* table for keeping track of all short name usages */ 288 Map<Name, List<Symbol>> nameClashes = new HashMap<>(); 289 290 /** 291 * Add a name usage to the simplifier's internal cache 292 */ addUsage(Symbol sym)293 protected void addUsage(Symbol sym) { 294 Name n = sym.getSimpleName(); 295 List<Symbol> conflicts = nameClashes.get(n); 296 if (conflicts == null) { 297 conflicts = List.nil(); 298 } 299 if (!conflicts.contains(sym)) 300 nameClashes.put(n, conflicts.append(sym)); 301 } 302 simplify(Symbol s)303 public String simplify(Symbol s) { 304 String name = s.getQualifiedName().toString(); 305 if (!s.type.isCompound() && !s.type.isPrimitive()) { 306 List<Symbol> conflicts = nameClashes.get(s.getSimpleName()); 307 if (conflicts == null || 308 (conflicts.size() == 1 && 309 conflicts.contains(s))) { 310 List<Name> l = List.nil(); 311 Symbol s2 = s; 312 while (s2.type.hasTag(CLASS) && 313 s2.type.getEnclosingType().hasTag(CLASS) && 314 s2.owner.kind == TYP) { 315 l = l.prepend(s2.getSimpleName()); 316 s2 = s2.owner; 317 } 318 l = l.prepend(s2.getSimpleName()); 319 StringBuilder buf = new StringBuilder(); 320 String sep = ""; 321 for (Name n2 : l) { 322 buf.append(sep); 323 buf.append(n2); 324 sep = "."; 325 } 326 name = buf.toString(); 327 } 328 } 329 return name; 330 } 331 } 332 // </editor-fold> 333 334 // <editor-fold defaultstate="collapsed" desc="rich printer"> 335 /** 336 * Enhanced type/symbol printer that provides support for features like simple names 337 * and type variable disambiguation. This enriched printer exploits the info 338 * discovered during type/symbol preprocessing. This printer is set on the delegate 339 * formatter so that rich type/symbol info can be properly rendered. 340 */ 341 protected class RichPrinter extends Printer { 342 343 @Override localize(Locale locale, String key, Object... args)344 public String localize(Locale locale, String key, Object... args) { 345 return formatter.localize(locale, key, args); 346 } 347 348 @Override capturedVarId(CapturedType t, Locale locale)349 public String capturedVarId(CapturedType t, Locale locale) { 350 return indexOf(t, WhereClauseKind.CAPTURED) + ""; 351 } 352 353 @Override visitType(Type t, Locale locale)354 public String visitType(Type t, Locale locale) { 355 String s = super.visitType(t, locale); 356 if (t == syms.botType) 357 s = localize(locale, "compiler.misc.type.null"); 358 return s; 359 } 360 361 @Override visitCapturedType(CapturedType t, Locale locale)362 public String visitCapturedType(CapturedType t, Locale locale) { 363 if (getConfiguration().isEnabled(RichFormatterFeature.WHERE_CLAUSES)) { 364 return localize(locale, 365 "compiler.misc.captured.type", 366 indexOf(t, WhereClauseKind.CAPTURED)); 367 } 368 else 369 return super.visitCapturedType(t, locale); 370 } 371 372 @Override visitClassType(ClassType t, Locale locale)373 public String visitClassType(ClassType t, Locale locale) { 374 if (t.isCompound() && 375 getConfiguration().isEnabled(RichFormatterFeature.WHERE_CLAUSES)) { 376 return localize(locale, 377 "compiler.misc.intersection.type", 378 indexOf(t, WhereClauseKind.INTERSECTION)); 379 } 380 else 381 return super.visitClassType(t, locale); 382 } 383 384 @Override className(ClassType t, boolean longform, Locale locale)385 protected String className(ClassType t, boolean longform, Locale locale) { 386 Symbol sym = t.tsym; 387 if (sym.name.length() == 0 || 388 !getConfiguration().isEnabled(RichFormatterFeature.SIMPLE_NAMES)) { 389 return super.className(t, longform, locale); 390 } 391 else if (longform) 392 return nameSimplifier.simplify(sym).toString(); 393 else 394 return sym.name.toString(); 395 } 396 397 @Override visitTypeVar(TypeVar t, Locale locale)398 public String visitTypeVar(TypeVar t, Locale locale) { 399 if (unique(t) || 400 !getConfiguration().isEnabled(RichFormatterFeature.UNIQUE_TYPEVAR_NAMES)) { 401 return t.toString(); 402 } 403 else { 404 return localize(locale, 405 "compiler.misc.type.var", 406 t.toString(), indexOf(t, WhereClauseKind.TYPEVAR)); 407 } 408 } 409 410 @Override visitClassSymbol(ClassSymbol s, Locale locale)411 public String visitClassSymbol(ClassSymbol s, Locale locale) { 412 if (s.type.isCompound()) { 413 return visit(s.type, locale); 414 } 415 String name = nameSimplifier.simplify(s); 416 if (name.length() == 0 || 417 !getConfiguration().isEnabled(RichFormatterFeature.SIMPLE_NAMES)) { 418 return super.visitClassSymbol(s, locale); 419 } 420 else { 421 return name; 422 } 423 } 424 425 @Override visitMethodSymbol(MethodSymbol s, Locale locale)426 public String visitMethodSymbol(MethodSymbol s, Locale locale) { 427 String ownerName = visit(s.owner, locale); 428 if (s.isStaticOrInstanceInit()) { 429 return ownerName; 430 } else { 431 String ms = (s.name == s.name.table.names.init) 432 ? ownerName 433 : s.name.toString(); 434 if (s.type != null) { 435 if (s.type.hasTag(FORALL)) { 436 ms = "<" + visitTypes(s.type.getTypeArguments(), locale) + ">" + ms; 437 } 438 ms += "(" + printMethodArgs( 439 s.type.getParameterTypes(), 440 (s.flags() & VARARGS) != 0, 441 locale) + ")"; 442 } 443 return ms; 444 } 445 } 446 } 447 // </editor-fold> 448 449 // <editor-fold defaultstate="collapsed" desc="type scanner"> 450 /** 451 * Preprocess a given type looking for (i) additional info (where clauses) to be 452 * added to the main diagnostic (ii) names to be compacted. 453 */ preprocessType(Type t)454 protected void preprocessType(Type t) { 455 typePreprocessor.visit(t); 456 } 457 //where 458 protected Types.UnaryVisitor<Void> typePreprocessor = 459 new Types.UnaryVisitor<Void>() { 460 461 public Void visit(List<Type> ts) { 462 for (Type t : ts) 463 visit(t); 464 return null; 465 } 466 467 @Override 468 public Void visitForAll(ForAll t, Void ignored) { 469 visit(t.tvars); 470 visit(t.qtype); 471 return null; 472 } 473 474 @Override 475 public Void visitMethodType(MethodType t, Void ignored) { 476 visit(t.argtypes); 477 visit(t.restype); 478 return null; 479 } 480 481 @Override 482 public Void visitErrorType(ErrorType t, Void ignored) { 483 Type ot = t.getOriginalType(); 484 if (ot != null) 485 visit(ot); 486 return null; 487 } 488 489 @Override 490 public Void visitArrayType(ArrayType t, Void ignored) { 491 visit(t.elemtype); 492 return null; 493 } 494 495 @Override 496 public Void visitWildcardType(WildcardType t, Void ignored) { 497 visit(t.type); 498 return null; 499 } 500 501 public Void visitType(Type t, Void ignored) { 502 return null; 503 } 504 505 @Override 506 public Void visitCapturedType(CapturedType t, Void ignored) { 507 if (indexOf(t, WhereClauseKind.CAPTURED) == -1) { 508 String suffix = t.lower == syms.botType ? ".1" : ""; 509 JCDiagnostic d = diags.fragment("where.captured"+ suffix, t, t.getUpperBound(), t.lower, t.wildcard); 510 whereClauses.get(WhereClauseKind.CAPTURED).put(t, d); 511 visit(t.wildcard); 512 visit(t.lower); 513 visit(t.getUpperBound()); 514 } 515 return null; 516 } 517 518 @Override 519 public Void visitClassType(ClassType t, Void ignored) { 520 if (t.isCompound()) { 521 if (indexOf(t, WhereClauseKind.INTERSECTION) == -1) { 522 Type supertype = types.supertype(t); 523 List<Type> interfaces = types.interfaces(t); 524 JCDiagnostic d = diags.fragment(Fragments.WhereIntersection(t, interfaces.prepend(supertype))); 525 whereClauses.get(WhereClauseKind.INTERSECTION).put(t, d); 526 visit(supertype); 527 visit(interfaces); 528 } 529 } else if (t.tsym.name.isEmpty()) { 530 //anon class 531 ClassType norm = (ClassType) t.tsym.type; 532 if (norm != null) { 533 if (norm.interfaces_field != null && norm.interfaces_field.nonEmpty()) { 534 visit(norm.interfaces_field.head); 535 } else { 536 visit(norm.supertype_field); 537 } 538 } 539 } 540 nameSimplifier.addUsage(t.tsym); 541 visit(t.getTypeArguments()); 542 Type enclosingType; 543 try { 544 enclosingType = t.getEnclosingType(); 545 } catch (CompletionFailure cf) { 546 return null; 547 } 548 if (enclosingType != Type.noType) 549 visit(t.getEnclosingType()); 550 return null; 551 } 552 553 @Override 554 public Void visitTypeVar(TypeVar t, Void ignored) { 555 t = (TypeVar)t.stripMetadataIfNeeded(); 556 if (indexOf(t, WhereClauseKind.TYPEVAR) == -1) { 557 //access the bound type and skip error types 558 Type bound = t.getUpperBound(); 559 while ((bound instanceof ErrorType)) 560 bound = ((ErrorType)bound).getOriginalType(); 561 //retrieve the bound list - if the type variable 562 //has not been attributed the bound is not set 563 List<Type> bounds = (bound != null) && 564 (bound.hasTag(CLASS) || bound.hasTag(TYPEVAR)) ? 565 getBounds(bound) : 566 List.nil(); 567 568 nameSimplifier.addUsage(t.tsym); 569 570 boolean boundErroneous = bounds.head == null || 571 bounds.head.hasTag(NONE) || 572 bounds.head.hasTag(ERROR); 573 574 if ((t.tsym.flags() & SYNTHETIC) == 0) { 575 //this is a true typevar 576 JCDiagnostic d = diags.fragment("where.typevar" + 577 (boundErroneous ? ".1" : ""), t, bounds, 578 kindName(t.tsym.location()), t.tsym.location()); 579 whereClauses.get(WhereClauseKind.TYPEVAR).put(t, d); 580 symbolPreprocessor.visit(t.tsym.location(), null); 581 visit(bounds); 582 } else { 583 Assert.check(!boundErroneous); 584 //this is a fresh (synthetic) tvar 585 JCDiagnostic d = diags.fragment(Fragments.WhereFreshTypevar(t, bounds)); 586 whereClauses.get(WhereClauseKind.TYPEVAR).put(t, d); 587 visit(bounds); 588 } 589 590 } 591 return null; 592 } 593 //where: 594 private List<Type> getBounds(Type bound) { 595 return bound.isCompound() ? types.directSupertypes(bound) : List.of(bound); 596 } 597 }; 598 // </editor-fold> 599 600 // <editor-fold defaultstate="collapsed" desc="symbol scanner"> 601 /** 602 * Preprocess a given symbol looking for (i) additional info (where clauses) to be 603 * added to the main diagnostic (ii) names to be compacted 604 */ preprocessSymbol(Symbol s)605 protected void preprocessSymbol(Symbol s) { 606 symbolPreprocessor.visit(s, null); 607 } 608 //where 609 protected Types.DefaultSymbolVisitor<Void, Void> symbolPreprocessor = 610 new Types.DefaultSymbolVisitor<Void, Void>() { 611 612 @Override 613 public Void visitClassSymbol(ClassSymbol s, Void ignored) { 614 if (s.type.isCompound()) { 615 typePreprocessor.visit(s.type); 616 } else { 617 nameSimplifier.addUsage(s); 618 } 619 return null; 620 } 621 622 @Override 623 public Void visitSymbol(Symbol s, Void ignored) { 624 return null; 625 } 626 627 @Override 628 public Void visitMethodSymbol(MethodSymbol s, Void ignored) { 629 visit(s.owner, null); 630 if (s.type != null) 631 typePreprocessor.visit(s.type); 632 return null; 633 } 634 }; 635 // </editor-fold> 636 637 @Override getConfiguration()638 public RichConfiguration getConfiguration() { 639 //the following cast is always safe - see init 640 return (RichConfiguration)configuration; 641 } 642 643 /** 644 * Configuration object provided by the rich formatter. 645 */ 646 public static class RichConfiguration extends ForwardingDiagnosticFormatter.ForwardingConfiguration { 647 648 /** set of enabled rich formatter's features */ 649 protected java.util.EnumSet<RichFormatterFeature> features; 650 651 @SuppressWarnings("fallthrough") RichConfiguration(Options options, AbstractDiagnosticFormatter formatter)652 public RichConfiguration(Options options, AbstractDiagnosticFormatter formatter) { 653 super(formatter.getConfiguration()); 654 features = formatter.isRaw() ? EnumSet.noneOf(RichFormatterFeature.class) : 655 EnumSet.of(RichFormatterFeature.SIMPLE_NAMES, 656 RichFormatterFeature.WHERE_CLAUSES, 657 RichFormatterFeature.UNIQUE_TYPEVAR_NAMES); 658 String diagOpts = options.get("diags.formatterOptions"); 659 if (diagOpts != null) { 660 for (String args: diagOpts.split(",")) { 661 if (args.equals("-where")) { 662 features.remove(RichFormatterFeature.WHERE_CLAUSES); 663 } 664 else if (args.equals("where")) { 665 features.add(RichFormatterFeature.WHERE_CLAUSES); 666 } 667 if (args.equals("-simpleNames")) { 668 features.remove(RichFormatterFeature.SIMPLE_NAMES); 669 } 670 else if (args.equals("simpleNames")) { 671 features.add(RichFormatterFeature.SIMPLE_NAMES); 672 } 673 if (args.equals("-disambiguateTvars")) { 674 features.remove(RichFormatterFeature.UNIQUE_TYPEVAR_NAMES); 675 } 676 else if (args.equals("disambiguateTvars")) { 677 features.add(RichFormatterFeature.UNIQUE_TYPEVAR_NAMES); 678 } 679 } 680 } 681 } 682 683 /** 684 * Returns a list of all the features supported by the rich formatter. 685 * @return list of supported features 686 */ getAvailableFeatures()687 public RichFormatterFeature[] getAvailableFeatures() { 688 return RichFormatterFeature.values(); 689 } 690 691 /** 692 * Enable a specific feature on this rich formatter. 693 * @param feature feature to be enabled 694 */ enable(RichFormatterFeature feature)695 public void enable(RichFormatterFeature feature) { 696 features.add(feature); 697 } 698 699 /** 700 * Disable a specific feature on this rich formatter. 701 * @param feature feature to be disabled 702 */ disable(RichFormatterFeature feature)703 public void disable(RichFormatterFeature feature) { 704 features.remove(feature); 705 } 706 707 /** 708 * Is a given feature enabled on this formatter? 709 * @param feature feature to be tested 710 */ isEnabled(RichFormatterFeature feature)711 public boolean isEnabled(RichFormatterFeature feature) { 712 return features.contains(feature); 713 } 714 715 /** 716 * The advanced formatting features provided by the rich formatter 717 */ 718 public enum RichFormatterFeature { 719 /** a list of additional info regarding a given type/symbol */ 720 WHERE_CLAUSES, 721 /** full class names simplification (where possible) */ 722 SIMPLE_NAMES, 723 /** type-variable names disambiguation */ 724 UNIQUE_TYPEVAR_NAMES 725 } 726 } 727 } 728