Attachment #158645 for bug #260381

Lines 31-36 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/FormatJavadocBlock.java (-2 / +25 lines)
31	final static int PARAM_TAG = 0x0020;	31	final static int PARAM_TAG = 0x0020;
32	final static int IN_PARAM_TAG = 0x0040;	32	final static int IN_PARAM_TAG = 0x0040;
33	final static int IN_DESCRIPTION = 0x0080;	33	final static int IN_DESCRIPTION = 0x0080;
		34	final static int IMMUTABLE = 0x0100;
34		35
35	// constants	36	// constants
36	final static int MAX_TAG_HIERARCHY = 10;	37	final static int MAX_TAG_HIERARCHY = 10;
Lines 53-58 Link Here
53	case TAG_THROWS_VALUE:	54	case TAG_THROWS_VALUE:
54	case TAG_EXCEPTION_VALUE:	55	case TAG_EXCEPTION_VALUE:
55	this.flags \|= PARAM_TAG;	56	this.flags \|= PARAM_TAG;
		57	break;
		58	case TAG_CODE_VALUE:
		59	case TAG_LITERAL_VALUE:
		60	this.flags \|= IMMUTABLE;
		61	break;
56	}	62	}
57	}	63	}
58		64
Lines 141-146 Link Here
141	}	147	}
142	}	148	}
143	addNode(text);	149	addNode(text);
		150	if (isImmutable()) {
		151	text.immutable = true;
		152	}
144	}	153	}
145		154
146	void clean() {	155	void clean() {
Lines 322-327 Link Here
322	return (this.flags & PARAM_TAG) == PARAM_TAG;	331	return (this.flags & PARAM_TAG) == PARAM_TAG;
323	}	332	}
324		333
		334	/**
		335	* Returns whether the block is immutable or not.
		336	* <p>
		337	* Currently, only @code inline tag block are considered as immutable.
		338	*
		339	* @return <code>true</code> if the block is immutable,
		340	* <code>false</code> otherwise.
		341	*/
		342	public boolean isImmutable() {
		343	return (this.flags & IMMUTABLE) == IMMUTABLE;
		344	}
		345
