langtools/src/share/classes/com/sun/tools/javac/util/AbstractDiagnosticFormatter.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.tools.javac.util;

 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;

 import javax.tools.JavaFileObject;

 import com.sun.tools.javac.api.DiagnosticFormatter;
 import com.sun.tools.javac.api.DiagnosticFormatter.Configuration.DiagnosticPart;
 import com.sun.tools.javac.api.DiagnosticFormatter.Configuration.MultilineLimit;
 import com.sun.tools.javac.api.DiagnosticFormatter.PositionKind;
 import com.sun.tools.javac.api.Formattable;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Printer;
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Type.CapturedType;
 import com.sun.tools.javac.file.BaseFileObject;
 import com.sun.tools.javac.jvm.Profile;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.tree.Pretty;
 import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticType.*;

 /**
  * This abstract class provides a basic implementation of the functionalities that should be provided
  * by any formatter used by javac. Among the main features provided by AbstractDiagnosticFormatter are:
  *
  * <ul>
  *  <li> Provides a standard implementation of the visitor-like methods defined in the interface DiagnisticFormatter.
  *  Those implementations are specifically targeting JCDiagnostic objects.
  *  <li> Provides basic support for i18n and a method for executing all locale-dependent conversions
  *  <li> Provides the formatting logic for rendering the arguments of a JCDiagnostic object.
  * <ul>
  *
  * <p><b>This is NOT part of any supported API.
  * 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 abstract class AbstractDiagnosticFormatter implements DiagnosticFormatter<JCDiagnostic> {

     /**
      * JavacMessages object used by this formatter for i18n.
      */
     protected JavacMessages messages;

     /**
      * Configuration object used by this formatter
      */
     private SimpleConfiguration config;

     /**
      * Current depth level of the disgnostic being formatted
      * (!= 0 for subdiagnostics)
      */
     protected int depth = 0;

     /**
      * All captured types that have been encountered during diagnostic formatting.
      * This info is used by the FormatterPrinter in order to print friendly unique
      * ids for captured types
      */
     private List<Type> allCaptured = List.nil();

     /**
      * Initialize an AbstractDiagnosticFormatter by setting its JavacMessages object.
      * @param messages
      */
     protected AbstractDiagnosticFormatter(JavacMessages messages, SimpleConfiguration config) {
         this.messages = messages;
         this.config = config;
     }

     public String formatKind(JCDiagnostic d, Locale l) {
         switch (d.getType()) {
             case FRAGMENT: return "";
             case NOTE:     return localize(l, "compiler.note.note");
             case WARNING:  return localize(l, "compiler.warn.warning");
             case ERROR:    return localize(l, "compiler.err.error");
             default:
                 throw new AssertionError("Unknown diagnostic type: " + d.getType());
         }
     }

     @Override
     public String format(JCDiagnostic d, Locale locale) {
         allCaptured = List.nil();
         return formatDiagnostic(d, locale);
     }

     protected abstract String formatDiagnostic(JCDiagnostic d, Locale locale);

     public String formatPosition(JCDiagnostic d, PositionKind pk,Locale l) {
         Assert.check(d.getPosition() != Position.NOPOS);
         return String.valueOf(getPosition(d, pk));
     }
     //where
     private long getPosition(JCDiagnostic d, PositionKind pk) {
         switch (pk) {
             case START: return d.getIntStartPosition();
             case END: return d.getIntEndPosition();
             case LINE: return d.getLineNumber();
             case COLUMN: return d.getColumnNumber();
             case OFFSET: return d.getIntPosition();
             default:
                 throw new AssertionError("Unknown diagnostic position: " + pk);
         }
     }

     public String formatSource(JCDiagnostic d, boolean fullname, Locale l) {
         JavaFileObject fo = d.getSource();
         if (fo == null)
             throw new IllegalArgumentException(); // d should have source set
         if (fullname)
             return fo.getName();
         else if (fo instanceof BaseFileObject)
             return ((BaseFileObject) fo).getShortName();
         else
             return BaseFileObject.getSimpleName(fo);
     }

     /**
      * Format the arguments of a given diagnostic.
      *
      * @param d diagnostic whose arguments are to be formatted
      * @param l locale object to be used for i18n
      * @return a Collection whose elements are the formatted arguments of the diagnostic
      */
     protected Collection<String> formatArguments(JCDiagnostic d, Locale l) {
         ListBuffer<String> buf = new ListBuffer<>();
         for (Object o : d.getArgs()) {
            buf.append(formatArgument(d, o, l));
         }
         return buf.toList();
     }

     /**
      * Format a single argument of a given diagnostic.
      *
      * @param d diagnostic whose argument is to be formatted
      * @param arg argument to be formatted
      * @param l locale object to be used for i18n
      * @return string representation of the diagnostic argument
      */
     protected String formatArgument(JCDiagnostic d, Object arg, Locale l) {
         if (arg instanceof JCDiagnostic) {
             String s = null;
             depth++;
             try {
                 s = formatMessage((JCDiagnostic)arg, l);
             }
             finally {
                 depth--;
             }
             return s;
         }
         else if (arg instanceof JCExpression) {
             return expr2String((JCExpression)arg);
         }
         else if (arg instanceof Iterable<?>) {
             return formatIterable(d, (Iterable<?>)arg, l);
         }
         else if (arg instanceof Type) {
             return printer.visit((Type)arg, l);
         }
         else if (arg instanceof Symbol) {
             return printer.visit((Symbol)arg, l);
         }
         else if (arg instanceof JavaFileObject) {
             return ((JavaFileObject)arg).getName();
         }
         else if (arg instanceof Profile) {
             return ((Profile)arg).name;
         }
         else if (arg instanceof Formattable) {
             return ((Formattable)arg).toString(l, messages);
         }
         else {
             return String.valueOf(arg);
         }
     }
     //where
             private String expr2String(JCExpression tree) {
                 switch(tree.getTag()) {
                     case PARENS:
                         return expr2String(((JCParens)tree).expr);
                     case LAMBDA:
                     case REFERENCE:
                     case CONDEXPR:
                         return Pretty.toSimpleString(tree);
                     default:
                         Assert.error("unexpected tree kind " + tree.getKind());
                         return null;
                 }
             }

     /**
      * Format an iterable argument of a given diagnostic.
      *
      * @param d diagnostic whose argument is to be formatted
      * @param it iterable argument to be formatted
      * @param l locale object to be used for i18n
      * @return string representation of the diagnostic iterable argument
      */
     protected String formatIterable(JCDiagnostic d, Iterable<?> it, Locale l) {
         StringBuilder sbuf = new StringBuilder();
         String sep = "";
         for (Object o : it) {
             sbuf.append(sep);
             sbuf.append(formatArgument(d, o, l));
             sep = ",";
         }
         return sbuf.toString();
     }

     /**
      * Format all the subdiagnostics attached to a given diagnostic.
      *
      * @param d diagnostic whose subdiagnostics are to be formatted
      * @param l locale object to be used for i18n
      * @return list of all string representations of the subdiagnostics
      */
     protected List<String> formatSubdiagnostics(JCDiagnostic d, Locale l) {
         List<String> subdiagnostics = List.nil();
         int maxDepth = config.getMultilineLimit(MultilineLimit.DEPTH);
         if (maxDepth == -1 || depth < maxDepth) {
             depth++;
             try {
                 int maxCount = config.getMultilineLimit(MultilineLimit.LENGTH);
                 int count = 0;
                 for (JCDiagnostic d2 : d.getSubdiagnostics()) {
                     if (maxCount == -1 || count < maxCount) {
                         subdiagnostics = subdiagnostics.append(formatSubdiagnostic(d, d2, l));
                         count++;
                     }
                     else
                         break;
                 }
             }
             finally {
                 depth--;
             }
         }
         return subdiagnostics;
     }

     /**
      * Format a subdiagnostics attached to a given diagnostic.
      *
      * @param parent multiline diagnostic whose subdiagnostics is to be formatted
      * @param sub subdiagnostic to be formatted
      * @param l locale object to be used for i18n
      * @return string representation of the subdiagnostics
      */
     protected String formatSubdiagnostic(JCDiagnostic parent, JCDiagnostic sub, Locale l) {
         return formatMessage(sub, l);
     }

     /** Format the faulty source code line and point to the error.
      *  @param d The diagnostic for which the error line should be printed
      */
     protected String formatSourceLine(JCDiagnostic d, int nSpaces) {
         StringBuilder buf = new StringBuilder();
         DiagnosticSource source = d.getDiagnosticSource();
         int pos = d.getIntPosition();
         if (d.getIntPosition() == Position.NOPOS)
             throw new AssertionError();
         String line = (source == null ? null : source.getLine(pos));
         if (line == null)
             return "";
         buf.append(indent(line, nSpaces));
         int col = source.getColumnNumber(pos, false);
         if (config.isCaretEnabled()) {
             buf.append("\n");
             for (int i = 0; i < col - 1; i++)  {
                 buf.append((line.charAt(i) == '\t') ? "\t" : " ");
             }
             buf.append(indent("^", nSpaces));
         }
         return buf.toString();
     }

     protected String formatLintCategory(JCDiagnostic d, Locale l) {
         LintCategory lc = d.getLintCategory();
         if (lc == null)
             return "";
         return localize(l, "compiler.warn.lintOption", lc.option);
     }

     /**
      * Converts a String into a locale-dependent representation accordingly to a given locale.
      *
      * @param l locale object to be used for i18n
      * @param key locale-independent key used for looking up in a resource file
      * @param args localization arguments
      * @return a locale-dependent string
      */
     protected String localize(Locale l, String key, Object... args) {
         return messages.getLocalizedString(l, key, args);
     }

     public boolean displaySource(JCDiagnostic d) {
         return config.getVisible().contains(DiagnosticPart.SOURCE) &&
                 d.getType() != FRAGMENT &&
                 d.getIntPosition() != Position.NOPOS;
     }

     public boolean isRaw() {
         return false;
     }

     /**
      * Creates a string with a given amount of empty spaces. Useful for
      * indenting the text of a diagnostic message.
      *
      * @param nSpaces the amount of spaces to be added to the result string
      * @return the indentation string
      */
     protected String indentString(int nSpaces) {
         String spaces = "                        ";
         if (nSpaces <= spaces.length())
             return spaces.substring(0, nSpaces);
         else {
             StringBuilder buf = new StringBuilder();
             for (int i = 0 ; i < nSpaces ; i++)
                 buf.append(" ");
             return buf.toString();
         }
     }

     /**
      * Indent a string by prepending a given amount of empty spaces to each line
      * of the string.
      *
      * @param s the string to be indented
      * @param nSpaces the amount of spaces that should be prepended to each line
      * of the string
      * @return an indented string
      */
     protected String indent(String s, int nSpaces) {
         String indent = indentString(nSpaces);
         StringBuilder buf = new StringBuilder();
         String nl = "";
         for (String line : s.split("\n")) {
             buf.append(nl);
             buf.append(indent + line);
             nl = "\n";
         }
         return buf.toString();
     }

     public SimpleConfiguration getConfiguration() {
         return config;
     }

     static public class SimpleConfiguration implements Configuration {

         protected Map<MultilineLimit, Integer> multilineLimits;
         protected EnumSet<DiagnosticPart> visibleParts;
         protected boolean caretEnabled;

         public SimpleConfiguration(Set<DiagnosticPart> parts) {
             multilineLimits = new HashMap<>();
             setVisible(parts);
             setMultilineLimit(MultilineLimit.DEPTH, -1);
             setMultilineLimit(MultilineLimit.LENGTH, -1);
             setCaretEnabled(true);
         }

         @SuppressWarnings("fallthrough")
         public SimpleConfiguration(Options options, Set<DiagnosticPart> parts) {
             this(parts);
             String showSource = null;
             if ((showSource = options.get("showSource")) != null) {
                 if (showSource.equals("true"))
                     setVisiblePart(DiagnosticPart.SOURCE, true);
                 else if (showSource.equals("false"))
                     setVisiblePart(DiagnosticPart.SOURCE, false);
             }
             String diagOpts = options.get("diags");
             if (diagOpts != null) {//override -XDshowSource
                 Collection<String> args = Arrays.asList(diagOpts.split(","));
                 if (args.contains("short")) {
                     setVisiblePart(DiagnosticPart.DETAILS, false);
                     setVisiblePart(DiagnosticPart.SUBDIAGNOSTICS, false);
                 }
                 if (args.contains("source"))
                     setVisiblePart(DiagnosticPart.SOURCE, true);
                 if (args.contains("-source"))
                     setVisiblePart(DiagnosticPart.SOURCE, false);
             }
             String multiPolicy = null;
             if ((multiPolicy = options.get("multilinePolicy")) != null) {
                 if (multiPolicy.equals("disabled"))
                     setVisiblePart(DiagnosticPart.SUBDIAGNOSTICS, false);
                 else if (multiPolicy.startsWith("limit:")) {
                     String limitString = multiPolicy.substring("limit:".length());
                     String[] limits = limitString.split(":");
                     try {
                         switch (limits.length) {
                             case 2: {
                                 if (!limits[1].equals("*"))
                                     setMultilineLimit(MultilineLimit.DEPTH, Integer.parseInt(limits[1]));
                             }
                             case 1: {
                                 if (!limits[0].equals("*"))
                                     setMultilineLimit(MultilineLimit.LENGTH, Integer.parseInt(limits[0]));
                             }
                         }
                     }
                     catch(NumberFormatException ex) {
                         setMultilineLimit(MultilineLimit.DEPTH, -1);
                         setMultilineLimit(MultilineLimit.LENGTH, -1);
                     }
                 }
             }
             String showCaret = null;
             if (((showCaret = options.get("showCaret")) != null) &&
                 showCaret.equals("false"))
                     setCaretEnabled(false);
             else
                 setCaretEnabled(true);
         }

         public int getMultilineLimit(MultilineLimit limit) {
             return multilineLimits.get(limit);
         }

         public EnumSet<DiagnosticPart> getVisible() {
             return EnumSet.copyOf(visibleParts);
         }

         public void setMultilineLimit(MultilineLimit limit, int value) {
             multilineLimits.put(limit, value < -1 ? -1 : value);
         }


         public void setVisible(Set<DiagnosticPart> diagParts) {
             visibleParts = EnumSet.copyOf(diagParts);
         }

         public void setVisiblePart(DiagnosticPart diagParts, boolean enabled) {
             if (enabled)
                 visibleParts.add(diagParts);
             else
                 visibleParts.remove(diagParts);
         }

         /**
          * Shows a '^' sign under the source line displayed by the formatter
          * (if applicable).
          *
          * @param caretEnabled if true enables caret
          */
         public void setCaretEnabled(boolean caretEnabled) {
             this.caretEnabled = caretEnabled;
         }

         /**
          * Tells whether the caret display is active or not.
          *
          * @return true if the caret is enabled
          */
         public boolean isCaretEnabled() {
             return caretEnabled;
         }
     }

     public Printer getPrinter() {
         return printer;
     }

     public void setPrinter(Printer printer) {
         this.printer = printer;
     }

     /**
      * An enhanced printer for formatting types/symbols used by
      * AbstractDiagnosticFormatter. Provides alternate numbering of captured
      * types (they are numbered starting from 1 on each new diagnostic, instead
      * of relying on the underlying hashcode() method which generates unstable
      * output). Also detects cycles in wildcard messages (e.g. if the wildcard
      * type referred by a given captured type C contains C itself) which might
      * lead to infinite loops.
      */
     protected Printer printer = new Printer() {

         @Override
         protected String localize(Locale locale, String key, Object... args) {
             return AbstractDiagnosticFormatter.this.localize(locale, key, args);
         }
         @Override
         protected String capturedVarId(CapturedType t, Locale locale) {
             return "" + (allCaptured.indexOf(t) + 1);
         }
         @Override
         public String visitCapturedType(CapturedType t, Locale locale) {
             if (!allCaptured.contains(t)) {
                 allCaptured = allCaptured.append(t);
             }
             return super.visitCapturedType(t, locale);
         }
     };
 }
	/*
	* Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package com.sun.tools.javac.util;

	import java.util.Arrays;
	import java.util.Collection;
	import java.util.EnumSet;
	import java.util.HashMap;
	import java.util.Locale;
	import java.util.Map;
	import java.util.Set;

	import javax.tools.JavaFileObject;

	import com.sun.tools.javac.api.DiagnosticFormatter;
	import com.sun.tools.javac.api.DiagnosticFormatter.Configuration.DiagnosticPart;
	import com.sun.tools.javac.api.DiagnosticFormatter.Configuration.MultilineLimit;
	import com.sun.tools.javac.api.DiagnosticFormatter.PositionKind;
	import com.sun.tools.javac.api.Formattable;
	import com.sun.tools.javac.code.Lint.LintCategory;
	import com.sun.tools.javac.code.Printer;
	import com.sun.tools.javac.code.Symbol;
	import com.sun.tools.javac.code.Type;
	import com.sun.tools.javac.code.Type.CapturedType;
	import com.sun.tools.javac.file.BaseFileObject;
	import com.sun.tools.javac.jvm.Profile;
	import com.sun.tools.javac.tree.JCTree.*;
	import com.sun.tools.javac.tree.Pretty;
	import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticType.*;

	/**
	* This abstract class provides a basic implementation of the functionalities that should be provided
	* by any formatter used by javac. Among the main features provided by AbstractDiagnosticFormatter are:
	*
	* <ul>
	* <li> Provides a standard implementation of the visitor-like methods defined in the interface DiagnisticFormatter.
	* Those implementations are specifically targeting JCDiagnostic objects.
	* <li> Provides basic support for i18n and a method for executing all locale-dependent conversions
	* <li> Provides the formatting logic for rendering the arguments of a JCDiagnostic object.
	* <ul>
	*
	* <p><b>This is NOT part of any supported API.
	* 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 abstract class AbstractDiagnosticFormatter implements DiagnosticFormatter<JCDiagnostic> {

	/**
	* JavacMessages object used by this formatter for i18n.
	*/
	protected JavacMessages messages;

	/**
	* Configuration object used by this formatter
	*/
	private SimpleConfiguration config;

	/**
	* Current depth level of the disgnostic being formatted
	* (!= 0 for subdiagnostics)
	*/
	protected int depth = 0;

	/**
	* All captured types that have been encountered during diagnostic formatting.
	* This info is used by the FormatterPrinter in order to print friendly unique
	* ids for captured types
	*/
	private List<Type> allCaptured = List.nil();

	/**
	* Initialize an AbstractDiagnosticFormatter by setting its JavacMessages object.
	* @param messages
	*/
	protected AbstractDiagnosticFormatter(JavacMessages messages, SimpleConfiguration config) {
	this.messages = messages;
	this.config = config;
	}

	public String formatKind(JCDiagnostic d, Locale l) {
	switch (d.getType()) {
	case FRAGMENT: return "";
	case NOTE: return localize(l, "compiler.note.note");
	case WARNING: return localize(l, "compiler.warn.warning");
	case ERROR: return localize(l, "compiler.err.error");
	default:
	throw new AssertionError("Unknown diagnostic type: " + d.getType());
	}
	}

	@Override
	public String format(JCDiagnostic d, Locale locale) {
	allCaptured = List.nil();
	return formatDiagnostic(d, locale);
	}

	protected abstract String formatDiagnostic(JCDiagnostic d, Locale locale);

	public String formatPosition(JCDiagnostic d, PositionKind pk,Locale l) {
	Assert.check(d.getPosition() != Position.NOPOS);
	return String.valueOf(getPosition(d, pk));
	}
	//where
	private long getPosition(JCDiagnostic d, PositionKind pk) {
	switch (pk) {
	case START: return d.getIntStartPosition();
	case END: return d.getIntEndPosition();
	case LINE: return d.getLineNumber();
	case COLUMN: return d.getColumnNumber();
	case OFFSET: return d.getIntPosition();
	default:
	throw new AssertionError("Unknown diagnostic position: " + pk);
	}
	}

	public String formatSource(JCDiagnostic d, boolean fullname, Locale l) {
	JavaFileObject fo = d.getSource();
	if (fo == null)
	throw new IllegalArgumentException(); // d should have source set
	if (fullname)
	return fo.getName();
	else if (fo instanceof BaseFileObject)
	return ((BaseFileObject) fo).getShortName();
	else
	return BaseFileObject.getSimpleName(fo);
	}

	/**
	* Format the arguments of a given diagnostic.
	*
	* @param d diagnostic whose arguments are to be formatted
	* @param l locale object to be used for i18n
	* @return a Collection whose elements are the formatted arguments of the diagnostic
	*/
	protected Collection<String> formatArguments(JCDiagnostic d, Locale l) {
	ListBuffer<String> buf = new ListBuffer<>();
	for (Object o : d.getArgs()) {
	buf.append(formatArgument(d, o, l));
	}
	return buf.toList();
	}

	/**
	* Format a single argument of a given diagnostic.
	*
	* @param d diagnostic whose argument is to be formatted
	* @param arg argument to be formatted
	* @param l locale object to be used for i18n
	* @return string representation of the diagnostic argument
	*/
	protected String formatArgument(JCDiagnostic d, Object arg, Locale l) {
	if (arg instanceof JCDiagnostic) {
	String s = null;
	depth++;
	try {
	s = formatMessage((JCDiagnostic)arg, l);
	}
	finally {
	depth--;
	}
	return s;
	}
	else if (arg instanceof JCExpression) {
	return expr2String((JCExpression)arg);
	}
	else if (arg instanceof Iterable<?>) {
	return formatIterable(d, (Iterable<?>)arg, l);
	}
	else if (arg instanceof Type) {
	return printer.visit((Type)arg, l);
	}
	else if (arg instanceof Symbol) {
	return printer.visit((Symbol)arg, l);
	}
	else if (arg instanceof JavaFileObject) {
	return ((JavaFileObject)arg).getName();
	}
	else if (arg instanceof Profile) {
	return ((Profile)arg).name;
	}
	else if (arg instanceof Formattable) {
	return ((Formattable)arg).toString(l, messages);
	}
	else {
	return String.valueOf(arg);
	}
	}
	//where
	private String expr2String(JCExpression tree) {
	switch(tree.getTag()) {
	case PARENS:
	return expr2String(((JCParens)tree).expr);
	case LAMBDA:
	case REFERENCE:
	case CONDEXPR:
	return Pretty.toSimpleString(tree);
	default:
	Assert.error("unexpected tree kind " + tree.getKind());
	return null;
	}
	}

	/**
	* Format an iterable argument of a given diagnostic.
	*
	* @param d diagnostic whose argument is to be formatted
	* @param it iterable argument to be formatted
	* @param l locale object to be used for i18n
	* @return string representation of the diagnostic iterable argument
	*/
	protected String formatIterable(JCDiagnostic d, Iterable<?> it, Locale l) {
	StringBuilder sbuf = new StringBuilder();
	String sep = "";
	for (Object o : it) {
	sbuf.append(sep);
	sbuf.append(formatArgument(d, o, l));
	sep = ",";
	}
	return sbuf.toString();
	}

	/**
	* Format all the subdiagnostics attached to a given diagnostic.
	*
	* @param d diagnostic whose subdiagnostics are to be formatted
	* @param l locale object to be used for i18n
	* @return list of all string representations of the subdiagnostics
	*/
	protected List<String> formatSubdiagnostics(JCDiagnostic d, Locale l) {
	List<String> subdiagnostics = List.nil();
	int maxDepth = config.getMultilineLimit(MultilineLimit.DEPTH);
	if (maxDepth == -1 \|\| depth < maxDepth) {
	depth++;
	try {
	int maxCount = config.getMultilineLimit(MultilineLimit.LENGTH);
	int count = 0;
	for (JCDiagnostic d2 : d.getSubdiagnostics()) {
	if (maxCount == -1 \|\| count < maxCount) {
	subdiagnostics = subdiagnostics.append(formatSubdiagnostic(d, d2, l));
	count++;
	}
	else
	break;
	}
	}
	finally {
	depth--;
	}
	}
	return subdiagnostics;
	}

	/**
	* Format a subdiagnostics attached to a given diagnostic.
	*
	* @param parent multiline diagnostic whose subdiagnostics is to be formatted
	* @param sub subdiagnostic to be formatted
	* @param l locale object to be used for i18n
	* @return string representation of the subdiagnostics
	*/
	protected String formatSubdiagnostic(JCDiagnostic parent, JCDiagnostic sub, Locale l) {
	return formatMessage(sub, l);
	}

	/** Format the faulty source code line and point to the error.
	* @param d The diagnostic for which the error line should be printed
	*/
	protected String formatSourceLine(JCDiagnostic d, int nSpaces) {
	StringBuilder buf = new StringBuilder();
	DiagnosticSource source = d.getDiagnosticSource();
	int pos = d.getIntPosition();
	if (d.getIntPosition() == Position.NOPOS)
	throw new AssertionError();
	String line = (source == null ? null : source.getLine(pos));
	if (line == null)
	return "";
	buf.append(indent(line, nSpaces));
	int col = source.getColumnNumber(pos, false);
	if (config.isCaretEnabled()) {
	buf.append("\n");
	for (int i = 0; i < col - 1; i++) {
	buf.append((line.charAt(i) == '\t') ? "\t" : " ");
	}
	buf.append(indent("^", nSpaces));
	}
	return buf.toString();
	}

	protected String formatLintCategory(JCDiagnostic d, Locale l) {
	LintCategory lc = d.getLintCategory();
	if (lc == null)
	return "";
	return localize(l, "compiler.warn.lintOption", lc.option);
	}

	/**
	* Converts a String into a locale-dependent representation accordingly to a given locale.
	*
	* @param l locale object to be used for i18n
	* @param key locale-independent key used for looking up in a resource file
	* @param args localization arguments
	* @return a locale-dependent string
	*/
	protected String localize(Locale l, String key, Object... args) {
	return messages.getLocalizedString(l, key, args);
	}

	public boolean displaySource(JCDiagnostic d) {
	return config.getVisible().contains(DiagnosticPart.SOURCE) &&
	d.getType() != FRAGMENT &&
	d.getIntPosition() != Position.NOPOS;
	}

	public boolean isRaw() {
	return false;
	}

	/**
	* Creates a string with a given amount of empty spaces. Useful for
	* indenting the text of a diagnostic message.
	*
	* @param nSpaces the amount of spaces to be added to the result string
	* @return the indentation string
	*/
	protected String indentString(int nSpaces) {
	String spaces = " ";
	if (nSpaces <= spaces.length())
	return spaces.substring(0, nSpaces);
	else {
	StringBuilder buf = new StringBuilder();
	for (int i = 0 ; i < nSpaces ; i++)
	buf.append(" ");
	return buf.toString();
	}
	}

	/**
	* Indent a string by prepending a given amount of empty spaces to each line
	* of the string.
	*
	* @param s the string to be indented
	* @param nSpaces the amount of spaces that should be prepended to each line
	* of the string
	* @return an indented string
	*/
	protected String indent(String s, int nSpaces) {
	String indent = indentString(nSpaces);
	StringBuilder buf = new StringBuilder();
	String nl = "";
	for (String line : s.split("\n")) {
	buf.append(nl);
	buf.append(indent + line);
	nl = "\n";
	}
	return buf.toString();
	}

	public SimpleConfiguration getConfiguration() {
	return config;
	}

	static public class SimpleConfiguration implements Configuration {

	protected Map<MultilineLimit, Integer> multilineLimits;
	protected EnumSet<DiagnosticPart> visibleParts;
	protected boolean caretEnabled;

	public SimpleConfiguration(Set<DiagnosticPart> parts) {
	multilineLimits = new HashMap<>();
	setVisible(parts);
	setMultilineLimit(MultilineLimit.DEPTH, -1);
	setMultilineLimit(MultilineLimit.LENGTH, -1);
	setCaretEnabled(true);
	}

	@SuppressWarnings("fallthrough")
	public SimpleConfiguration(Options options, Set<DiagnosticPart> parts) {
	this(parts);
	String showSource = null;
	if ((showSource = options.get("showSource")) != null) {
	if (showSource.equals("true"))
	setVisiblePart(DiagnosticPart.SOURCE, true);
	else if (showSource.equals("false"))
	setVisiblePart(DiagnosticPart.SOURCE, false);
	}
	String diagOpts = options.get("diags");
	if (diagOpts != null) {//override -XDshowSource
	Collection<String> args = Arrays.asList(diagOpts.split(","));
	if (args.contains("short")) {
	setVisiblePart(DiagnosticPart.DETAILS, false);
	setVisiblePart(DiagnosticPart.SUBDIAGNOSTICS, false);
	}
	if (args.contains("source"))
	setVisiblePart(DiagnosticPart.SOURCE, true);
	if (args.contains("-source"))
	setVisiblePart(DiagnosticPart.SOURCE, false);
	}
	String multiPolicy = null;
	if ((multiPolicy = options.get("multilinePolicy")) != null) {
	if (multiPolicy.equals("disabled"))
	setVisiblePart(DiagnosticPart.SUBDIAGNOSTICS, false);
	else if (multiPolicy.startsWith("limit:")) {
	String limitString = multiPolicy.substring("limit:".length());
	String[] limits = limitString.split(":");
	try {
	switch (limits.length) {
	case 2: {
	if (!limits[1].equals("*"))
	setMultilineLimit(MultilineLimit.DEPTH, Integer.parseInt(limits[1]));
	}
	case 1: {
	if (!limits[0].equals("*"))
	setMultilineLimit(MultilineLimit.LENGTH, Integer.parseInt(limits[0]));
	}
	}
	}
	catch(NumberFormatException ex) {
	setMultilineLimit(MultilineLimit.DEPTH, -1);
	setMultilineLimit(MultilineLimit.LENGTH, -1);
	}
	}
	}
	String showCaret = null;
	if (((showCaret = options.get("showCaret")) != null) &&
	showCaret.equals("false"))
	setCaretEnabled(false);
	else
	setCaretEnabled(true);
	}

	public int getMultilineLimit(MultilineLimit limit) {
	return multilineLimits.get(limit);
	}

	public EnumSet<DiagnosticPart> getVisible() {
	return EnumSet.copyOf(visibleParts);
	}

	public void setMultilineLimit(MultilineLimit limit, int value) {
	multilineLimits.put(limit, value < -1 ? -1 : value);
	}


	public void setVisible(Set<DiagnosticPart> diagParts) {
	visibleParts = EnumSet.copyOf(diagParts);
	}

	public void setVisiblePart(DiagnosticPart diagParts, boolean enabled) {
	if (enabled)
	visibleParts.add(diagParts);
	else
	visibleParts.remove(diagParts);
	}

	/**
	* Shows a '^' sign under the source line displayed by the formatter
	* (if applicable).
	*
	* @param caretEnabled if true enables caret
	*/
	public void setCaretEnabled(boolean caretEnabled) {
	this.caretEnabled = caretEnabled;
	}

	/**
	* Tells whether the caret display is active or not.
	*
	* @return true if the caret is enabled
	*/
	public boolean isCaretEnabled() {
	return caretEnabled;
	}
	}

	public Printer getPrinter() {
	return printer;
	}

	public void setPrinter(Printer printer) {
	this.printer = printer;
	}

	/**
	* An enhanced printer for formatting types/symbols used by
	* AbstractDiagnosticFormatter. Provides alternate numbering of captured
	* types (they are numbered starting from 1 on each new diagnostic, instead
	* of relying on the underlying hashcode() method which generates unstable
	* output). Also detects cycles in wildcard messages (e.g. if the wildcard
	* type referred by a given captured type C contains C itself) which might
	* lead to infinite loops.
	*/
	protected Printer printer = new Printer() {

	@Override
	protected String localize(Locale locale, String key, Object... args) {
	return AbstractDiagnosticFormatter.this.localize(locale, key, args);
	}
	@Override
	protected String capturedVarId(CapturedType t, Locale locale) {
	return "" + (allCaptured.indexOf(t) + 1);
	}
	@Override
	public String visitCapturedType(CapturedType t, Locale locale) {
	if (!allCaptured.contains(t)) {
	allCaptured = allCaptured.append(t);
	}
	return super.visitCapturedType(t, locale);
	}
	};
	}