Attachment #187942 for bug #65317




/*******************************************************************************
 * Copyright (c) 2009, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.text.tests.Accessor;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.rules.FastPartitioner;

import org.eclipse.jdt.ui.text.IJavaPartitions;


	}

	public void testPasteLongStringWithContinuations() {
		fDocument.set("public class Test2 {\n}");
		JavaAutoIndentStrategy javaAutoIndentStrategy= new JavaAutoIndentStrategy(IJavaPartitions.JAVA_PARTITIONING, null, null);
		DocumentCommand documentCommand= new DocumentCommand() {
		};
		documentCommand.doit= true;
		documentCommand.offset= 21;
		documentCommand.text= "String[]a=new String[] {\n" +
				"\"X.java\",\n" +
				"\"public class X extends B{\n\"\n" +
				"\"    public static int field1;\n\"\n" +
				"\"    public static X xfield;\n\"\n" +
				"\"    public void bar1(int i) {\n\"\n" +
				"\"        field1 = 1;\n\"\n" +
				"\"    }\n\"\n" +
				"\"    public void bar2(int i) {\n\"\n" +
				"\"        this.field1 = 1;\n\"\n" +
				"\"    }\n\"\n" +
				"\"}\n\"\n" +
				"\"class A{\n\"\n" +
				"\"    public static X xA;\n\"\n" +
				"\"}\n\"\n" +
				"\"class B{\n\"\n" +
				"\"    public static int b1;\n\"\n" +
				"\"}\"\n" +
				"};";

		Accessor accessor= new Accessor(javaAutoIndentStrategy, JavaAutoIndentStrategy.class);
		accessor.invoke("smartPaste", new Class[] { IDocument.class, DocumentCommand.class }, new Object[] { fDocument, documentCommand });
		System.out.println(documentCommand.text);
		try {
			IRegion lineDetails= fDocument.getLineInformation(0);
			//System.out.println(fDocument.get(lineDetails.getOffset(), lineDetails.getLength()));
		} catch (BadLocationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	/*
	 * @see junit.framework.TestCase#setUp()
	 */




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		Assert.assertEquals(21, pos);
	}

	public void testPrevIndentationUnit4() {
		fDocument.set("\tint a;\n" +
			"\tif (true)\n" +
			"\t\treturn a\n" +
			"");

		int pos= fScanner.findReferencePosition(29);
		Assert.assertEquals(28, pos);
	}

	public void testPrevIndentationUnit5() {
		fDocument.set("\tint a;\n" +

		Assert.assertEquals("\t\t", indent);
	}

	public void testIndentation2() {
		fDocument.set("\tint a;\n" +
			"\tif (true)\n" +
			"\t\treturn a");

		String indent= fScanner.computeIndentation(28).toString();
		Assert.assertEquals("\t\t", indent);
	}

	public void testIndentation3() {
		fDocument.set("\tint a;\n" +
			"\tif (true)\n" +
			"\t\treturn a;");

		String indent= fScanner.computeIndentation(29).toString();
		Assert.assertEquals("\t\t", indent);
	}

	public void testIndentation4() {
		fDocument.set("\tint a;\n" +
			"\tif (true)\n" +
			"\t\treturn a\n" +
			"");

		String indent= fScanner.computeIndentation(29).toString();
		Assert.assertEquals("\t\t", indent);
	}

	public void testIndentation5() {
		fDocument.set("\tint a;\n" +
			"\tif (true)\n" +

    	Assert.assertEquals("					", indent);

    }

	public void testContinuationIndentationOfForStatement() throws Exception {
		fDocument.set("\tfor (int i = (2 * 2); i < array.length; i++) {\n" +
				"\tint i= 25;\n" +
				"\t}");

		String indent= fScanner.computeIndentation(22).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(27).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(39).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(40).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(5).toString();
		Assert.assertEquals("\t", indent);
		indent= fScanner.computeIndentation(45).toString();
		Assert.assertEquals("\t", indent);
		indent= fScanner.computeIndentation(60).toString();
		Assert.assertEquals("\t", indent);
	}

	public void testContinuationIndentationOfBooleanExpression() throws Exception {
		fDocument.set("\tboolean a = true || false;\n" +
				"\tboolean b = a || false;\n");

		String indent= fScanner.computeIndentation(20).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(40).toString();
		Assert.assertEquals("\t\t", indent);
	}

	public void testContinuationIndentationOfReturnStatement() throws Exception {
		fDocument.set("\t\treturn \"I'm such a long string that you have to split me to see the whole line without scrolling around\"\n");

		String indent= fScanner.computeIndentation(8).toString();
		Assert.assertEquals("\t\t\t", indent);
		indent= fScanner.computeIndentation(21).toString();
		Assert.assertEquals("\t\t\t", indent);
		indent= fScanner.computeIndentation(38).toString();
		Assert.assertEquals("\t\t\t", indent);
	}

	public void testContinuationIndentationOfAssignmentStatement() throws Exception {
		fDocument.set("\tint i= 5+");

		String indent= fScanner.computeIndentation(7).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(10).toString();
		Assert.assertEquals("\t\t", indent);
	}

	public void testContinuationIndentationOfThrowsClause() throws Exception {
		fDocument.set("\tprivate void thrower() throws java.sql.SQLException, java.io.IOException {");

		String indent= fScanner.computeIndentation(23).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(24).toString();
		Assert.assertEquals("\t\t", indent);
	}

	public void testContinuationIndentationOfBrackets() throws Exception {
		fDocument.set("\tprivate void helper2(boolean[] booleans) {\n\t}");

		String indent= fScanner.computeIndentation(31).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(30).toString();
		Assert.assertEquals("\t                             ", indent);

		fDocument.set("\tif (booleans[0]) {\n\t\tString[] aString= new String[]{\"a\", \"b\"};\n\t\tbooleans[5]= true;\n\t}");
		indent= fScanner.computeIndentation(16).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(14).toString();
		Assert.assertEquals("\t             ", indent);
		indent= fScanner.computeIndentation(30).toString();
		Assert.assertEquals("\t\t\t", indent);
		indent= fScanner.computeIndentation(52).toString();
		Assert.assertEquals("\t\t\t", indent);
		indent= fScanner.computeIndentation(77).toString();
		Assert.assertEquals("\t\t\t", indent);
	}

	public void testContinuationIndentationOfStrings() throws Exception {
		fDocument.set("\tString[] i = new String[] {\n\t\t\"X.java\",\n\t\t\"public class X extends B{\"\n\t\t+ \"test\"\n\t\t+ \"    public \"};");

		String indent= fScanner.computeIndentation(73).toString();
		Assert.assertEquals("\t\t\t", indent);
		indent= fScanner.computeIndentation(84).toString();
		Assert.assertEquals("\t\t\t", indent);

		fDocument.set("\tString[] i = new String[] {\n\t\t\"X.java\",\n\t\t\"public class X extends B{\" +\n\t\t\"test\" +\n\t\t\"    public\"\n};");

		indent= fScanner.computeIndentation(75).toString();
		Assert.assertEquals("\t\t\t", indent);
	}


	public void testContinuationIndentation1() throws Exception {
		fDocument.set("\treturn (thisIsAVeryLongName == 1 && anotherVeryLongName == 1)\n" +
				"\t\t|| thisIsAVeryLongName == 2;");

		String indent= fScanner.computeIndentation(68).toString();
		Assert.assertEquals("\t\t", indent);
		indent= fScanner.computeIndentation(88).toString();
		Assert.assertEquals("\t\t", indent);
	}

	public void testContinuationIndentation2() {
		fDocument.set("\tint a;\n" +
				"\tif (true)\n" +
				"\t\treturn a\n" +
				"");

		int pos= fScanner.findReferencePosition(29);
		Assert.assertEquals(21, pos);
	}

	public void testContinuationIndentation3() {
		fDocument.set("\tint a;\n" +
				"\tif (true)\n" +
				"\t\treturn a");

		String indent= fScanner.computeIndentation(28).toString();
		Assert.assertEquals("\t\t\t", indent);
	}

	public void testContinuationIndentation4() {
		fDocument.set("\tint a;\n" +
				"\tif (true)\n" +
				"\t\treturn a;");

		String indent= fScanner.computeIndentation(29).toString();
		Assert.assertEquals("\t\t\t", indent);
	}

	public void testContinuationIndentation5() {
		fDocument.set("\tint a;\n" +
				"\tif (true)\n" +
				"\t\treturn a\n" +
				"");

		String indent= fScanner.computeIndentation(29).toString();
		Assert.assertEquals("\t\t\t", indent);
	}
}

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/internal/ui/text/JavaHeuristicScanner.java (-6 / +34 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 59-64 Link Here
59	private static final char EQUAL= '=';	59	private static final char EQUAL= '=';
60	private static final char LANGLE= '<';	60	private static final char LANGLE= '<';
61	private static final char RANGLE= '>';	61	private static final char RANGLE= '>';
		62	private static final char PLUS= '+';
62		63
63	/**	64	/**
64	* Specifies the stop condition, upon which the <code>scanXXX</code> methods will decide whether	65	* Specifies the stop condition, upon which the <code>scanXXX</code> methods will decide whether
Lines 333-338 Link Here
333	return TokenLESSTHAN;	334	return TokenLESSTHAN;
334	case RANGLE:	335	case RANGLE:
335	return TokenGREATERTHAN;	336	return TokenGREATERTHAN;
		337	case PLUS:
		338	return TokenPLUS;
336	}	339	}
337		340
338	// else	341	// else
Lines 405-410 Link Here
405	return TokenLESSTHAN;	408	return TokenLESSTHAN;
406	case RANGLE:	409	case RANGLE:
407	return TokenGREATERTHAN;	410	return TokenGREATERTHAN;
		411	case PLUS:
		412	return TokenPLUS;
408	}	413	}
409		414
410	// else	415	// else
Lines 485-490 Link Here
485	return TokenSTATIC;	490	return TokenSTATIC;
486	if ("switch".equals(s)) //$NON-NLS-1$	491	if ("switch".equals(s)) //$NON-NLS-1$
487	return TokenSWITCH;	492	return TokenSWITCH;
		493	if ("throws".equals(s)) //$NON-NLS-1$
		494	return TokenTHROWS;
488	break;	495	break;
489	case 7:	496	case 7:
490	if ("default".equals(s)) //$NON-NLS-1$	497	if ("default".equals(s)) //$NON-NLS-1$
Lines 672-684 Link Here
672	}	679	}
673		680
674	/**	681	/**
675	* Finds the lowest position <code>p</code> in <code>fDocument</code> such that <code>start</code> <= p <	682	* Finds the highest position in <code>fDocument</code> such that the position is <=
676	* <code>bound</code> and <code>condition.stop(fDocument.getChar(p), p)</code> evaluates to <code>true</code>.	683	* <code>position</code> and > <code>bound</code> and
677	*	684	* <code>Character.isWhitespace(fDocument.getChar(pos))</code> evaluates to <code>false</code>
		685	* and the position can be in any partition.
		686	*
		687	* @param position the first character position in <code>fDocument</code> to be considered
		688	* @param bound the first position in <code>fDocument</code> to not consider any more, with
		689	* <code>bound</code> < <code>position</code>, or <code>UNBOUND</code>
		690	* @return the highest position of a non-whitespace character in (<code>bound</code>,
		691	* <code>position</code>] that resides in a Java partition, or <code>NOT_FOUND</code> if
		692	* none can be found
		693	* @since 3.7
		694	*/
		695	public int findNonWhitespaceBackwardInAnyPartition(int position, int bound) {
		696	return scanBackward(position, bound, fNonWS);
		697	}
		698
		699	/**
		700	* Finds the lowest position <code>p</code> in <code>fDocument</code> such that
		701	* <code>start</code> <= p < <code>bound</code> and
		702	* <code>condition.stop(fDocument.getChar(p), p)</code> evaluates to <code>true</code>.
		703	*
678	* @param start the first character position in <code>fDocument</code> to be considered	704	* @param start the first character position in <code>fDocument</code> to be considered
679	* @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> > <code>start</code>, or <code>UNBOUND</code>	705	* @param bound the first position in <code>fDocument</code> to not consider any more, with
		706	* <code>bound</code> > <code>start</code>, or <code>UNBOUND</code>
680	* @param condition the <code>StopCondition</code> to check	707	* @param condition the <code>StopCondition</code> to check
681	* @return the lowest position in [<code>start</code>, <code>bound</code>) for which <code>condition</code> holds, or <code>NOT_FOUND</code> if none can be found	708	* @return the lowest position in [<code>start</code>, <code>bound</code>) for which
		709	* <code>condition</code> holds, or <code>NOT_FOUND</code> if none can be found
682	*/	710	*/
683	public int scanForward(int start, int bound, StopCondition condition) {	711	public int scanForward(int start, int bound, StopCondition condition) {
684	Assert.isLegal(start >= 0);	712	Assert.isLegal(start >= 0);




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.jdt.internal.corext.util.CodeFormatterUtil;

import org.eclipse.jdt.internal.ui.JavaPlugin;

/**
 * Uses the {@link org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner} to

		final boolean prefTernaryDeepAlign;
		final int prefTernaryIndent;
		final int prefCaseIndent;
		final int prefAssignmentIndent;
		final int prefCaseBlockIndent;
		final int prefSimpleIndent;
		final int prefBracketIndent;

				prefTernaryDeepAlign= false;
				prefTernaryIndent= prefContinuationIndent;
				prefCaseIndent= 0;
				prefAssignmentIndent= prefBlockIndent;
				prefCaseBlockIndent= prefBlockIndent;
				prefIndentBracesForBlocks= false;
				prefSimpleIndent= (prefIndentBracesForBlocks && prefBlockIndent == 0) ? 1 : prefBlockIndent;

				prefTernaryDeepAlign= prefTernaryDeepAlign();
				prefTernaryIndent= prefTernaryIndent();
				prefCaseIndent= prefCaseIndent();
				prefAssignmentIndent= prefAssignmentIndent();
				prefCaseBlockIndent= prefCaseBlockIndent();
				prefIndentBracesForBlocks= prefIndentBracesForBlocks();
				prefSimpleIndent= prefSimpleIndent();

				return 0;
		}

		private int prefAssignmentIndent() {
			return prefBlockIndent();
		}

		private int prefCaseBlockIndent() {
			if (DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES)))
				return prefBlockIndent();

		boolean matchBrace= false;
		boolean matchParen= false;
		boolean matchCase= false;
		boolean throwsClause= false;

		// account for un-indentation characters already typed in, but after position
		// if they are on a line by themselves, the indentation gets adjusted

					case Symbols.TokenLBRACE: // for opening-brace-on-new-line style
						if (bracelessBlockStart && !fPrefs.prefIndentBracesForBlocks)
							unindent= true;
						else if ((prevToken == Symbols.TokenCOLON || prevToken == Symbols.TokenEQUAL) && !fPrefs.prefIndentBracesForArrays)
							unindent= true;
						else if (!bracelessBlockStart && fPrefs.prefIndentBracesForMethods)
							indent= true;

						if (isFirstTokenOnLine)
							matchParen= true;
						break;
					case Symbols.TokenTHROWS:
						throwsClause= true;
						break;
					case Symbols.TokenPLUS:
						int position= handleStringContinuation(offset);
						if (position != JavaHeuristicScanner.NOT_FOUND) {
							fAlign= JavaHeuristicScanner.NOT_FOUND;
							fIndent= fPrefs.prefContinuationIndent;
							return position;
						}
						break;
				}
			} catch (BadLocationException e) {
			}

			danglingElse= false;
		}

		int ref= findReferencePosition(offset, danglingElse, matchBrace, matchParen, matchCase, throwsClause);
		if (unindent)
			fIndent--;
		if (indent)

	}

	/**
	 * Specifically handles the case of extra indentation for second line of string continuation.
	 * 
	 * @param offset the offset for which the reference is computed
	 * @return the reference statement relative to which <code>offset</code> should be indented, or
	 *         {@link JavaHeuristicScanner#NOT_FOUND}
	 * @since 3.7
	 */
	private int handleStringContinuation(int offset) {
		int prevNonWSCharPosition= fScanner.findNonWhitespaceBackwardInAnyPartition(offset - 1, JavaHeuristicScanner.UNBOUND);
		if (prevNonWSCharPosition != JavaHeuristicScanner.NOT_FOUND) {
			try {
				char c= fDocument.getChar(prevNonWSCharPosition);
				if (c == '"' || c == '+') {
					int initialLine= fDocument.getLineOfOffset(offset);
					nextToken(offset);
					while (fToken == Symbols.TokenPLUS) {
						if ((initialLine - fLine) > 1)
							return JavaHeuristicScanner.NOT_FOUND;
						nextToken();
					}
					int lineDiff= initialLine - fLine;
					if (lineDiff > 0) {
						int bound= fDocument.getLineOffset(fLine) + fDocument.getLineLength(fLine) - 1;
						int nextNonWSCharPosition= fScanner.findNonWhitespaceForwardInAnyPartition(fPosition + 1, bound);
						if (lineDiff < 3 && fPreviousPos != offset && nextNonWSCharPosition != JavaHeuristicScanner.NOT_FOUND && fDocument.getChar(nextNonWSCharPosition) != '"')
							return fPreviousPos;
						else
							return fPosition;
					}
				}
			} catch (BadLocationException e) {
				JavaPlugin.log(e);
			}
		}
		return JavaHeuristicScanner.NOT_FOUND;
	}

	/**
	 * Returns the reference position regarding to indentation for <code>position</code>, or
	 * <code>NOT_FOUND</code>.<code>fIndent</code> will contain the relative indentation (in
	 * indentation units, not characters) after the call. If there is a special alignment (e.g. for
	 * a method declaration where parameters should be aligned), <code>fAlign</code> will contain
	 * the absolute position of the alignment reference in <code>fDocument</code>, otherwise
	 * <code>fAlign</code> is set to <code>JavaHeuristicScanner.NOT_FOUND</code>. This method calls
	 * {@link #findReferencePosition(int, boolean, boolean, boolean, boolean, boolean)
	 * findReferencePosition(offset, danglingElse, matchBrace, matchParen, matchCase, throwsClause)}
	 * where <code>throwsClause</code> indicates whether a throws clause was found at
	 * <code>position</code>.
	 * 
	 * @param offset the offset for which the reference is computed
	 * @param danglingElse whether a dangling else should be assumed at <code>position</code>
	 * @param matchBrace whether the position of the matching brace should be returned instead of
	 *            doing code analysis
	 * @param matchParen whether the position of the matching parenthesis should be returned instead
	 *            of doing code analysis
	 * @param matchCase whether the position of a switch statement reference should be returned
	 *            (either an earlier case statement or the switch block brace)
	 * @return the reference statement relative to which <code>position</code> should be indented,
	 *         or {@link JavaHeuristicScanner#NOT_FOUND}
	 *         should be indented, or {@link JavaHeuristicScanner#NOT_FOUND}
	 */
	public int findReferencePosition(int offset, boolean danglingElse, boolean matchBrace, boolean matchParen, boolean matchCase) {
		return findReferencePosition(offset, danglingElse, matchBrace, matchParen, matchCase, false);
	}

	/**
	 * Returns the reference position regarding to indentation for <code>position</code>, or
	 * <code>NOT_FOUND</code>.<code>fIndent</code> will contain the relative indentation (in
	 * indentation units, not characters) after the call. If there is a special alignment (e.g. for
	 * a method declaration where parameters should be aligned), <code>fAlign</code> will contain
	 * the absolute position of the alignment reference in <code>fDocument</code>, otherwise
	 * <code>fAlign</code> is set to <code>JavaHeuristicScanner.NOT_FOUND</code>.
	 * 
	 * @param offset the offset for which the reference is computed
	 * @param danglingElse whether a dangling else should be assumed at <code>position</code>
	 * @param matchBrace whether the position of the matching brace should be returned instead of
	 *            doing code analysis
	 * @param matchParen whether the position of the matching parenthesis should be returned instead
	 *            of doing code analysis
	 * @param matchCase whether the position of a switch statement reference should be returned
	 *            (either an earlier case statement or the switch block brace)
	 * @param throwsClause whether a throws clause was found at <code>position</code>
	 * @return the reference statement relative to which <code>position</code> should be indented,
	 *         or {@link JavaHeuristicScanner#NOT_FOUND}
	 * @since 3.7
	 */
	public int findReferencePosition(int offset, boolean danglingElse, boolean matchBrace, boolean matchParen, boolean matchCase, boolean throwsClause) {
		fIndent= 0; // the indentation modification
		fAlign= JavaHeuristicScanner.NOT_FOUND;
		fPosition= offset;

			} else {
				// if we can't find the matching brace, the heuristic is to unindent
				// by one against the normal position
				int pos= findReferencePosition(offset, danglingElse, false, matchParen, matchCase, throwsClause);
				fIndent--;
				return pos;
			}

			else {
				// if we can't find the matching paren, the heuristic is to unindent
				// by one against the normal position
				int pos= findReferencePosition(offset, danglingElse, matchBrace, false, matchCase, throwsClause);
				fIndent--;
				return pos;
			}

				int pos= fPosition;
				if (!skipScope())
					fPosition= pos;
				return skipToStatementStart(danglingElse, false);
			case Symbols.TokenSEMICOLON:
				// this is the 90% case: after a statement block
				// the end of the previous statement / block previous.end
				// search to the end of the statement / block before the previous; the token just after that is previous.start
				pos= fPosition;
				if (isForStatement()) {
					fIndent= fPrefs.prefContinuationIndent;
					return fPosition;
				} else {
					fPosition= pos;
					return skipToStatementStart(danglingElse, false);
				}
			// scope introduction: special treat who special is
			case Symbols.TokenLPAREN:
			case Symbols.TokenLBRACE:


			case Symbols.TokenEQUAL:
				// indent assignments
				return handleEqual();
				return fPosition;

			case Symbols.TokenCOLON:
				// TODO handle ternary deep indentation


			case Symbols.TokenTRY:
				return skipToStatementStart(danglingElse, false);

			case Symbols.TokenRBRACKET:
				fIndent= fPrefs.prefContinuationIndent;
				return fPosition;

			case Symbols.TokenRPAREN:
				if (throwsClause) {
					fIndent= fPrefs.prefContinuationIndent;
					return fPosition;
				}
				int line= fLine;
				if (skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN)) {
					int scope= fPosition;

				fLine= line;

				return skipToPreviousListItemOrListStart();
			case Symbols.TokenRETURN:
				fIndent= fPrefs.prefContinuationIndent;
				return fPosition;
			case Symbols.TokenCOMMA:
				// inside a list of some type
				// easy if there is already a list item before with its own indentation - we just align

	}

	/**
	 * Checks if the statement at position is itself a continuation of the previous, else sets the
	 * indentation to Continuation Indent.
	 * 
	 * @return the position of the token
	 * @since 3.7
	 */
	private int handleEqual() {
		try {
			//If this line is itself continuation of the previous then do nothing
			IRegion line= fDocument.getLineInformationOfOffset(fPosition);
			int nonWS= fScanner.findNonWhitespaceBackward(line.getOffset(), JavaHeuristicScanner.UNBOUND);
			if (nonWS != Symbols.TokenEOF) {
				int tokenAtPreviousLine= fScanner.nextToken(nonWS, nonWS + 1);
				if (tokenAtPreviousLine != Symbols.TokenSEMICOLON && tokenAtPreviousLine != Symbols.TokenRBRACE && tokenAtPreviousLine != Symbols.TokenLBRACE
						&& tokenAtPreviousLine != Symbols.TokenEOF)
					return fPosition;
			}
		} catch (BadLocationException e) {
			return fPosition;
		}

		fIndent= fPrefs.prefContinuationIndent;
		return fPosition;
	}

	/**
	 * Checks if the semicolon at the current position is part of a for statement.
	 * 
	 * @return returns <code>true</code> if current position is part of for statement
	 * @since 3.7
	 */
	private boolean isForStatement() {
		int semiColonCount= 1;
		while (true) {
			nextToken();
			switch (fToken) {
				case Symbols.TokenFOR:
					return true;
				case Symbols.TokenLBRACE:
					return false;
				case Symbols.TokenSEMICOLON:
					semiColonCount++;
					if (semiColonCount > 2)
						return false;
					break;
				case Symbols.TokenEOF:
					return false;
			}
		}
	}

	/**
	 * Skips to the start of a statement that ends at the current position.
	 *
	 * @param danglingElse whether to indent aligned with the last <code>if</code>

					return handleScopeIntroduction(startPosition + 1);

				case Symbols.TokenSEMICOLON:
					int savedPosition= fPosition;
					if (isForStatement())
						fIndent= fPrefs.prefContinuationIndent;
					else
						fPosition= savedPosition;
					return fPosition;
				case Symbols.TokenQUESTIONMARK:
					if (fPrefs.prefTernaryDeepAlign) {

						fIndent= fPrefs.prefTernaryIndent;
						return fPosition;
					}
				case Symbols.TokenRETURN:
					fIndent= fPrefs.prefContinuationIndent;
					return fPosition;
				case Symbols.TokenEQUAL:
					return handleEqual();
				case Symbols.TokenEOF:
					return 0;


Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/internal/ui/text/java/JavaAutoIndentStrategy.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 715-721 Link Here
715	}	715	}
716	return;	716	return;
717	}	717	}
718	removeJavaStuff(temp);
719	} else {	718	} else {
720	changed= insertLength != 0;	719	changed= insertLength != 0;
721	}	720	}
Lines 729-734 Link Here
729		728
730	}	729	}
731		730
		731	removeJavaStuff(temp);
732	temp.stopRewriteSession(session);	732	temp.stopRewriteSession(session);
733	newText= temp.get(prefix.length(), temp.getLength() - prefix.length());	733	newText= temp.get(prefix.length(), temp.getLength() - prefix.length());
734		734

Return to bug 65317

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/text/tests/JavaAutoIndentStrategyTest.java (-1 / +43 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.	2	* Copyright (c) 2009, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 19-27 Link Here
19		19
20	import org.eclipse.text.tests.Accessor;	20	import org.eclipse.text.tests.Accessor;
21		21
		22	import org.eclipse.jface.text.BadLocationException;
22	import org.eclipse.jface.text.Document;	23	import org.eclipse.jface.text.Document;
23	import org.eclipse.jface.text.DocumentCommand;	24	import org.eclipse.jface.text.DocumentCommand;
24	import org.eclipse.jface.text.IDocument;	25	import org.eclipse.jface.text.IDocument;
		26	import org.eclipse.jface.text.IRegion;
25	import org.eclipse.jface.text.rules.FastPartitioner;	27	import org.eclipse.jface.text.rules.FastPartitioner;
26		28
27	import org.eclipse.jdt.ui.text.IJavaPartitions;	29	import org.eclipse.jdt.ui.text.IJavaPartitions;
Lines 88-93 Link Here
88		90
89	}	91	}
90		92
		93	public void testPasteLongStringWithContinuations() {
		94	fDocument.set("public class Test2 {\n}");
		95	JavaAutoIndentStrategy javaAutoIndentStrategy= new JavaAutoIndentStrategy(IJavaPartitions.JAVA_PARTITIONING, null, null);
		96	DocumentCommand documentCommand= new DocumentCommand() {
		97	};
		98	documentCommand.doit= true;
		99	documentCommand.offset= 21;
		100	documentCommand.text= "String[]a=new String[] {\n" +
		101	"\"X.java\",\n" +
		102	"\"public class X extends B{\n\"\n" +
		103	"\" public static int field1;\n\"\n" +
		104	"\" public static X xfield;\n\"\n" +
		105	"\" public void bar1(int i) {\n\"\n" +
		106	"\" field1 = 1;\n\"\n" +
		107	"\" }\n\"\n" +
		108	"\" public void bar2(int i) {\n\"\n" +
		109	"\" this.field1 = 1;\n\"\n" +
		110	"\" }\n\"\n" +
		111	"\"}\n\"\n" +
		112	"\"class A{\n\"\n" +
		113	"\" public static X xA;\n\"\n" +
		114	"\"}\n\"\n" +
		115	"\"class B{\n\"\n" +
		116	"\" public static int b1;\n\"\n" +
		117	"\"}\"\n" +
		118	"};";
		119
		120	Accessor accessor= new Accessor(javaAutoIndentStrategy, JavaAutoIndentStrategy.class);
		121	accessor.invoke("smartPaste", new Class[] { IDocument.class, DocumentCommand.class }, new Object[] { fDocument, documentCommand });
		122	System.out.println(documentCommand.text);
		123	try {
		124	IRegion lineDetails= fDocument.getLineInformation(0);
		125	//System.out.println(fDocument.get(lineDetails.getOffset(), lineDetails.getLength()));
		126	} catch (BadLocationException e) {
		127	// TODO Auto-generated catch block
		128	e.printStackTrace();
		129	}
		130
		131	}
		132
91	/*	133	/*
92	* @see junit.framework.TestCase#setUp()	134	* @see junit.framework.TestCase#setUp()
93	*/	135	*/

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/text/tests/JavaHeuristicScannerTest.java (-38 / +145 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 110-124 Link Here
110	Assert.assertEquals(21, pos);	110	Assert.assertEquals(21, pos);
111	}	111	}
112		112
113	public void testPrevIndentationUnit4() {
114	fDocument.set("\tint a;\n" +
115	"\tif (true)\n" +
116	"\t\treturn a\n" +
117	"");
118
119	int pos= fScanner.findReferencePosition(29);
120	Assert.assertEquals(28, pos);
121	}
122		113
123	public void testPrevIndentationUnit5() {	114	public void testPrevIndentationUnit5() {
124	fDocument.set("\tint a;\n" +	115	fDocument.set("\tint a;\n" +
Lines 325-358 Link Here
325	Assert.assertEquals("\t\t", indent);	316	Assert.assertEquals("\t\t", indent);
326	}	317	}
327		318
328	public void testIndentation2() {
329	fDocument.set("\tint a;\n" +
330	"\tif (true)\n" +
331	"\t\treturn a");
332
333	String indent= fScanner.computeIndentation(28).toString();
334	Assert.assertEquals("\t\t", indent);
335	}
336
337	public void testIndentation3() {
338	fDocument.set("\tint a;\n" +
339	"\tif (true)\n" +
340	"\t\treturn a;");
341
342	String indent= fScanner.computeIndentation(29).toString();
343	Assert.assertEquals("\t\t", indent);
344	}
345
346	public void testIndentation4() {
347	fDocument.set("\tint a;\n" +
348	"\tif (true)\n" +
349	"\t\treturn a\n" +
350	"");
351
352	String indent= fScanner.computeIndentation(29).toString();
353	Assert.assertEquals("\t\t", indent);
354	}
355
356	public void testIndentation5() {	319	public void testIndentation5() {
357	fDocument.set("\tint a;\n" +	320	fDocument.set("\tint a;\n" +
358	"\tif (true)\n" +	321	"\tif (true)\n" +
Lines 873-876 Link Here
873	Assert.assertEquals(" ", indent);	836	Assert.assertEquals(" ", indent);
874		837
875	}	838	}
		839
		840	public void testContinuationIndentationOfForStatement() throws Exception {
		841	fDocument.set("\tfor (int i = (2 * 2); i < array.length; i++) {\n" +
		842	"\tint i= 25;\n" +
		843	"\t}");
		844
		845	String indent= fScanner.computeIndentation(22).toString();
		846	Assert.assertEquals("\t\t", indent);
		847	indent= fScanner.computeIndentation(27).toString();
		848	Assert.assertEquals("\t\t", indent);
		849	indent= fScanner.computeIndentation(39).toString();
		850	Assert.assertEquals("\t\t", indent);
		851	indent= fScanner.computeIndentation(40).toString();
		852	Assert.assertEquals("\t\t", indent);
		853	indent= fScanner.computeIndentation(5).toString();
		854	Assert.assertEquals("\t", indent);
		855	indent= fScanner.computeIndentation(45).toString();
		856	Assert.assertEquals("\t", indent);
		857	indent= fScanner.computeIndentation(60).toString();
		858	Assert.assertEquals("\t", indent);
		859	}
		860
		861	public void testContinuationIndentationOfBooleanExpression() throws Exception {
		862	fDocument.set("\tboolean a = true \|\| false;\n" +
		863	"\tboolean b = a \|\| false;\n");
		864
		865	String indent= fScanner.computeIndentation(20).toString();
		866	Assert.assertEquals("\t\t", indent);
		867	indent= fScanner.computeIndentation(40).toString();
		868	Assert.assertEquals("\t\t", indent);
		869	}
		870
		871	public void testContinuationIndentationOfReturnStatement() throws Exception {
		872	fDocument.set("\t\treturn \"I'm such a long string that you have to split me to see the whole line without scrolling around\"\n");
		873
		874	String indent= fScanner.computeIndentation(8).toString();
		875	Assert.assertEquals("\t\t\t", indent);
		876	indent= fScanner.computeIndentation(21).toString();
		877	Assert.assertEquals("\t\t\t", indent);
		878	indent= fScanner.computeIndentation(38).toString();
		879	Assert.assertEquals("\t\t\t", indent);
		880	}
		881
		882	public void testContinuationIndentationOfAssignmentStatement() throws Exception {
		883	fDocument.set("\tint i= 5+");
		884
		885	String indent= fScanner.computeIndentation(7).toString();
		886	Assert.assertEquals("\t\t", indent);
		887	indent= fScanner.computeIndentation(10).toString();
		888	Assert.assertEquals("\t\t", indent);
		889	}
		890
		891	public void testContinuationIndentationOfThrowsClause() throws Exception {
		892	fDocument.set("\tprivate void thrower() throws java.sql.SQLException, java.io.IOException {");
		893
		894	String indent= fScanner.computeIndentation(23).toString();
		895	Assert.assertEquals("\t\t", indent);
		896	indent= fScanner.computeIndentation(24).toString();
		897	Assert.assertEquals("\t\t", indent);
		898	}
		899
		900	public void testContinuationIndentationOfBrackets() throws Exception {
		901	fDocument.set("\tprivate void helper2(boolean[] booleans) {\n\t}");
		902
903	String indent= fScanner.computeIndentation(31).toString();
904	Assert.assertEquals("\t\t", indent);
905	indent= fScanner.computeIndentation(30).toString();
906	Assert.assertEquals("\t ", indent);
907
908	fDocument.set("\tif (booleans[0]) {\n\t\tString[] aString= new String[]{\"a\", \"b\"};\n\t\tbooleans[5]= true;\n\t}");
909	indent= fScanner.computeIndentation(16).toString();
910	Assert.assertEquals("\t\t", indent);
911	indent= fScanner.computeIndentation(14).toString();
912	Assert.assertEquals("\t ", indent);
913	indent= fScanner.computeIndentation(30).toString();
914	Assert.assertEquals("\t\t\t", indent);
915	indent= fScanner.computeIndentation(52).toString();
916	Assert.assertEquals("\t\t\t", indent);
917	indent= fScanner.computeIndentation(77).toString();
918	Assert.assertEquals("\t\t\t", indent);
919	}
920
921	public void testContinuationIndentationOfStrings() throws Exception {
922	fDocument.set("\tString[] i = new String[] {\n\t\t\"X.java\",\n\t\t\"public class X extends B{\"\n\t\t+ \"test\"\n\t\t+ \" public \"};");
923
924	String indent= fScanner.computeIndentation(73).toString();
925	Assert.assertEquals("\t\t\t", indent);
926	indent= fScanner.computeIndentation(84).toString();
927	Assert.assertEquals("\t\t\t", indent);
928
929	fDocument.set("\tString[] i = new String[] {\n\t\t\"X.java\",\n\t\t\"public class X extends B{\" +\n\t\t\"test\" +\n\t\t\" public\"\n};");
930
931	indent= fScanner.computeIndentation(75).toString();
932	Assert.assertEquals("\t\t\t", indent);
933	}
934
935
936	public void testContinuationIndentation1() throws Exception {
937	fDocument.set("\treturn (thisIsAVeryLongName == 1 && anotherVeryLongName == 1)\n" +
938	"\t\t\|\| thisIsAVeryLongName == 2;");
939
940	String indent= fScanner.computeIndentation(68).toString();
941	Assert.assertEquals("\t\t", indent);
942	indent= fScanner.computeIndentation(88).toString();
943	Assert.assertEquals("\t\t", indent);
944	}
945
946	public void testContinuationIndentation2() {
947	fDocument.set("\tint a;\n" +
948	"\tif (true)\n" +
949	"\t\treturn a\n" +
950	"");
951
952	int pos= fScanner.findReferencePosition(29);
953	Assert.assertEquals(21, pos);
954	}
955
956	public void testContinuationIndentation3() {
957	fDocument.set("\tint a;\n" +
958	"\tif (true)\n" +
959	"\t\treturn a");
960
961	String indent= fScanner.computeIndentation(28).toString();
962	Assert.assertEquals("\t\t\t", indent);
963	}
964
965	public void testContinuationIndentation4() {
966	fDocument.set("\tint a;\n" +
967	"\tif (true)\n" +
968	"\t\treturn a;");
969
970	String indent= fScanner.computeIndentation(29).toString();
971	Assert.assertEquals("\t\t\t", indent);
972	}
973
974	public void testContinuationIndentation5() {
975	fDocument.set("\tint a;\n" +
976	"\tif (true)\n" +
977	"\t\treturn a\n" +
978	"");
979
980	String indent= fScanner.computeIndentation(29).toString();
981	Assert.assertEquals("\t\t\t", indent);
982	}
876	}	983	}