325	void setHeaderLine(int javadocLineStart) {	346	void setHeaderLine(int javadocLineStart) {
326	if (javadocLineStart == this.lineStart) {	347	if (javadocLineStart == this.lineStart) {
327	this.flags \|= ON_HEADER_LINE;	348	this.flags \|= ON_HEADER_LINE;
Lines 332-340 Link Here
332	}	353	}
333		354
334	protected void toString(StringBuffer buffer) {	355	protected void toString(StringBuffer buffer) {
335	if ((this.flags & INLINED) != 0) buffer.append('{');	356	boolean inlined = (this.flags & INLINED) != 0;
		357	if (inlined) buffer.append(" {"); //$NON-NLS-1$
336	buffer.append('@');	358	buffer.append('@');
337	buffer.append(this.tagValue);	359	buffer.append(TAG_NAMES[this.tagValue]);
338	super.toString(buffer);	360	super.toString(buffer);
339	if (this.reference == null) {	361	if (this.reference == null) {
340	buffer.append('\n');	362	buffer.append('\n');
Lines 345-350 Link Here
345	}	367	}
346	if (this.nodesPtr > -1) {	368	if (this.nodesPtr > -1) {
347	for (int i = 0; i <= this.nodesPtr; i++) {	369	for (int i = 0; i <= this.nodesPtr; i++) {
		370	if (inlined) buffer.append('\t');
348	this.nodes[i].toString(buffer);	371	this.nodes[i].toString(buffer);
349	}	372	}
350	}	373	}




	return false;
}

/**
 * Returns whether the node is immutable or not. If <code>true</code>, then
 * the formatter will leave it contents unchanged.
 *
 * @return <code>true</code> if the node is immutable, <code>false</code>
 * 	otherwise.
 */
public boolean isImmutable() {
	return false;
}

public String toString() {
	StringBuffer buffer = new StringBuffer();
	toString(buffer);




	long[] separators;
	int separatorsPtr = -1;
	private int htmlTagIndex = -1;
	boolean immutable = false;
	FormatJavadocNode[] htmlNodes;
	int[] htmlIndexes;
	int htmlNodesPtr = -1;

 * child node.
 */
void appendText(FormatJavadocText text) {
	this.immutable = text.immutable;
	if (this.depth == text.depth) {
		addSeparator(text);
		this.sourceEnd = text.sourceEnd;

 *
 * @return <code>true</code> if the node is an immutable tag,
 *		<code>false</code> otherwise.
 *@deprecated Use {@link #isImmutable()} instead
 */
public boolean isImmutableHtmlTag() {
	return this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_TAGS_ID_MASK) == JAVADOC_IMMUTABLE_TAGS_ID;

}

/**
 * Returns whether the text is immutable or not.
 * <p>
 * A text in considered as immutable when it  belongs to an immutable block
 * or when it's an immutable html tag.
 * </p>
 *
 * @return <code>true</code> if the node is an immutable tag,
 *		<code>false</code> otherwise.
 */
public boolean isImmutable() {
	return this.immutable || (this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_TAGS_ID_MASK) == JAVADOC_IMMUTABLE_TAGS_ID);

}

/**
 * Returns whether the text at the given separator index position is after a
 * separator tag or not.
 *




		this.scanner.resetTo(this.index, this.javadocEnd);
		return true;
	}
	this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
	return false;
}


			}
			this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);
		}
		this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
	}
	return valid;
}

	if (!valid) {
		this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);
		this.index = this.tagSourceEnd+1;
		this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
	}
	return valid;
}

			if (length == TAG_LINK_LENGTH && CharOperation.equals(TAG_LINK, tagName)) {
				this.tagValue = TAG_LINK_VALUE;
				if (this.inlineTagStarted || (this.kind & COMPLETION_PARSER) != 0) {
					valid = parseReference();
				} else {
					// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=53290
					// Cannot have @link outside inline comment

	} else if (this.invalidTagName) {
		this.textStart = previousPosition;
	} else if (this.astPtr == ptr) {
		this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
		createTag();
	}
	return true;

		// If invalid, restart from the end tag position
		this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);
		this.index = this.tagSourceEnd+1;
		this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
	}
	return valid;
}




							if (newLines > 0)  newLines = 1;
						}
					}
					if (newLines == 0 && (!node.isImmutable() || block.reference != null)) {
						newLines = printJavadocBlockNodesNewLines(block, node, previousEnd);
					}
					printJavadocGapLines(previousEnd+1, nodeStart-1, newLines, clearBlankLines, false, null);

			// Print node
			if (node.isText()) {
				FormatJavadocText text = (FormatJavadocText) node;
				if (text.isImmutable()) {
					// Indent if new line was added
					if (newLines > 0 && this.commentIndentation != null) {
				    	addInsertEdit(node.sourceStart, this.commentIndentation);
				    	this.column += this.commentIndentation.length();
					    	this.column += this.commentIndentation.length();
						}
						printJavadocHtmlImmutableTag(text, block, newLines > 0);
						this.column += getTextLength(block, text);
					} else {
						printJavadocHtmlTag(text, block, newLines>0);
					}
					printJavadocImmutableText(text, block, newLines > 0);
					this.column += getTextLength(block, text);
				} else if (text.isHtmlTag()) {
					printJavadocHtmlTag(text, block, newLines>0);
				} else {
					printJavadocText(text, block, newLines>0);
				}

 	    try {
			this.scanner.resetTo(nodeStart , node.sourceEnd);
	    	int length = 0;
	    	int newLines = 0;
	    	boolean newLine = false;
			boolean headerLine = block.isHeaderLine() && this.lastNumberOfNewLines == 0;
			int firstColumn = 1 + this.indentationLevel + BLOCK_LINE_PREFIX_LENGTH;
			if (this.commentIndentation != null) firstColumn += this.commentIndentation.length();
			if (headerLine) maxColumn++;
			FormatJavadocText text = null;
			boolean isImmutableNode = node.isImmutable();
			boolean nodeIsText = node.isText();
			if (nodeIsText) {
	    		text = (FormatJavadocText)node;
			} else {
				FormatJavadocBlock inlinedBlock = (FormatJavadocBlock)node;
				if (isImmutableNode) {
					text = (FormatJavadocText) inlinedBlock.getLastNode();
		    		length += inlinedBlock.tagEnd - inlinedBlock.sourceStart + 1;  // tag length
					this.scanner.resetTo(text.sourceStart , node.sourceEnd);
				}
			}
	    	if (text != null) {
    			if (isImmutableNode) {
			    	if (nodeStart > (previousEnd+1)) {
			    		length++; // include space between nodes
			    	}

		    				int token = this.scanner.getNextToken();
		    				switch (token) {
		    					case TerminalTokens.TokenNameWHITESPACE:
		    						if (nodeIsText) {
			    						if (CharOperation.indexOf('\n', this.scanner.source, this.scanner.startPosition, this.scanner.currentPosition) >= 0) {
			    							return 0;
			    						}
		    						}
		    						length = 1;
		    						break;

	    				}
	    				lastColumn += length;
	    				if (lastColumn > maxColumn) {
	    					return 1;
				    		if (headerLine) {
								maxColumn--;
								headerLine = false;
			    			}
							lastColumn = firstColumn;
						}
	    			}
	    			return 0;
    			}
    			if (text.isHtmlTag()) {
    				if (text.getHtmlTagID() == JAVADOC_SINGLE_BREAK_TAG_ID) {

	private int getTextLength(FormatJavadocBlock block, FormatJavadocText text) {

		// Special case for immutable tags
		if (text.isImmutable()) {
			this.scanner.resetTo(text.sourceStart , text.sourceEnd);
			int textLength = 0;
			while (!this.scanner.atEnd()) {

		}
	}

	private void printJavadocImmutableText(FormatJavadocText text, FormatJavadocBlock block, boolean textOnNewLine) {

		try {
			// Iterate on text line separators
			int lineNumber = text.lineStart;
			this.scanner.tokenizeWhiteSpace = false;
			StringBuffer buffer = null;
			for (int idx=0, max=text.separatorsPtr; idx<=max ; idx++) {
				int start = (int) text.separators[idx];
				int lineStart = Util.getLineNumber(start, this.lineEnds, lineNumber-1, this.maxLines);
				if (buffer == null) {
					buffer = new StringBuffer();
					this.column = 1;
					printIndentationIfNecessary(buffer);
					buffer.append(BLOCK_LINE_PREFIX);
					this.column += BLOCK_LINE_PREFIX_LENGTH;
				}
				while (lineNumber < lineStart) {
					int end = this.lineEnds[lineNumber-1];
					this.scanner.resetTo(end, start);

					if (this.scanner.currentCharacter == ' ') {
						this.scanner.getNextChar();
					}
					if (buffer == null) {
						buffer = new StringBuffer();
						this.column = 1;
						printIndentationIfNecessary(buffer);
						buffer.append(BLOCK_LINE_PREFIX);
						this.column += BLOCK_LINE_PREFIX_LENGTH;
					}
					addReplaceEdit(end+1, this.scanner.getCurrentTokenEndPosition(), buffer.toString());
					lineNumber++;
				}

				if (textStart < previousEnd) {
					addReplaceEdit(textStart, previousEnd, buffer.toString());
				}
				boolean immutable = node.isImmutable();
				if (newLines == 0) {
					newLines = printJavadocBlockNodesNewLines(block, node, previousEnd);
				}

					    	addInsertEdit(node.sourceStart, this.commentIndentation);
					    	this.column += this.commentIndentation.length();
						}
						printJavadocImmutableText(htmlTag, block, textOnNewLine);
						this.column += getTextLength(block, htmlTag);
						linesAfter = 0;
					} else {




		"\n" + 
		"	/**\n" + 
		"	 * Returns the change directly associated with this change element or <code\n" + 
		"	 * null</code> if the element isn\'t associated with a change.\n" + 
		"	 * if the element isn\'t associated with a change.\n" + 
		"	 * \n" + 
		"	 * @return the change or <code>null</code>\n" + 
		"	 */\n" + 

}

/**
 * @bug 260381: [formatter] Javadoc formatter breaks {@code ...} tags.
 * @test Ensure that the @code tag is similar to <code> HTML tag
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=260381"
 */
public void testBug260381() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Comments that can be formated in several lines...\n" + 
		" * \n" + 
		" * @author Myself\n" + 
		" * @version {@code $Revision: 1.2 $ $Date: 2009/01/07 12:27:50 $ $Author:myself $ $Source: /projects/cvs/module/project/src/com/foo/Main.java,v $}\n" + 
		" */\n" + 
		"public class X01 {\n" + 
		"}\n";
	formatSource(source);
}
public void testBug260381b() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Comments that can be formated in several lines...\n" + 
		" * \n" + 
		" * @author Myself\n" + 
		" * @version <code>$Revision: 1.2 $ $Date: 2009/01/07 12:27:50 $ $Author:myself $ $Source: /projects/cvs/module/project/src/com/foo/Main.java,v $</code>\n" + 
		" */\n" + 
		"public class X01b {\n" + 
		"}\n";
	formatSource(source);
}
public void testBug260381c() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Comments that can be formated in several lines...\n" + 
		" * \n" + 
		" * @author Myself\n" + 
		" * @version\n" + 
		" *          <code>3.0 xxxxxxxxxxxxxx xwxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx</code>\n" + 
		" */\n" + 
		"public class X01c {\n" + 
		"}\n";
	formatSource(source,
		"/**\n" + 
		" * Comments that can be formated in several lines...\n" + 
		" * \n" + 
		" * @author Myself\n" + 
		" * @version <code>3.0 xxxxxxxxxxxxxx xwxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx</code>\n" + 
		" */\n" + 
		"public class X01c {\n" + 
		"}\n"
	);
}
public void testBug260381d() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Comments that can be formated in several lines...\n" + 
		" * \n" + 
		" * @author Myself\n" + 
		" *  @see Object <code>$Revision: 1.2 $ $Date: 2009/01/07 12:27:50 $ $Author:myself $ $Source: /projects/cvs/module/project/src/com/foo/Main.java,v $</code>\n" + 
		" */\n" + 
		"public class X02 {\n" + 
		"}\n";
	formatSource(source,
		"/**\n" + 
		" * Comments that can be formated in several lines...\n" + 
		" * \n" + 
		" * @author Myself\n" + 
		" * @see Object\n" + 
		" *      <code>$Revision: 1.2 $ $Date: 2009/01/07 12:27:50 $ $Author:myself $ $Source: /projects/cvs/module/project/src/com/foo/Main.java,v $</code>\n" + 
		" */\n" + 
		"public class X02 {\n" + 
		"}\n"
	);
}
public void testBug260381e() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Comments that can be formated in several lines...\n" + 
		" * \n" + 
		" * {@code $Revision: 1.2 $ $Date: 2009/01/07 12:27:50 $ $Author:myself $\n" + 
		" * $Source: /projects/cvs/module/project/src/com/foo/Main.java,v $}\n" + 
		" */\n" + 
		"public class X03 {\n" + 
		"}\n";
	formatSource(source);
}
public void testBug260381f() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Literal inline tag should also be untouched by the formatter\n" + 
		" * \n" + 
		" * @version {@literal $Revision: 1.2 $ $Date: 2009/01/07 12:27:50 $ $Author:myself $ $Source: /projects/cvs/module/project/src/com/foo/Main.java,v $}\n" + 
		" */\n" + 
		"public class X04 {\n" + 
		"\n" + 
		"}\n";
	formatSource(source);
}
public void testBug260381_wksp2_01() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"public interface I01 {\n" + 
		"	/**\n" + 
		"	 * Returns the composition of two functions. For {@code f: A->B} and\n" + 
		"	 * {@code g: B->C}, composition is defined as the function h such that\n" + 
		"	 * {@code h(a) == g(f(a))} for each {@code a}.\n" + 
		"	 *\n" + 
		"	 * @see <a href=\"//en.wikipedia.org/wiki/Function_composition\">\n" + 
		"	 * function composition</a>\n" + 
		"	 *\n" + 
		"	 * @param g the second function to apply\n" + 
		"	 * @param f the first function to apply\n" + 
		"	 * @return the composition of {@code f} and {@code g}\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I01 {\n" + 
		"	/**\n" + 
		"	 * Returns the composition of two functions. For {@code f: A->B} and\n" + 
		"	 * {@code g: B->C}, composition is defined as the function h such that\n" + 
		"	 * {@code h(a) == g(f(a))} for each {@code a}.\n" + 
		"	 * \n" + 
		"	 * @see <a href=\"//en.wikipedia.org/wiki/Function_composition\"> function\n" + 
		"	 *      composition</a>\n" + 
		"	 * \n" + 
		"	 * @param g\n" + 
		"	 *            the second function to apply\n" + 
		"	 * @param f\n" + 
		"	 *            the first function to apply\n" + 
		"	 * @return the composition of {@code f} and {@code g}\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_01b() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"public interface I01b {\n" + 
		"  /**\n" + 
		"   * Returns the composition of two functions. For <code> f: A->B</code> and\n" + 
		"   * <code> g: B->C</code>, composition is defined as the function h such that\n" + 
		"   * <code> h(a) == g(f(a))</code> for each <code> a</code>.\n" + 
		"   *\n" + 
		"   * @see <a href=\"//en.wikipedia.org/wiki/Function_composition\">\n" + 
		"   * function composition</a>\n" + 
		"   *\n" + 
		"   * @param g the second function to apply\n" + 
		"   * @param f the first function to apply\n" + 
		"   * @return the composition of <code> f</code> and <code> g</code>\n" + 
		"   */\n" + 
		"  void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I01b {\n" + 
		"	/**\n" + 
		"	 * Returns the composition of two functions. For <code> f: A->B</code> and\n" + 
		"	 * <code> g: B->C</code>, composition is defined as the function h such that\n" + 
		"	 * <code> h(a) == g(f(a))</code> for each <code> a</code>.\n" + 
		"	 * \n" + 
		"	 * @see <a href=\"//en.wikipedia.org/wiki/Function_composition\"> function\n" + 
		"	 *      composition</a>\n" + 
		"	 * \n" + 
		"	 * @param g\n" + 
		"	 *            the second function to apply\n" + 
		"	 * @param f\n" + 
		"	 *            the first function to apply\n" + 
		"	 * @return the composition of <code> f</code> and <code> g</code>\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_01c() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"public interface I01c {\n" + 
		"  /**\n" + 
		"   * Returns the composition of two functions. For <code> f: A->B</code> and\n" + 
		"   * <code>\n" + 
		"   * g: B->C\n" + 
		"   * </code>,\n" + 
		"   * composition is defined as the function h such that\n" + 
		"   * <code>\n" + 
		"   *  h(a) == g(f(a))\n" + 
		"   *  </code>\n" + 
		"   *  for each\n" + 
		"   *  <code>\n" + 
		"   *  a\n" + 
		"   *  </code>.\n" + 
		"   *\n" + 
		"   * @see <a href=\"//en.wikipedia.org/wiki/Function_composition\">\n" + 
		"   * function composition</a>\n" + 
		"   *\n" + 
		"   * @param g the second function to apply\n" + 
		"   * @param f the first function to apply\n" + 
		"   * @return the composition of <code> f</code> and <code> g</code>\n" + 
		"   */\n" + 
		"  void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I01c {\n" + 
		"	/**\n" + 
		"	 * Returns the composition of two functions. For <code> f: A->B</code> and\n" + 
		"	 * <code>\n" + 
		"	 * g: B->C\n" + 
		"	 * </code>, composition is defined as the function h such that <code>\n" + 
		"	 *  h(a) == g(f(a))\n" + 
		"	 *  </code> for each <code>\n" + 
		"	 *  a\n" + 
		"	 *  </code>.\n" + 
		"	 * \n" + 
		"	 * @see <a href=\"//en.wikipedia.org/wiki/Function_composition\"> function\n" + 
		"	 *      composition</a>\n" + 
		"	 * \n" + 
		"	 * @param g\n" + 
		"	 *            the second function to apply\n" + 
		"	 * @param f\n" + 
		"	 *            the first function to apply\n" + 
		"	 * @return the composition of <code> f</code> and <code> g</code>\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_02() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"\n" + 
		"public interface I02 {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * Implementations of {@code computeNext} <b>must</b> invoke this method when\n" + 
		"   * there are no elements left in the iteration.\n" + 
		"   *\n" + 
		"   * @return {@code null}; a convenience so your {@link #computeNext}\n" + 
		"   *     implementation can use the simple statement {@code return endOfData();}\n" + 
		"   */\n" + 
		"  void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I02 {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * Implementations of {@code computeNext} <b>must</b> invoke this method\n" + 
		"	 * when there are no elements left in the iteration.\n" + 
		"	 * \n" + 
		"	 * @return {@code null}; a convenience so your {@link #computeNext}\n" + 
		"	 *         implementation can use the simple statement\n" + 
		"	 *         {@code return endOfData();}\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_03() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"\n" + 
		"public interface I03 {\n" + 
		"  /**\n" + 
		"   * A builder for creating immutable bimap instances, especially {@code public\n" + 
		"   * static final} bimaps (\"constant bimaps\"). Example: <pre>   {@code\n" + 
		"   *\n" + 
		"   *   static final ImmutableBiMap<String, Integer> WORD_TO_INT =\n" + 
		"   *       new ImmutableBiMap.Builder<String, Integer>()\n" + 
		"   *           .put(\"one\", 1)\n" + 
		"   *           .put(\"two\", 2)\n" + 
		"   *           .put(\"three\", 3)\n" + 
		"   *           .build();}</pre>\n" + 
		"   *\n" + 
		"   * For <i>small</i> immutable bimaps, the {@code ImmutableBiMap.of()} methods\n" + 
		"   * are even more convenient.\n" + 
		"   *\n" + 
		"   * <p>Builder instances can be reused - it is safe to call {@link #build}\n" + 
		"   * multiple times to build multiple bimaps in series. Each bimap is a superset\n" + 
		"   * of the bimaps created before it.\n" + 
		"   */\n" + 
		"  void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I03 {\n" + 
		"	/**\n" + 
		"	 * A builder for creating immutable bimap instances, especially\n" + 
		"	 * {@code public static final} bimaps (\"constant bimaps\"). Example:\n" + 
		"	 * \n" + 
		"	 * <pre>\n" + 
		"	 * {\n" + 
		"	 * 	&#064;code\n" + 
		"	 * 	static final ImmutableBiMap&lt;String, Integer&gt; WORD_TO_INT = new ImmutableBiMap.Builder&lt;String, Integer&gt;()\n" + 
		"	 * 			.put(&quot;one&quot;, 1).put(&quot;two&quot;, 2).put(&quot;three&quot;, 3).build();\n" + 
		"	 * }\n" + 
		"	 * </pre>\n" + 
		"	 * \n" + 
		"	 * For <i>small</i> immutable bimaps, the {@code ImmutableBiMap.of()}\n" + 
		"	 * methods are even more convenient.\n" + 
		"	 * \n" + 
		"	 * <p>\n" + 
		"	 * Builder instances can be reused - it is safe to call {@link #build}\n" + 
		"	 * multiple times to build multiple bimaps in series. Each bimap is a\n" + 
		"	 * superset of the bimaps created before it.\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_04() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"\n" + 
		"public interface I04 {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * Returns an immutable multiset containing the given elements.\n" + 
		"   * \n" + 
		"   * <p>The multiset is ordered by the first occurrence of each element. For\n" + 
		"   * example, {@code ImmutableMultiset.copyOf(Arrays.asList(2, 3, 1, 3))} yields\n" + 
		"   * a multiset with elements in the order {@code 2, 3, 3, 1}.\n" + 
		"   *\n" + 
		"   * <p>Note that if {@code c} is a {@code Collection<String>}, then {@code\n" + 
		"   * ImmutableMultiset.copyOf(c)} returns an {@code ImmutableMultiset<String>}\n" + 
		"   * containing each of the strings in {@code c}, while\n" + 
		"   * {@code ImmutableMultiset.of(c)} returns an\n" + 
		"   * {@code ImmutableMultiset<Collection<String>>} containing one element (the\n" + 
		"   * given collection itself).\n" + 
		"   *\n" + 
		"   * <p><b>Note:</b> Despite what the method name suggests, if {@code elements}\n" + 
		"   * is an {@code ImmutableMultiset}, no copy will actually be performed, and\n" + 
		"   * the given multiset itself will be returned.\n" + 
		"   *\n" + 
		"   * @throws NullPointerException if any of {@code elements} is null\n" + 
		"   */\n" + 
		"  void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I04 {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * Returns an immutable multiset containing the given elements.\n" + 
		"	 * \n" + 
		"	 * <p>\n" + 
		"	 * The multiset is ordered by the first occurrence of each element. For\n" + 
		"	 * example, {@code ImmutableMultiset.copyOf(Arrays.asList(2, 3, 1, 3))}\n" + 
		"	 * yields a multiset with elements in the order {@code 2, 3, 3, 1}.\n" + 
		"	 * \n" + 
		"	 * <p>\n" + 
		"	 * Note that if {@code c} is a {@code Collection<String>}, then\n" + 
		"	 * {@code ImmutableMultiset.copyOf(c)} returns an\n" + 
		"	 * {@code ImmutableMultiset<String>} containing each of the strings in\n" + 
		"	 * {@code c}, while {@code ImmutableMultiset.of(c)} returns an\n" + 
		"	 * {@code ImmutableMultiset<Collection<String>>} containing one element (the\n" + 
		"	 * given collection itself).\n" + 
		"	 * \n" + 
		"	 * <p>\n" + 
		"	 * <b>Note:</b> Despite what the method name suggests, if {@code elements}\n" + 
		"	 * is an {@code ImmutableMultiset}, no copy will actually be performed, and\n" + 
		"	 * the given multiset itself will be returned.\n" + 
		"	 * \n" + 
		"	 * @throws NullPointerException\n" + 
		"	 *             if any of {@code elements} is null\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_05() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"\n" + 
		"public interface I05 {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * Indexes the specified values into a {@code Multimap} by applying a\n" + 
		"   * specified function to each item in an {@code Iterable} of values. Each\n" + 
		"   * value will be stored as a value in the specified multimap. The key used to\n" + 
		"   * store that value in the multimap will be the result of calling the function\n" + 
		"   * on that value. Depending on the multimap implementation, duplicate entries\n" + 
		"   * (equal keys and equal values) may be collapsed.\n" + 
		"   *\n" + 
		"   * <p>For example,\n" + 
		"   *\n" + 
		"   * <pre class=\"code\">\n" + 
		"   * List&lt;String> badGuys =\n" + 
		"   *   Arrays.asList(\"Inky\", \"Blinky\", \"Pinky\", \"Pinky\", \"Clyde\");\n" + 
		"   * Function&lt;String, Integer> stringLengthFunction = ...;\n" + 
		"   * Multimap&lt;Integer, String> index = Multimaps.newHashMultimap();\n" + 
		"   * Multimaps.index(badGuys, stringLengthFunction, index);\n" + 
		"   * System.out.println(index); </pre>\n" + 
		"   *\n" + 
		"   * prints\n" + 
		"   *\n" + 
		"   * <pre class=\"code\">\n" + 
		"   * {4=[Inky], 5=[Pinky, Clyde], 6=[Blinky]} </pre>\n" + 
		"   *\n" + 
		"   * The {@link HashMultimap} collapses the duplicate occurrence of\n" + 
		"   * {@code (5, \"Pinky\")}.\n" + 
		"   *\n" + 
		"   * @param values the values to add to the multimap\n" + 
		"   * @param keyFunction the function used to produce the key for each value\n" + 
		"   * @param multimap the multimap to store the key value pairs\n" + 
		"   */\n" + 
		"  void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I05 {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * Indexes the specified values into a {@code Multimap} by applying a\n" + 
		"	 * specified function to each item in an {@code Iterable} of values. Each\n" + 
		"	 * value will be stored as a value in the specified multimap. The key used\n" + 
		"	 * to store that value in the multimap will be the result of calling the\n" + 
		"	 * function on that value. Depending on the multimap implementation,\n" + 
		"	 * duplicate entries (equal keys and equal values) may be collapsed.\n" + 
		"	 * \n" + 
		"	 * <p>\n" + 
		"	 * For example,\n" + 
		"	 * \n" + 
		"	 * <pre class=\"code\">\n" + 
		"	 * List&lt;String> badGuys =\n" + 
		"	 *   Arrays.asList(\"Inky\", \"Blinky\", \"Pinky\", \"Pinky\", \"Clyde\");\n" + 
		"	 * Function&lt;String, Integer> stringLengthFunction = ...;\n" + 
		"	 * Multimap&lt;Integer, String> index = Multimaps.newHashMultimap();\n" + 
		"	 * Multimaps.index(badGuys, stringLengthFunction, index);\n" + 
		"	 * System.out.println(index);\n" + 
		"	 * </pre>\n" + 
		"	 * \n" + 
		"	 * prints\n" + 
		"	 * \n" + 
		"	 * <pre class=\"code\">\n" + 
		"	 * {4=[Inky], 5=[Pinky, Clyde], 6=[Blinky]}\n" + 
		"	 * </pre>\n" + 
		"	 * \n" + 
		"	 * The {@link HashMultimap} collapses the duplicate occurrence of\n" + 
		"	 * {@code (5, \"Pinky\")}.\n" + 
		"	 * \n" + 
		"	 * @param values\n" + 
		"	 *            the values to add to the multimap\n" + 
		"	 * @param keyFunction\n" + 
		"	 *            the function used to produce the key for each value\n" + 
		"	 * @param multimap\n" + 
		"	 *            the multimap to store the key value pairs\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_06() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"\n" + 
		"public interface I06 {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * Adds a number of occurrences of an element to this multiset. Note that if\n" + 
		"   * {@code occurrences == 1}, this method has the identical effect to {@link\n" + 
		"   * #add(Object)}. This method is functionally equivalent (except in the case\n" + 
		"   * of overflow) to the call {@code addAll(Collections.nCopies(element,\n" + 
		"   * occurrences))}, which would presumably perform much more poorly.\n" + 
		"   *\n" + 
		"   * @param element the element to add occurrences of; may be {@code null} only\n" + 
		"   *     if explicitly allowed by the implementation\n" + 
		"   * @param occurrences the number of occurrences of this element to add. May\n" + 
		"   *     be zero, in which case no change will be made.\n" + 
		"   * @return the previous count of this element before the operation; possibly\n" + 
		"   *     zero - TODO: make this the actual behavior!\n" + 
		"   * @throws IllegalArgumentException if {@code occurrences} is negative, or if\n" + 
		"   *     this operation would result in more than {@link Integer#MAX_VALUE}\n" + 
		"   *     occurrences of the element \n" + 
		"   * @throws NullPointerException if {@code element} is null and this\n" + 
		"   *     implementation does not permit null elements. Note that if {@code\n" + 
		"   *     occurrences} is zero, the implementation may opt to return normally.\n" + 
		"   */\n" + 
		"  boolean /*int*/ add(E element, int occurrences);\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I06 {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * Adds a number of occurrences of an element to this multiset. Note that if\n" + 
		"	 * {@code occurrences == 1}, this method has the identical effect to\n" + 
		"	 * {@link #add(Object)}. This method is functionally equivalent (except in\n" + 
		"	 * the case of overflow) to the call\n" + 
		"	 * {@code addAll(Collections.nCopies(element, occurrences))}, which would\n" + 
		"	 * presumably perform much more poorly.\n" + 
		"	 * \n" + 
		"	 * @param element\n" + 
		"	 *            the element to add occurrences of; may be {@code null} only if\n" + 
		"	 *            explicitly allowed by the implementation\n" + 
		"	 * @param occurrences\n" + 
		"	 *            the number of occurrences of this element to add. May be zero,\n" + 
		"	 *            in which case no change will be made.\n" + 
		"	 * @return the previous count of this element before the operation; possibly\n" + 
		"	 *         zero - TODO: make this the actual behavior!\n" + 
		"	 * @throws IllegalArgumentException\n" + 
		"	 *             if {@code occurrences} is negative, or if this operation\n" + 
		"	 *             would result in more than {@link Integer#MAX_VALUE}\n" + 
		"	 *             occurrences of the element\n" + 
		"	 * @throws NullPointerException\n" + 
		"	 *             if {@code element} is null and this implementation does not\n" + 
		"	 *             permit null elements. Note that if {@code occurrences} is\n" + 
		"	 *             zero, the implementation may opt to return normally.\n" + 
		"	 */\n" + 
		"	boolean /* int */add(E element, int occurrences);\n" + 
		"}\n"
	);
}
public void testBug260381_wksp2_07() throws JavaModelException {
	String source = 
		"package wksp2;\n" + 
		"\n" + 
		"public interface I07 {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * Constructs a new, empty multiset, sorted according to the specified\n" + 
		"   * comparator. All elements inserted into the multiset must be <i>mutually\n" + 
		"   * comparable</i> by the specified comparator: {@code comparator.compare(e1,\n" + 
		"   * e2)} must not throw a {@code ClassCastException} for any elements {@code\n" + 
		"   * e1} and {@code e2} in the multiset. If the user attempts to add an element\n" + 
		"   * to the multiset that violates this constraint, the {@code add(Object)} call\n" + 
		"   * will throw a {@code ClassCastException}.\n" + 
		"   *\n" + 
		"   * @param comparator the comparator that will be used to sort this multiset. A\n" + 
		"   *     null value indicates that the elements\' <i>natural ordering</i> should\n" + 
		"   *     be used.\n" + 
		"   */\n" + 
		"  void foo();\n" + 
		"}\n";
	formatSource(source,
		"package wksp2;\n" + 
		"\n" + 
		"public interface I07 {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * Constructs a new, empty multiset, sorted according to the specified\n" + 
		"	 * comparator. All elements inserted into the multiset must be <i>mutually\n" + 
		"	 * comparable</i> by the specified comparator:\n" + 
		"	 * {@code comparator.compare(e1, e2)} must not throw a\n" + 
		"	 * {@code ClassCastException} for any elements {@code e1} and {@code e2} in\n" + 
		"	 * the multiset. If the user attempts to add an element to the multiset that\n" + 
		"	 * violates this constraint, the {@code add(Object)} call will throw a\n" + 
		"	 * {@code ClassCastException}.\n" + 
		"	 * \n" + 
		"	 * @param comparator\n" + 
		"	 *            the comparator that will be used to sort this multiset. A null\n" + 
		"	 *            value indicates that the elements\' <i>natural ordering</i>\n" + 
		"	 *            should be used.\n" + 
		"	 */\n" + 
		"	void foo();\n" + 
		"}\n"
	);
}

