<ul>

<li>

Added a new preference to force the formatter to try to keep nested expressions on one line.

<p>

This new preference is controlled with the option:</p>

<code>DefaultCodeFormatterConstants.FORMATTER_KEEP_NESTED_EXPRESSIONS_ON_ONE_LINE</code>

<pre>

/**

 * FORMATTER / Option to wrap outer expressions first in nested expressions

 *     - option id:         "org.eclipse.jdt.core.formatter.wrap_outer_expressions_first_when_nested"

 *     - possible values:   { TRUE, FALSE }

 *     - default:           TRUE

 *

 * This option changes the formatter behavior when nested method calls are encountered.

 * Since 3.6, the formatter tries to wrap outermost method calls first to have a better output.

 * For example, let's say we are using the Eclipse built-in profile with a max line width=40+space for tab policy.

 * Then consider the following snippet:

 *

 * public class X01 {

 *     void test() {

 *         foo(bar(1, 2, 3, 4), bar(5, 6, 7, 8));

 *     }

 * }

 *

 * With this new strategy, the formatter will wrap the line earlier, between the arguments of the message call

 * for this example, and then it will allow to keep each nested call on a single line.

 * Hence, the output will be:

 *

 * public class X01 {

 *     void test() {

 *         foo(bar(1, 2, 3, 4),

 *             bar(5, 6, 7, 8));

 *     }

 * }

 *

 * Important notes:

 * 1. This new behavior is automatically activated (ie. the default value for this preference is {@link #TRUE}).

 *    If the backward compatibility regarding previous versions formatter behavior (ie. before 3.6 version) is necessary,

 *    then the preference needs to be set to the {@link #FALSE} value to retrieve the previous formatter behavior.

 * 2. The new strategy currently only applies to nested method calls, but might be extended to other nested expressions in future versions

 * 

 * @see #TRUE

 * @see #FALSE

 * @since 3.6

 */

</pre>

See bug <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=313524">313524</a> for more details.

</li>

</ul>

	 * FORMATTER / Option to wrap outer expressions first in nested expressions

	 *     - option id:         "org.eclipse.jdt.core.formatter.wrap_outer_expressions_first_when_nested"

	 *     - possible values:   { TRUE, FALSE }

	 *     - default:           TRUE

	 * </pre>

	 * <p>

	 * This option changes the formatter behavior when nested method calls are encountered.

	 * Since 3.6, the formatter tries to wrap outermost method calls first to have a better output.</p>

	 * <p>For example, let's say we are using the Eclipse built-in profile with a max line width=40+space for tab policy.

	 * Then consider the following snippet:</p>

	 * <pre>

	 * public class X01 {

	 *     void test() {

	 *         foo(bar(1, 2, 3, 4), bar(5, 6, 7, 8));

	 *     }

	 * }

	 * </pre>

	 * <p>With this new strategy, the formatter will wrap the line earlier, between the arguments of the message call

	 * for this example, and then it will allow to keep each nested call on a single line.</p>

	 * <p>Hence, the output will be:</p>

	 * <pre>

	 * public class X01 {

	 *     void test() {

	 *         foo(bar(1, 2, 3, 4),

	 *             bar(5, 6, 7, 8));

	 *     }

	 * }

	 * </pre>

	 * <p>

	 * </p>

	 * <p><b><u>Important notes</u></b>:</p>

	 * <ol>

	 * <li>This new behavior is automatically activated (ie. the default value for this preference is {@link #TRUE}).

	 * If the backward compatibility regarding previous versions formatter behavior (ie. before 3.6 version) is necessary,

	 * then the preference needs to be set to the {@link #FALSE} value to retrieve the previous formatter behavior.</li>

	 * <li>The new strategy currently only applies to nested method calls, but might be extended to other nested expressions in future versions</li>

	 * </ol>

	 * 

	 * @see #TRUE

	 * @see #FALSE

	 * @since 3.6

	 */

	public static final String FORMATTER_WRAP_OUTER_EXPRESSIONS_FIRST_WHEN_NESTED = JavaCore.PLUGIN_ID + ".formatter.wrap_outer_expressions_first_when_nested"; //$NON-NLS-1$

	/**

	 * <pre>

	public boolean wrap_outer_expressions_first_when_nested;

		options.put(DefaultCodeFormatterConstants.FORMATTER_WRAP_OUTER_EXPRESSIONS_FIRST_WHEN_NESTED, this.wrap_outer_expressions_first_when_nested ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);

		final Object wrapWrapOuterExpressionsFirstWhenNestedOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_WRAP_OUTER_EXPRESSIONS_FIRST_WHEN_NESTED);

		if (wrapWrapOuterExpressionsFirstWhenNestedOption != null) {

			this.wrap_outer_expressions_first_when_nested = DefaultCodeFormatterConstants.TRUE.equals(wrapWrapOuterExpressionsFirstWhenNestedOption);

		}

		this.wrap_outer_expressions_first_when_nested = true;

		this.wrap_outer_expressions_first_when_nested = true;

		if (this.formatter.preferences.wrap_outer_expressions_first_when_nested) {

			handleLineTooLongSmartly();

			return;

		}

		// search for closest breakable alignment, using tiebreak rules

		// look for outermost breakable one

		int relativeDepth = 0, outerMostDepth = -1;

		Alignment targetAlignment = this.currentAlignment;

		while (targetAlignment != null){

			if (targetAlignment.tieBreakRule == Alignment.R_OUTERMOST && targetAlignment.couldBreak()){

				outerMostDepth = relativeDepth;

			}

			targetAlignment = targetAlignment.enclosing;

			relativeDepth++;

		}

		if (outerMostDepth >= 0) {

			throw new AlignmentException(AlignmentException.LINE_TOO_LONG, outerMostDepth);

		}

		// look for innermost breakable one

		relativeDepth = 0;

		targetAlignment = this.currentAlignment;

		while (targetAlignment != null){

			if (targetAlignment.couldBreak()){

				throw new AlignmentException(AlignmentException.LINE_TOO_LONG, relativeDepth);

			}

			targetAlignment = targetAlignment.enclosing;

			relativeDepth++;

		}

		// did not find any breakable location - proceed

	}

	private void handleLineTooLongSmartly() {