/**
 * @bug 260798: [formatter] Strange behavior of never join lines
 * @test Ensure that the formatter indents lines correctly when never join lines pref is activated
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=260798"

Return to bug 260381

Lines 356-361 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/FormatterCommentParser.java (-2 / +5 lines)
356	this.scanner.resetTo(this.index, this.javadocEnd);	356	this.scanner.resetTo(this.index, this.javadocEnd);
357	return true;	357	return true;
358	}	358	}
		359	this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
359	return false;	360	return false;
360	}	361	}
361		362
Lines 382-387 Link Here
382	}	383	}
383	this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);	384	this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);
384	}	385	}
		386	this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
385	}	387	}
386	return valid;	388	return valid;
387	}	389	}
Lines 394-399 Link Here
394	if (!valid) {	396	if (!valid) {
395	this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);	397	this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);
396	this.index = this.tagSourceEnd+1;	398	this.index = this.tagSourceEnd+1;
		399	this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
397	}	400	}
398	return valid;	401	return valid;
399	}	402	}
Lines 506-512 Link Here
506	if (length == TAG_LINK_LENGTH && CharOperation.equals(TAG_LINK, tagName)) {	509	if (length == TAG_LINK_LENGTH && CharOperation.equals(TAG_LINK, tagName)) {
507	this.tagValue = TAG_LINK_VALUE;	510	this.tagValue = TAG_LINK_VALUE;
508	if (this.inlineTagStarted \|\| (this.kind & COMPLETION_PARSER) != 0) {	511	if (this.inlineTagStarted \|\| (this.kind & COMPLETION_PARSER) != 0) {
509	valid= parseReference();	512	valid = parseReference();
510	} else {	513	} else {
511	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=53290	514	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=53290
512	// Cannot have @link outside inline comment	515	// Cannot have @link outside inline comment
Lines 605-611 Link Here
605	} else if (this.invalidTagName) {	608	} else if (this.invalidTagName) {
606	this.textStart = previousPosition;	609	this.textStart = previousPosition;
607	} else if (this.astPtr == ptr) {	610	} else if (this.astPtr == ptr) {
608	this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
609	createTag();	611	createTag();
610	}	612	}
611	return true;	613	return true;
Lines 620-625 Link Here
620	// If invalid, restart from the end tag position	622	// If invalid, restart from the end tag position
621	this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);	623	this.scanner.resetTo(this.tagSourceEnd+1, this.javadocEnd);
622	this.index = this.tagSourceEnd+1;	624	this.index = this.tagSourceEnd+1;
		625	this.tagValue = TAG_OTHERS_VALUE; // tag is invalid, do not keep the parsed tag value
623	}	626	}
624	return valid;	627	return valid;
625	}	628	}

Lines 2866-2872 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/Scribe.java (-38 / +44 lines)
2866	if (newLines > 0) newLines = 1;	2866	if (newLines > 0) newLines = 1;
2867	}	2867	}
2868	}	2868	}
2869	if (newLines == 0) {	2869	if (newLines == 0 && (!node.isImmutable() \|\| block.reference != null)) {
2870	newLines = printJavadocBlockNodesNewLines(block, node, previousEnd);	2870	newLines = printJavadocBlockNodesNewLines(block, node, previousEnd);
2871	}	2871	}
2872	printJavadocGapLines(previousEnd+1, nodeStart-1, newLines, clearBlankLines, false, null);	2872	printJavadocGapLines(previousEnd+1, nodeStart-1, newLines, clearBlankLines, false, null);
Lines 2898-2915 Link Here
2898	// Print node	2898	// Print node
2899	if (node.isText()) {	2899	if (node.isText()) {
2900	FormatJavadocText text = (FormatJavadocText) node;	2900	FormatJavadocText text = (FormatJavadocText) node;
2901	if (text.isHtmlTag()) {	2901	if (text.isImmutable()) {
2902	if (text.isImmutableHtmlTag()) {	2902	// Indent if new line was added
2903	// Indent if new line was added	2903	if (newLines > 0 && this.commentIndentation != null) {
2904	if (newLines > 0 && this.commentIndentation != null) {	2904	addInsertEdit(node.sourceStart, this.commentIndentation);
2905	addInsertEdit(node.sourceStart, this.commentIndentation);	2905	this.column += this.commentIndentation.length();
2906	this.column += this.commentIndentation.length();
2907	}
2908	printJavadocHtmlImmutableTag(text, block, newLines > 0);
2909	this.column += getTextLength(block, text);
2910	} else {
2911	printJavadocHtmlTag(text, block, newLines>0);
2912	}	2906	}
		2907	printJavadocImmutableText(text, block, newLines > 0);
		2908	this.column += getTextLength(block, text);
		2909	} else if (text.isHtmlTag()) {
		2910	printJavadocHtmlTag(text, block, newLines>0);
2913	} else {	2911	} else {
2914	printJavadocText(text, block, newLines>0);	2912	printJavadocText(text, block, newLines>0);
2915	}	2913	}
Lines 2934-2948 Link Here
2934	try {	2932	try {
2935	this.scanner.resetTo(nodeStart , node.sourceEnd);	2933	this.scanner.resetTo(nodeStart , node.sourceEnd);
2936	int length = 0;	2934	int length = 0;
2937	int newLines = 0;
2938	boolean newLine = false;	2935	boolean newLine = false;
2939	boolean headerLine = block.isHeaderLine() && this.lastNumberOfNewLines == 0;	2936	boolean headerLine = block.isHeaderLine() && this.lastNumberOfNewLines == 0;
2940	int firstColumn = 1 + this.indentationLevel + BLOCK_LINE_PREFIX_LENGTH;	2937	int firstColumn = 1 + this.indentationLevel + BLOCK_LINE_PREFIX_LENGTH;
2941	if (this.commentIndentation != null) firstColumn += this.commentIndentation.length();	2938	if (this.commentIndentation != null) firstColumn += this.commentIndentation.length();
2942	if (headerLine) maxColumn++;	2939	if (headerLine) maxColumn++;
2943	if (node.isText()) {	2940	FormatJavadocText text = null;
2944	FormatJavadocText text = (FormatJavadocText)node;	2941	boolean isImmutableNode = node.isImmutable();
2945	if (text.isImmutableHtmlTag()) {	2942	boolean nodeIsText = node.isText();
		2943	if (nodeIsText) {
		2944	text = (FormatJavadocText)node;
		2945	} else {
		2946	FormatJavadocBlock inlinedBlock = (FormatJavadocBlock)node;
		2947	if (isImmutableNode) {
		2948	text = (FormatJavadocText) inlinedBlock.getLastNode();
		2949	length += inlinedBlock.tagEnd - inlinedBlock.sourceStart + 1; // tag length
		2950	this.scanner.resetTo(text.sourceStart , node.sourceEnd);
		2951	}
		2952	}
		2953	if (text != null) {
		2954	if (isImmutableNode) {
2946	if (nodeStart > (previousEnd+1)) {	2955	if (nodeStart > (previousEnd+1)) {
2947	length++; // include space between nodes	2956	length++; // include space between nodes
2948	}	2957	}
Lines 2952-2959 Link Here
2952	int token = this.scanner.getNextToken();	2961	int token = this.scanner.getNextToken();
2953	switch (token) {	2962	switch (token) {
2954	case TerminalTokens.TokenNameWHITESPACE:	2963	case TerminalTokens.TokenNameWHITESPACE:
2955	if (CharOperation.indexOf('\n', this.scanner.source, this.scanner.startPosition, this.scanner.currentPosition) >= 0) {	2964	if (nodeIsText) {
2956	return newLines;	2965	if (CharOperation.indexOf('\n', this.scanner.source, this.scanner.startPosition, this.scanner.currentPosition) >= 0) {
		2966	return 0;
		2967	}
2957	}	2968	}
2958	length = 1;	2969	length = 1;
2959	break;	2970	break;
Lines 2975-2989 Link Here
2975	}	2986	}
2976	lastColumn += length;	2987	lastColumn += length;
2977	if (lastColumn > maxColumn) {	2988	if (lastColumn > maxColumn) {
2978	newLines++;	2989	return 1;
2979	if (headerLine) {
2980	maxColumn--;
2981	headerLine = false;
2982	}
2983	lastColumn = firstColumn;
2984	}	2990	}
2985	}	2991	}
2986	return newLines;	2992	return 0;
2987	}	2993	}
2988	if (text.isHtmlTag()) {	2994	if (text.isHtmlTag()) {
2989	if (text.getHtmlTagID() == JAVADOC_SINGLE_BREAK_TAG_ID) {	2995	if (text.getHtmlTagID() == JAVADOC_SINGLE_BREAK_TAG_ID) {
Lines 3146-3152 Link Here
3146	private int getTextLength(FormatJavadocBlock block, FormatJavadocText text) {	3152	private int getTextLength(FormatJavadocBlock block, FormatJavadocText text) {
3147		3153
3148	// Special case for immutable tags	3154	// Special case for immutable tags
3149	if (text.isImmutableHtmlTag()) {	3155	if (text.isImmutable()) {
3150	this.scanner.resetTo(text.sourceStart , text.sourceEnd);	3156	this.scanner.resetTo(text.sourceStart , text.sourceEnd);
3151	int textLength = 0;	3157	int textLength = 0;
3152	while (!this.scanner.atEnd()) {	3158	while (!this.scanner.atEnd()) {
Lines 3468-3490 Link Here
3468	}	3474	}
3469	}	3475	}
3470		3476
3471	private void printJavadocHtmlImmutableTag(FormatJavadocText text, FormatJavadocBlock block, boolean textOnNewLine) {	3477	private void printJavadocImmutableText(FormatJavadocText text, FormatJavadocBlock block, boolean textOnNewLine) {
3472		3478
3473	try {	3479	try {
3474	// Iterate on text line separators	3480	// Iterate on text line separators
3475	int lineNumber = text.lineStart;	3481	int lineNumber = text.lineStart;
3476	this.scanner.tokenizeWhiteSpace = false;	3482	this.scanner.tokenizeWhiteSpace = false;
3477	StringBuffer buffer = null;	3483	StringBuffer buffer = null;
3478	for (int idx=1, max=text.separatorsPtr; idx<max ; idx++) {	3484	for (int idx=0, max=text.separatorsPtr; idx<=max ; idx++) {
3479	int start = (int) text.separators[idx];	3485	int start = (int) text.separators[idx];
3480	int lineStart = Util.getLineNumber(start, this.lineEnds, lineNumber, this.maxLines);	3486	int lineStart = Util.getLineNumber(start, this.lineEnds, lineNumber-1, this.maxLines);
3481	if (buffer == null) {
3482	buffer = new StringBuffer();
3483	this.column = 1;
3484	printIndentationIfNecessary(buffer);
3485	buffer.append(BLOCK_LINE_PREFIX);
3486	this.column += BLOCK_LINE_PREFIX_LENGTH;
3487	}
3488	while (lineNumber < lineStart) {	3487	while (lineNumber < lineStart) {
3489	int end = this.lineEnds[lineNumber-1];	3488	int end = this.lineEnds[lineNumber-1];
3490	this.scanner.resetTo(end, start);	3489	this.scanner.resetTo(end, start);
Lines 3499-3504 Link Here
3499	if (this.scanner.currentCharacter == ' ') {	3498	if (this.scanner.currentCharacter == ' ') {
3500	this.scanner.getNextChar();	3499	this.scanner.getNextChar();
3501	}	3500	}
		3501	if (buffer == null) {
		3502	buffer = new StringBuffer();
		3503	this.column = 1;
		3504	printIndentationIfNecessary(buffer);
		3505	buffer.append(BLOCK_LINE_PREFIX);
		3506	this.column += BLOCK_LINE_PREFIX_LENGTH;
		3507	}
3502	addReplaceEdit(end+1, this.scanner.getCurrentTokenEndPosition(), buffer.toString());	3508	addReplaceEdit(end+1, this.scanner.getCurrentTokenEndPosition(), buffer.toString());
3503	lineNumber++;	3509	lineNumber++;
3504	}	3510	}
Lines 3562-3568 Link Here
3562	if (textStart < previousEnd) {	3568	if (textStart < previousEnd) {
3563	addReplaceEdit(textStart, previousEnd, buffer.toString());	3569	addReplaceEdit(textStart, previousEnd, buffer.toString());
3564	}	3570	}
3565	boolean immutable = htmlTag == null ? false : htmlTag.isImmutableHtmlTag();	3571	boolean immutable = node.isImmutable();
3566	if (newLines == 0) {	3572	if (newLines == 0) {
3567	newLines = printJavadocBlockNodesNewLines(block, node, previousEnd);	3573	newLines = printJavadocBlockNodesNewLines(block, node, previousEnd);
3568	}	3574	}
Lines 3579-3585 Link Here
3579	addInsertEdit(node.sourceStart, this.commentIndentation);	3585	addInsertEdit(node.sourceStart, this.commentIndentation);
3580	this.column += this.commentIndentation.length();	3586	this.column += this.commentIndentation.length();
3581	}	3587	}
3582	printJavadocHtmlImmutableTag(htmlTag, block, textOnNewLine);	3588	printJavadocImmutableText(htmlTag, block, textOnNewLine);
3583	this.column += getTextLength(block, htmlTag);	3589	this.column += getTextLength(block, htmlTag);
3584	linesAfter = 0;	3590	linesAfter = 0;
3585	} else {	3591	} else {

Lines 31-36 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/FormatJavadocText.java (+18 lines)
31	long[] separators;	31	long[] separators;
32	int separatorsPtr = -1;	32	int separatorsPtr = -1;
33	private int htmlTagIndex = -1;	33	private int htmlTagIndex = -1;
		34	boolean immutable = false;
34	FormatJavadocNode[] htmlNodes;	35	FormatJavadocNode[] htmlNodes;
35	int[] htmlIndexes;	36	int[] htmlIndexes;
36	int htmlNodesPtr = -1;	37	int htmlNodesPtr = -1;
Lines 49-54 Link Here
49	* child node.	50	* child node.
50	*/	51	*/
51	void appendText(FormatJavadocText text) {	52	void appendText(FormatJavadocText text) {
		53	this.immutable = text.immutable;
52	if (this.depth == text.depth) {	54	if (this.depth == text.depth) {
53	addSeparator(text);	55	addSeparator(text);
54	this.sourceEnd = text.sourceEnd;	56	this.sourceEnd = text.sourceEnd;
Lines 167-172 Link Here
167	*	169	*
168	* @return <code>true</code> if the node is an immutable tag,	170	* @return <code>true</code> if the node is an immutable tag,
169	* <code>false</code> otherwise.	171	* <code>false</code> otherwise.
		172	*@deprecated Use {@link #isImmutable()} instead
170	*/	173	*/
171	public boolean isImmutableHtmlTag() {	174	public boolean isImmutableHtmlTag() {
172	return this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_TAGS_ID_MASK) == JAVADOC_IMMUTABLE_TAGS_ID;	175	return this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_TAGS_ID_MASK) == JAVADOC_IMMUTABLE_TAGS_ID;
Lines 174-179 Link Here
174	}	177	}
175		178
176	/**	179	/**
		180	* Returns whether the text is immutable or not.
		181	* <p>
		182	* A text in considered as immutable when it belongs to an immutable block
		183	* or when it's an immutable html tag.
		184	* </p>
		185	*
		186	* @return <code>true</code> if the node is an immutable tag,
		187	* <code>false</code> otherwise.
		188	*/
		189	public boolean isImmutable() {
		190	return this.immutable \|\| (this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_TAGS_ID_MASK) == JAVADOC_IMMUTABLE_TAGS_ID);
		191
		192	}
		193
		194	/**
177	* Returns whether the text at the given separator index position is after a	195	* Returns whether the text at the given separator index position is after a
178	* separator tag or not.	196	* separator tag or not.
179	*	197	*