/* Tracking helpers

 * The following are used to elaborate realistic statistics about binary 

 * expressions. This must be neutralized in the released code.

 * Search the keyword BE_INSTRUMENTATION to reenable.

 * An external device must install a suitable probe so as to monitor the

 * emission of events and publish the results.

	public interface Probe {

		public void ping(int depth);

	}

	public int depthTracker;

	public static Probe probe;

 */

	// BE_INSTRUMENTATION: neutralized in the released code

//	if (left instanceof BinaryExpression && 

//			((left.bits & OperatorMASK) ^ (this.bits & OperatorMASK)) == 0) {

//		this.depthTracker = ((BinaryExpression)left).depthTracker + 1;

//	} else {

//		this.depthTracker = 1;

//	}

// given the current focus of CombinedBinaryExpression on strings concatenation,

// we do not provide a general, non-recursive implementation of generateCode,

// but rely upon generateOptimizedStringConcatenationCreation instead

					// BE_INSTRUMENTATION: neutralized in the released code					

//					if (probe != null) {

//						probe.ping(this.depthTracker);

//					}

/**

 * Separates into a reusable method the subpart of {@link 

 * #resolveType(BlockScope)} that needs to be executed while climbing up the 

 * chain of expressions of this' leftmost branch. For use by {@link 

 * CombinedBinaryExpression#resolveType(BlockScope)}.

 * @param scope the scope within which the resolution occurs

 */

void nonRecursiveResolveTypeUpwards(BlockScope scope) {

	// keep implementation in sync with BinaryExpression#resolveType

	boolean leftIsCast, rightIsCast;

	TypeBinding leftType = this.left.resolvedType;

	if ((rightIsCast = this.right instanceof CastExpression) == true) {

		this.right.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on

	}

	TypeBinding rightType = this.right.resolveType(scope);

	// use the id of the type to navigate into the table

	if (leftType == null || rightType == null) {

		this.constant = Constant.NotAConstant;

		return;

	}

	int leftTypeID = leftType.id;

	int rightTypeID = rightType.id;

	// autoboxing support

	boolean use15specifics = scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5;

	if (use15specifics) {

		if (!leftType.isBaseType() && rightTypeID != TypeIds.T_JavaLangString && rightTypeID != TypeIds.T_null) {

			leftTypeID = scope.environment().computeBoxingType(leftType).id;

		}

		if (!rightType.isBaseType() && leftTypeID != TypeIds.T_JavaLangString && leftTypeID != TypeIds.T_null) {

			rightTypeID = scope.environment().computeBoxingType(rightType).id;

		}

	}

	if (leftTypeID > 15

		|| rightTypeID > 15) { // must convert String + Object || Object + String

		if (leftTypeID == TypeIds.T_JavaLangString) {

			rightTypeID = TypeIds.T_JavaLangObject;

		} else if (rightTypeID == TypeIds.T_JavaLangString) {

			leftTypeID = TypeIds.T_JavaLangObject;

		} else {

			this.constant = Constant.NotAConstant;

			scope.problemReporter().invalidOperator(this, leftType, rightType);

			return;

		}

	}

	if (((this.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {

		if (leftTypeID == TypeIds.T_JavaLangString) {

			this.left.computeConversion(scope, leftType, leftType);

			if (rightType.isArrayType() && ((ArrayBinding) rightType).elementsType() == TypeBinding.CHAR) {

				scope.problemReporter().signalNoImplicitStringConversionForCharArrayExpression(this.right);

			}

		}

		if (rightTypeID == TypeIds.T_JavaLangString) {

			this.right.computeConversion(scope, rightType, rightType);

			if (leftType.isArrayType() && ((ArrayBinding) leftType).elementsType() == TypeBinding.CHAR) {

				scope.problemReporter().signalNoImplicitStringConversionForCharArrayExpression(this.left);

			}

		}

	}

	// the code is an int

	// (cast)  left   Op (cast)  right --> result

	//  0000   0000       0000   0000      0000

	//  <<16   <<12       <<8    <<4       <<0

	// Don't test for result = 0. If it is zero, some more work is done.

	// On the one hand when it is not zero (correct code) we avoid doing the test	

	int operator = (this.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT;

	int operatorSignature = OperatorExpression.OperatorSignatures[operator][(leftTypeID << 4) + rightTypeID];

	this.left.computeConversion(scope, 	TypeBinding.wellKnownType(scope, (operatorSignature >>> 16) & 0x0000F), leftType);

	this.right.computeConversion(scope, TypeBinding.wellKnownType(scope, (operatorSignature >>> 8) & 0x0000F), rightType);

	this.bits |= operatorSignature & 0xF;

	switch (operatorSignature & 0xF) { // record the current ReturnTypeID

		// only switch on possible result type.....

		case T_boolean :

			this.resolvedType = TypeBinding.BOOLEAN;

			break;

		case T_byte :

			this.resolvedType = TypeBinding.BYTE;

			break;

		case T_char :

			this.resolvedType = TypeBinding.CHAR;

			break;

		case T_double :

			this.resolvedType = TypeBinding.DOUBLE;

			break;

		case T_float :

			this.resolvedType = TypeBinding.FLOAT;

			break;

		case T_int :

			this.resolvedType = TypeBinding.INT;

			break;

		case T_long :

			this.resolvedType = TypeBinding.LONG;

			break;

		case T_JavaLangString :

			this.resolvedType = scope.getJavaLangString();

			break;

		default : //error........

			this.constant = Constant.NotAConstant;

			scope.problemReporter().invalidOperator(this, leftType, rightType);

			return;

	}

	// check need for operand cast

	if ((leftIsCast = (this.left instanceof CastExpression)) == true || 

			rightIsCast) {

		CastExpression.checkNeedForArgumentCasts(scope, operator, operatorSignature, this.left, leftTypeID, leftIsCast, this.right, rightTypeID, rightIsCast);

	}

	// compute the constant when valid

	computeConstant(scope, leftTypeID, rightTypeID);

}

	// keep implementation in sync with 

	// CombinedBinaryExpression#printExpressionNoParenthesis

	// keep implementation in sync with CombinedBinaryExpression#resolveType

	// and nonRecursiveResolveTypeUpwards

				} else if (expr1 instanceof CombinedBinaryExpression) {

					CombinedBinaryExpression cursor;

					// left branch is comprised of PLUS BEs

					// cursor is shifted upwards, while needed BEs are added

					// on demand; past the arityMax-th

					// consecutive BE, a CBE is inserted that holds a 

					// full-fledged references table

					if ((cursor = (CombinedBinaryExpression)expr1).arity <

								cursor.arityMax) {

						cursor.left = new BinaryExpression(cursor.left,

								cursor.right, PLUS);

						cursor.arity++;

					} else {

						cursor.left = new CombinedBinaryExpression(cursor.left,

								cursor.right, PLUS, cursor.arity);

						cursor.arity = 0;

						cursor.tuneArityMax();

					}

					cursor.right = expr2;

					cursor.sourceEnd = expr2.sourceEnd;

					this.expressionStack[this.expressionPtr] = cursor;

					// BE_INSTRUMENTATION: neutralized in the released code					

//					cursor.depthTracker = ((BinaryExpression)cursor.left).

//						depthTracker + 1;					

				} else if (expr1 instanceof BinaryExpression &&

							// single out the a + b case, which is a BE 

							// instead of a CBE (slightly more than a half of 

							// strings concatenation are one-deep binary 

							// expressions)

						((expr1.bits & ASTNode.OperatorMASK) >> 

							ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {

					this.expressionStack[this.expressionPtr] = 

						new CombinedBinaryExpression(expr1, expr2, PLUS, 1);

					// single out the a + b case

	// Note: we do not attempt to promote BinaryExpression-s to 

	//       IndexedBinaryExpression-s here since expr1 always holds a name

/*******************************************************************************

 * Copyright (c) 2006 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

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.jdt.internal.compiler.ast;

import org.eclipse.jdt.internal.compiler.ASTVisitor;

import org.eclipse.jdt.internal.compiler.codegen.CodeStream;

import org.eclipse.jdt.internal.compiler.flow.FlowContext;

import org.eclipse.jdt.internal.compiler.flow.FlowInfo;

import org.eclipse.jdt.internal.compiler.impl.Constant;

import org.eclipse.jdt.internal.compiler.lookup.BlockScope;

import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;

import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

/**

 * CombinedBinaryExpression is an implementation of BinaryExpression that 

 * specifically attempts to mitigate the issues raised by expressions which

 * have a very deep leftmost branch. It does so by maintaining a table of 

 * direct references to its subexpressions, and implementing non-recursive 

 * variants of the most significant recursive algorithms of its ancestors.

 * The subexpressions table only holds intermediate binary expressions. Its

 * role is to provide the reversed navigation through the left relationship

 * of BinaryExpression to Expression. To cope with potentially very deep

 * left branches, an instance of CombinedBinaryExpression is created once in

 * a while, using variable thresholds held by {@link #arityMax}.

 * As a specific case, the topmost node of all binary expressions that are

 * deeper than one is a CombinedBinaryExpression, but it has no references

 * table.<br>

 * Notes:

 * <ul>

 * <li>CombinedBinaryExpression is not meant to behave in other ways than 

 *     BinaryExpression in any observable respect;</li>

 * <li>visitors that implement their own traversal upon binary expressions

 *     should consider taking advantage of combined binary expressions, or

 *     else face a risk of StackOverflowError upon deep instances;</li>

 * <li>callers that need to change the operator should rebuild the expression

 *     from scratch, or else amend the references table as needed to cope with

 *     the resulting, separated expressions.</li>

 * </ul>

 */

public class CombinedBinaryExpression extends BinaryExpression {

	/** 

	 * The number of consecutive binary expressions of this' left branch that 

	 * bear the same operator as this.<br>

	 * Notes: 

	 * <ul><li>the presence of a CombinedBinaryExpression instance resets 

	 *         arity, even when its operator is compatible;</li>

	 *	   <li>this property is maintained by the parser.</li>

	 * </ul>

	 */

	public int arity;

	/**

	 * The threshold that will trigger the creation of the next full-fledged

	 * CombinedBinaryExpression. This field is only maintained for the

	 * topmost binary expression (it is 0 otherwise). It enables a variable

	 * policy, which scales better with very large expressions.

	 */

	public int arityMax;

	/**

	 * Upper limit for {@link #arityMax}.

	 */

	public static final int ARITY_MAX_MAX = 160;

	/**

	 * Default lower limit for {@link #arityMax}.

	 */

	public static final int ARITY_MAX_MIN = 20;

	/**

	 * Default value for the first term of the series of {@link #arityMax}

	 * values. Changing this allows for experimentation. Not meant to be 

	 * changed during a parse operation.

	 */

	public static int defaultArityMaxStartingValue = ARITY_MAX_MIN;

	/**

	 * A table of references to the binary expressions of this' left branch.

	 * Instances of CombinedBinaryExpression are not repeated here. Instead,

	 * the left subexpression of referencesTable[0] may be a combined binary

	 * expression, if appropriate. Null when this only cares about tracking 

	 * the expression's arity. 

	 */

	public BinaryExpression referencesTable[];

/**

 * Make a new CombinedBinaryExpression. If arity is strictly greater than one,

 * a references table is built and initialized with the reverse relationship of

 * the one defined by {@link BinaryExpression#left}. arity and left must be

 * compatible with each other (that is, there must be at least arity - 1

 * consecutive compatible binary expressions into the leftmost branch of left,

 * the topmost of which being left's immediate left expression).

 * @param left the left branch expression

 * @param right the right branch expression

 * @param operator the operator for this binary expression - only PLUS for now

 * @param arity the number of binary expressions of a compatible operator that

 *        already exist into the leftmost branch of left (including left); must

 *        be strictly greater than 0

 */

public CombinedBinaryExpression(Expression left, Expression right, int operator,

		int arity) {

	super(left, right, operator);

	this.arity = arity;

	if (arity > 1) {

		this.referencesTable = new BinaryExpression[arity];

		this.referencesTable[arity - 1] = (BinaryExpression) left;

		for (int i = arity - 1; i > 0; i--) {

			this.referencesTable[i - 1] = 

				(BinaryExpression) this.referencesTable[i].left; 

		}

	} else {

		this.arityMax = defaultArityMaxStartingValue;

	}

}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, 

		FlowInfo flowInfo) {

	// keep implementation in sync with BinaryExpression#analyseCode	

	if (this.referencesTable == null) {

		return super.analyseCode(currentScope, flowContext, flowInfo);

	}

	BinaryExpression cursor;

	if ((cursor = this.referencesTable[0]).resolvedType.id != 

			TypeIds.T_JavaLangString) {

		cursor.left.checkNPE(currentScope, flowContext, flowInfo);

	}

	flowInfo = cursor.left.analyseCode(currentScope, flowContext, flowInfo).

		unconditionalInits();	

	for (int i = 0, end = this.arity; i < end; i ++) {

		if ((cursor = this.referencesTable[i]).resolvedType.id != 

				TypeIds.T_JavaLangString) {

			cursor.right.checkNPE(currentScope, flowContext, flowInfo);

		}

		flowInfo = cursor.right.

			analyseCode(currentScope, flowContext, flowInfo).

				unconditionalInits();

	}

	if (this.resolvedType.id != TypeIds.T_JavaLangString) {

		this.right.checkNPE(currentScope, flowContext, flowInfo);

	}

	return this.right.analyseCode(currentScope, flowContext, flowInfo).

		unconditionalInits();

}

public void generateOptimizedStringConcatenation(BlockScope blockScope, 

		CodeStream codeStream, int typeID) {

	// keep implementation in sync with BinaryExpression and Expression

	// #generateOptimizedStringConcatenation

	if (this.referencesTable == null) {

		super.generateOptimizedStringConcatenation(blockScope, codeStream, 

			typeID);

	} else {	

		if ((((this.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) == 

				OperatorIds.PLUS)

			&& ((this.bits & ASTNode.ReturnTypeIDMASK) == TypeIds.T_JavaLangString)) {

			if (this.constant != Constant.NotAConstant) {

				codeStream.generateConstant(this.constant, this.implicitConversion);

				codeStream.invokeStringConcatenationAppendForType(

						this.implicitConversion & TypeIds.COMPILE_TYPE_MASK);

			} else {

				BinaryExpression cursor = this.referencesTable[0];

				int restart = 0;

	//			int cursorTypeID;

				int pc = codeStream.position;

				for (restart = this.arity - 1; restart >= 0; restart--) {

					if ((cursor = this.referencesTable[restart]).constant != 

							Constant.NotAConstant) {

						codeStream.generateConstant(cursor.constant, 

							cursor.implicitConversion);

						codeStream.invokeStringConcatenationAppendForType(

							cursor.implicitConversion & TypeIds.COMPILE_TYPE_MASK);

						break;

					}

					// never happens for now - may reconsider if we decide to 

					// cover more than string concatenation

	//				if (!((((cursor = this.referencesTable[restart]).bits & 

	//						ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) == 

	//							OperatorIds.PLUS) & 

	//						((cursorTypeID = cursor.bits & ASTNode.ReturnTypeIDMASK) == 

	//							TypeIds.T_JavaLangString)) {

	//					if (cursorTypeID == T_JavaLangString && 

	//							cursor.constant != Constant.NotAConstant && 

	//							cursor.constant.stringValue().length() == 0) {

	//						break; // optimize str + ""

	//					}

	//					cursor.generateCode(blockScope, codeStream, true);

	//					codeStream.invokeStringConcatenationAppendForType(

	//							cursorTypeID);					

	//					break;

	//				}

				}

				restart++;

				if (restart == 0) { // reached the leftmost expression

					cursor.left.generateOptimizedStringConcatenation(

						blockScope,

						codeStream,

						cursor.left.implicitConversion & TypeIds.COMPILE_TYPE_MASK);

				}

				int pcAux;

				for (int i = restart; i < this.arity; i++) {

					codeStream.recordPositionsFrom(pc, 

						(cursor = this.referencesTable[i]).left.sourceStart);

					pcAux = codeStream.position;

					cursor.right.generateOptimizedStringConcatenation(blockScope, 

						codeStream,	cursor.right.implicitConversion & 

							TypeIds.COMPILE_TYPE_MASK);

					codeStream.recordPositionsFrom(pcAux, cursor.right.sourceStart);

				}

				codeStream.recordPositionsFrom(pc, this.left.sourceStart);

				pc = codeStream.position;

				this.right.generateOptimizedStringConcatenation(

					blockScope,

					codeStream,

					this.right.implicitConversion & TypeIds.COMPILE_TYPE_MASK);

				codeStream.recordPositionsFrom(pc, this.right.sourceStart);

			}

		} else {

			super.generateOptimizedStringConcatenation(blockScope, codeStream, 

				typeID);

		}

	}

}

public void generateOptimizedStringConcatenationCreation(BlockScope blockScope, 

		CodeStream codeStream, int typeID) {

	// keep implementation in sync with BinaryExpression

	// #generateOptimizedStringConcatenationCreation

	if (this.referencesTable == null) {

		super.generateOptimizedStringConcatenationCreation(blockScope, 

			codeStream,	typeID);

	} else {

		if ((((this.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) == 

				OperatorIds.PLUS) && 

					((this.bits & ASTNode.ReturnTypeIDMASK) == 

						TypeIds.T_JavaLangString) && 

					this.constant == Constant.NotAConstant) {

			int pc = codeStream.position;

			BinaryExpression cursor = this.referencesTable[this.arity - 1];

				// silence warnings

			int restart = 0;

			for (restart = this.arity - 1; restart >= 0; restart--) {

				if (((((cursor = this.referencesTable[restart]).bits & 

						ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) == 

							OperatorIds.PLUS) && 

						((cursor.bits & ASTNode.ReturnTypeIDMASK) == 

							TypeIds.T_JavaLangString)) {

					if (cursor.constant != Constant.NotAConstant) {

						codeStream.newStringContatenation(); // new: java.lang.StringBuffer

						codeStream.dup();

						codeStream.ldc(cursor.constant.stringValue());

						codeStream.invokeStringConcatenationStringConstructor();

						// invokespecial: java.lang.StringBuffer.<init>(Ljava.lang.String;)V

						break;

					}

				} else {

					cursor.generateOptimizedStringConcatenationCreation(blockScope, 

						codeStream, cursor.implicitConversion & 

							TypeIds.COMPILE_TYPE_MASK);

					break;

				}

			}

			restart++;

			if (restart == 0) { // reached the leftmost expression

				cursor.left.generateOptimizedStringConcatenationCreation(

					blockScope,

					codeStream,

					this.left.implicitConversion & TypeIds.COMPILE_TYPE_MASK);

			}

			int pcAux;

			for (int i = restart; i < this.arity; i++) {

				codeStream.recordPositionsFrom(pc, 

					(cursor = this.referencesTable[i]).left.sourceStart);

				pcAux = codeStream.position;

				cursor.right.generateOptimizedStringConcatenation(blockScope, 

					codeStream,	cursor.right.implicitConversion & 

						TypeIds.COMPILE_TYPE_MASK);

				codeStream.recordPositionsFrom(pcAux, cursor.right.sourceStart);

			}

			codeStream.recordPositionsFrom(pc, this.left.sourceStart);

			pc = codeStream.position;

			this.right.generateOptimizedStringConcatenation(

				blockScope,

				codeStream,

				this.right.implicitConversion & TypeIds.COMPILE_TYPE_MASK);

			codeStream.recordPositionsFrom(pc, this.right.sourceStart);

		} else {

			super.generateOptimizedStringConcatenationCreation(blockScope, 

				codeStream, typeID);

		}

	}

}

public StringBuffer printExpressionNoParenthesis(int indent, 

		StringBuffer output) {

	// keep implementation in sync with 

	// BinaryExpression#printExpressionNoParenthesis and 

	// OperatorExpression#printExpression

	if (this.referencesTable == null) {

		return super.printExpressionNoParenthesis(indent, output);

	}

	String operatorString = operatorToString();

	for (int i = this.arity - 1; i >= 0; i--) {

		output.append('(');

	}

	output = this.referencesTable[0].left.

		printExpression(indent, output);

	for (int i = 0, end = this.arity; 

				i < end; i++) {

		output.append(' ').append(operatorString).append(' ');

		output = this.referencesTable[i].right.

			printExpression(0, output);

		output.append(')');

	}

	output.append(' ').append(operatorString).append(' ');

	return this.right.printExpression(0, output);

}

public TypeBinding resolveType(BlockScope scope) {

	// keep implementation in sync with BinaryExpression#resolveType

	if (this.referencesTable == null) {

		return super.resolveType(scope);

	}

	BinaryExpression cursor;

	if ((cursor = this.referencesTable[0]).left instanceof CastExpression) {

		cursor.left.bits |= ASTNode.DisableUnnecessaryCastCheck; 

			// will check later on

	}

	cursor.left.resolveType(scope);

	for (int i = 0, end = this.arity; i < end; i ++) {

		this.referencesTable[i].nonRecursiveResolveTypeUpwards(scope);

	}

	nonRecursiveResolveTypeUpwards(scope);

	return this.resolvedType;

}

public void traverse(ASTVisitor visitor, BlockScope scope) {

	if (this.referencesTable == null) {

		super.traverse(visitor, scope);

	} else {

		if (visitor.visit(this, scope)) {

			int restart;

			for (restart = this.arity - 1; 

					restart >= 0; 

					restart--) {

				if (!visitor.visit(

						this.referencesTable[restart], scope)) {

					visitor.endVisit(

						this.referencesTable[restart], scope);

					break;

				}

			}

			restart++;

			// restart now points to the deepest BE for which

			// visit returned true, if any

			if (restart == 0) {

				this.referencesTable[0].left.traverse(visitor, scope);

			}

			for (int i = restart, end = this.arity; 

						i < end; i++) {

				this.referencesTable[i].right.traverse(visitor, scope);

				visitor.endVisit(this.referencesTable[i], scope);

			}

			this.right.traverse(visitor, scope);

		}

		visitor.endVisit(this, scope);

	}

}

/**

 * Change {@link #arityMax} if and as needed. The current policy is to double 

 * arityMax each time this method is called, until it reaches 

 * {@link #ARITY_MAX_MAX}. Other policies may consider incrementing it less

 * agressively. Call only after an appropriate value has been assigned to 

 * {@link #left}.

 */

// more sophisticate increment policies would leverage the leftmost expression

// to hold an indication of the number of uses of a given arityMax in a row

public void tuneArityMax() {

	if (this.arityMax < ARITY_MAX_MAX) {

		this.arityMax *= 2;

	}

}

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Non-recursive approach for deep binary expressions. Check that the

// flow analysis doesn't break.

public void test027() {

	this.runConformTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"  public static void main(String args[]) {\n" + 

			"    String s;\n" + 

			"    if (args.length == 0) {\n" + 

			"      s = \"s\";\n" + 

			"    } else {\n" + 

			"      s = args[0];\n" + 

			"    }\n" + 

			"    System.out.println(s + \"-\" + s + \"-\" + s + \"-\" +\n" +

			"                       s + \"-\" + s + \"-\" + s + \"-\" +\n" + 

			"                       s + \"-\" + s + \"-\" + s + \"-\" +\n" + 

			"                       s + \"-\" + s + \"-\" + s + \"-\" +\n" + 

			"                       s + \"-\" + s + \"-\" + s + \"-\");\n" + 

			"  }\n" + 

			"}"

		},

		"s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-");

}

import java.util.Random;

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Failed before using a non recursive implementation of deep binary

// expressions.

public void test010() {

	StringBuffer sourceCode = new StringBuffer(			

			"public class X {\n" + 

			"  void foo(String a, String b, String c, String d, String e) {\n" +

			"    String s = \n");

	for (int i = 0; i < 350; i++) {

		sourceCode.append(

			"    	\"abcdef\" + a + b + c + d + e + " +

			"\" ghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmno" +

			"pqrstuvwxyzabcdefghijklmnopqrstuvwxyz\" +\n");

	}

	sourceCode.append(			

			"    	\"abcdef\" + a + b + c + d + e + \" ghijklmnopqrstuvwxyz" +

			"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" +

			"abcdefghijklmnopqrstuvwxy12\";\n" + 

			"    }\n" + 

			"}");

	this.runConformTest(

		new String[] {

			"X.java",

			sourceCode.toString()

		},

		"");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// check if we hit the 64Kb limit on method code lenth in class files before 

// filling the stack

// need to use a computed string (else this source file will get blown away

// as well)

public void test011() {

	int length = 3 * 54 * 1000; 

		// the longer the slower, but still needs to reach the limit...

	StringBuffer veryLongString = new StringBuffer(length + 20);

	veryLongString.append('"');

	Random random = new Random();

	while (veryLongString.length() < length) {

		veryLongString.append("\"+a+\"");

		veryLongString.append(random.nextLong());

	}

	veryLongString.append('"');

	this.runNegativeTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"  void foo(String a, String b, String c, String d, String e) {\n" +

			"    String s = \n" +

			veryLongString.toString() +

			"    	+ \"abcdef\" + a + b + c + d + e + \" ghiABCDEFGHIJKLMNOPQRSTUVWXYZjklmnopqrstuvwxyzabcdefghiABCDEFGHIJKLMNOPQRSTUVWXYZjklmnopqrstuvwxyzabcdefghiABCDEFGHIJKLMNOPQRSTUVWXYZjklmnopqrstuvwxyzabcdefghiABCDEFGHIJKLMNOPQRSTUVWXYZjklmnopqrstuvwxy12\";\n" + 

			"    }\n" + 

			"}"

		},

		"----------\n" +

		"1. ERROR in X.java (at line 2)\n" +

		"	void foo(String a, String b, String c, String d, String e) {\n" +

		"	     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +

		"The code of method foo(String, String, String, String, String) is " +

			"exceeding the 65535 bytes limit\n" +

		"----------\n");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// variant: right member of the topmost expression is left-deep

public void test012() {

	StringBuffer sourceCode = new StringBuffer(			

			"public class X {\n" + 

			"  void foo(String a, String b, String c, String d, String e) {\n" +

			"    String s = a + (\n");

	for (int i = 0; i < 1000; i++) {

		sourceCode.append(

			"    	\"abcdef\" + a + b + c + d + e + " +

			"\" ghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmno" +

			"pqrstuvwxyzabcdefghijklmnopqrstuvwxyz\" +\n");

	}

	sourceCode.append(			

			"    	\"abcdef\" + a + b + c + d + e + \" ghijklmnopqrstuvwxyz" +

			"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" +

			"abcdefghijklmnopqrstuvwxy12\");\n" + 

			"    }\n" + 

			"}");

	this.runConformTest(

		new String[] {

			"X.java",

			sourceCode.toString()

		},

		"");

}

	standardTests.add(ASTImplTests.class);

/*******************************************************************************

 * Copyright (c) 2006 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

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.jdt.core.tests.compiler.regression;

import junit.framework.Test;

import org.eclipse.jdt.core.tests.util.Util;

import org.eclipse.jdt.internal.compiler.ASTVisitor;

import org.eclipse.jdt.internal.compiler.CompilationResult;

import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;

import org.eclipse.jdt.internal.compiler.ast.BinaryExpression;

import org.eclipse.jdt.internal.compiler.ast.CharLiteral;

import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;

import org.eclipse.jdt.internal.compiler.ast.CombinedBinaryExpression;

import org.eclipse.jdt.internal.compiler.ast.ExtendedStringLiteral;

import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;

import org.eclipse.jdt.internal.compiler.ast.StringLiteral;

import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation;

import org.eclipse.jdt.internal.compiler.batch.CompilationUnit;

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

import org.eclipse.jdt.internal.compiler.lookup.BlockScope;

import org.eclipse.jdt.internal.compiler.parser.Parser;

import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;

import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;

/**

 * A tests series especially meant to validate the internals of our AST

 * implementation.

 */

public class ASTImplTests extends AbstractRegressionTest {

public ASTImplTests(String name) { 

    super(name);

}

	// Static initializer to specify tests subset using TESTS_* static variables

  	// All specified tests which does not belong to the class are skipped...

  	// Only the highest compliance level is run; add the VM argument

  	// -Dcompliance=1.4 (for example) to lower it if needed

  	static {

//    	TESTS_NAMES = new String[] { "test2050" };

//    	TESTS_NUMBERS = new int[] { 3 };   

//    	TESTS_NUMBERS = new int[] { 2999 };   

//    	TESTS_RANGE = new int[] { 2050, -1 }; 

  	}

public static Test suite() {

    return buildAllCompliancesTestSuite(testClass());

}

public static Class testClass() {

    return ASTImplTests.class;

}

// Helper methods

static Parser defaultParser = new Parser(

			new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(), 

			new CompilerOptions(), 

			new DefaultProblemFactory()), false);

public void runConformTest(String fileName, String fileContents, 

		Parser parser, ASTCollector visitor, String expected) {

	CompilationUnit source = 

		new CompilationUnit(fileContents.toCharArray(),	fileName, null);

	CompilationResult compilationResult =

		new CompilationResult(source, 1, 1, 10); 

	CompilationUnitDeclaration unit = parser.parse(source, compilationResult);

	assertEquals(0, compilationResult.problemCount);

	unit.traverse(visitor, unit.scope);

	String result = visitor.result();

	if (! expected.equals(result)) {

		System.out.println(getClass().getName() + '#' + getName());

		System.out.println("Expected:");

		System.out.println(expected);

		System.out.println("But was:");

		System.out.println(result);

		System.out.println("Cut and paste:");

		System.out.println(Util.displayString(result, INDENT, SHIFT));

	}

	assertEquals(expected, result);

}

// AST implementation - visiting binary expressions

public void test0001_regular_binary_expression() {

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    String s2 = \"s2\";\n" + 

		"    String s3 = \"s3\";\n" + 

		"    String s4 = \"s4\";\n" + 

		"    System.out.println(s1 + \"l1\" + s2 + \"l2\" +\n" +

		"      s3 + \"l3\" + s4);\n" + 

		"  }\n" + 

		"}\n",

		defaultParser,

		new ASTBinaryExpressionCollector(),

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v SL \"s2\"]\n" + 

		"[ev SL \"s2\"]\n" + 

		"[v SL \"s3\"]\n" + 

		"[ev SL \"s3\"]\n" + 

		"[v SL \"s4\"]\n" + 

		"[ev SL \"s4\"]\n" + 

		"[v BE ((((((s1 + \"l1\") + s...) + s4)]\n" + 

		"[v BE (((((s1 + \"l1\") + s2...+ \"l3\")]\n" + 

		"[v BE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v BE ((s1 + \"l1\") + s2)]\n" + 

		"[v BE (s1 + \"l1\")]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[v SL \"l1\"]\n" + 

		"[ev SL \"l1\"]\n" + 

		"[ev BE (s1 + \"l1\")]\n" + 

		"[v SNR s2]\n" + 

		"[ev SNR s2]\n" + 

		"[ev BE ((s1 + \"l1\") + s2)]\n" + 

		"[v SL \"l2\"]\n" + 

		"[ev SL \"l2\"]\n" + 

		"[ev BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v SNR s3]\n" + 

		"[ev SNR s3]\n" + 

		"[ev BE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v SL \"l3\"]\n" + 

		"[ev SL \"l3\"]\n" + 

		"[ev BE (((((s1 + \"l1\") + s2...+ \"l3\")]\n" + 

		"[v SNR s4]\n" + 

		"[ev SNR s4]\n" + 

		"[ev BE ((((((s1 + \"l1\") + s...) + s4)]\n");

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions

public void test0002_combined_binary_expression() {

	CombinedBinaryExpression.defaultArityMaxStartingValue = 3;

	// one CBE each fourth BE

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    String s2 = \"s2\";\n" + 

		"    String s3 = \"s3\";\n" + 

		"    String s4 = \"s4\";\n" + 

		"    System.out.println(s1 + \"l1\" + s2 + \"l2\" +\n" +

		"      s3 + \"l3\" + s4);\n" + 

		"  }\n" + 

		"}\n",

		defaultParser,

		new ASTBinaryExpressionCollector() {

			public void endVisit(BinaryExpression binaryExpression, BlockScope scope) {

				if (binaryExpression instanceof CombinedBinaryExpression &&

						((CombinedBinaryExpression) binaryExpression).

							referencesTable != null) {

					this.collector.append("[ev CBE " + 

						cut(binaryExpression.toString()) + "]\n");

				} else {

					super.endVisit(binaryExpression, scope);

				}

			}

		},

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v SL \"s2\"]\n" + 

		"[ev SL \"s2\"]\n" + 

		"[v SL \"s3\"]\n" + 

		"[ev SL \"s3\"]\n" + 

		"[v SL \"s4\"]\n" + 

		"[ev SL \"s4\"]\n" + 

		"[v BE ((((((s1 + \"l1\") + s...) + s4)]\n" + 

		"[v BE (((((s1 + \"l1\") + s2...+ \"l3\")]\n" + 

		"[v BE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v BE ((s1 + \"l1\") + s2)]\n" + 

		"[v BE (s1 + \"l1\")]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[v SL \"l1\"]\n" + 

		"[ev SL \"l1\"]\n" + 

		"[ev BE (s1 + \"l1\")]\n" + 

		"[v SNR s2]\n" + 

		"[ev SNR s2]\n" + 

		"[ev BE ((s1 + \"l1\") + s2)]\n" + 

		"[v SL \"l2\"]\n" + 

		"[ev SL \"l2\"]\n" + 

		"[ev BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v SNR s3]\n" + 

		"[ev SNR s3]\n" + 

		"[ev CBE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v SL \"l3\"]\n" + 

		"[ev SL \"l3\"]\n" + 

		"[ev BE (((((s1 + \"l1\") + s2...+ \"l3\")]\n" + 

		"[v SNR s4]\n" + 

		"[ev SNR s4]\n" + 

		"[ev BE ((((((s1 + \"l1\") + s...) + s4)]\n");

	CombinedBinaryExpression.defaultArityMaxStartingValue = 

		CombinedBinaryExpression.ARITY_MAX_MIN;

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions

public void test0003_combined_binary_expression() {

	Parser parser = new Parser(

			new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(), 

			new CompilerOptions(), 

			new DefaultProblemFactory()), true); // optimize string literals

	CombinedBinaryExpression.defaultArityMaxStartingValue = 2;

		// one CBE each third BE - except the top one, which is degenerate (no

		// references table)

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    String s2 = \"s2\";\n" + 

		"    String s3 = \"s3\";\n" + 

		"    String s4 = \"s4\";\n" + 

		"    System.out.println(s1 + \"l1\" + s2 + \"l2\" +\n" +

		"      s3 + \"l3\" + s4);\n" + 

		"  }\n" + 

		"}\n",

		parser,		

		new ASTBinaryExpressionCollector() {

			public void endVisit(BinaryExpression binaryExpression, BlockScope scope) {

				if (binaryExpression instanceof CombinedBinaryExpression &&

						((CombinedBinaryExpression) binaryExpression).

							referencesTable != null) {

					this.collector.append("[ev CBE " + 

						cut(binaryExpression.toString()) + "]\n");

				} else {

					super.endVisit(binaryExpression, scope);

				}

			}

		},

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v SL \"s2\"]\n" + 

		"[ev SL \"s2\"]\n" + 

		"[v SL \"s3\"]\n" + 

		"[ev SL \"s3\"]\n" + 

		"[v SL \"s4\"]\n" + 

		"[ev SL \"s4\"]\n" + 

		"[v BE ((((((s1 + \"l1\") + s...) + s4)]\n" + 

		"[v BE (((((s1 + \"l1\") + s2...+ \"l3\")]\n" + 

		"[v BE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v BE ((s1 + \"l1\") + s2)]\n" + 

		"[v BE (s1 + \"l1\")]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[v SL \"l1\"]\n" + 

		"[ev SL \"l1\"]\n" + 

		"[ev BE (s1 + \"l1\")]\n" + 

		"[v SNR s2]\n" + 

		"[ev SNR s2]\n" + 

		"[ev BE ((s1 + \"l1\") + s2)]\n" + 

		"[v SL \"l2\"]\n" + 

		"[ev SL \"l2\"]\n" + 

		"[ev CBE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v SNR s3]\n" + 

		"[ev SNR s3]\n" + 

		"[ev BE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v SL \"l3\"]\n" + 

		"[ev SL \"l3\"]\n" + 

		"[ev BE (((((s1 + \"l1\") + s2...+ \"l3\")]\n" + 

		"[v SNR s4]\n" + 

		"[ev SNR s4]\n" + 

		"[ev BE ((((((s1 + \"l1\") + s...) + s4)]\n");

	CombinedBinaryExpression.defaultArityMaxStartingValue = 

		CombinedBinaryExpression.ARITY_MAX_MIN;

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions - effect of a literal at the start with

// string literal optimization

public void test0004_combined_binary_expression() {

	Parser parser = new Parser(

			new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(), 

			new CompilerOptions(), 

			new DefaultProblemFactory()), true); // optimize string literals

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    System.out.println(\"l\" + \"1\" + s1);\n" +

			// "l" + "1" is collapsed into "l1" without affecting binary 

			// expressions: only one BE

		"  }\n" + 

		"}\n",

		parser,

		new ASTBinaryExpressionCollector(),

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v BE (ExtendedStringLiter...} + s1)]\n" + 

		"[v ESL ExtendedStringLiteral{l1}]\n" + 

		"[ev ESL ExtendedStringLiteral{l1}]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[ev BE (ExtendedStringLiter...} + s1)]\n");

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions - effect of a literal at the start without

// string literals optimization

public void test0005_combined_binary_expression() {

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    System.out.println(\"l\" + \"1\" + s1);\n" +

			// "l" + "1" is handled by a string literal concatenation without 

			// affecting binary expressions: only one BE

		"  }\n" + 

		"}\n",

		defaultParser,

		new ASTBinaryExpressionCollector(),

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v BE (StringLiteralConcat...} + s1)]\n" + 

		"[v SLC StringLiteralConcate...\n" + 

		"\"1\"+\n" + 

		"}]\n" + 

		"[v SL \"l\"]\n" + 

		"[ev SL \"l\"]\n" + 

		"[v SL \"1\"]\n" + 

		"[ev SL \"1\"]\n" + 

		"[ev SLC StringLiteralConcate...\n" + 

		"\"1\"+\n" + 

		"}]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[ev BE (StringLiteralConcat...} + s1)]\n");

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions - cutting the traversal half-way down

public void test0006_combined_binary_expression() {

	CombinedBinaryExpression.defaultArityMaxStartingValue = 1;

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    String s2 = \"s2\";\n" + 

		"    String s3 = \"s3\";\n" + 

		"    String s4 = \"s4\";\n" + 

		"    System.out.println(s1 + \"l1\" + s2 + \"l2\" +\n" +

		"      s3 + s1 + s4);\n" + 

		"  }\n" + 

		"}\n",

		defaultParser,

		new ASTBinaryExpressionCollector() {

			public boolean visit(BinaryExpression binaryExpression, BlockScope scope) {

				super.visit(binaryExpression, scope);

				if (binaryExpression.right instanceof StringLiteral) {

					return false;

				}

				return true;

			}

		},

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v SL \"s2\"]\n" + 

		"[ev SL \"s2\"]\n" + 

		"[v SL \"s3\"]\n" + 

		"[ev SL \"s3\"]\n" + 

		"[v SL \"s4\"]\n" + 

		"[ev SL \"s4\"]\n" + 

		"[v BE ((((((s1 + \"l1\") + s...) + s4)]\n" + 

		"[v BE (((((s1 + \"l1\") + s2...) + s1)]\n" + 

		"[v BE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[ev BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v SNR s3]\n" + 

		"[ev SNR s3]\n" + 

		"[ev BE ((((s1 + \"l1\") + s2)...) + s3)]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[ev BE (((((s1 + \"l1\") + s2...) + s1)]\n" + 

		"[v SNR s4]\n" + 

		"[ev SNR s4]\n" + 

		"[ev BE ((((((s1 + \"l1\") + s...) + s4)]\n");

	CombinedBinaryExpression.defaultArityMaxStartingValue = 

		CombinedBinaryExpression.ARITY_MAX_MIN;

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions - cutting the traversal right away

public void test0007_combined_binary_expression() {

	CombinedBinaryExpression.defaultArityMaxStartingValue = 4; 

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    String s2 = \"s2\";\n" + 

		"    String s3 = \"s3\";\n" + 

		"    String s4 = \"s4\";\n" + 

		"    System.out.println(s1 + \"l1\" + s2 + \"l2\" +\n" +

		"      s3 + \"l3\" + s4);\n" + 

		"  }\n" + 

		"}\n",

		defaultParser,

		new ASTBinaryExpressionCollector() {

			public boolean visit(BinaryExpression binaryExpression, BlockScope scope) {

				super.visit(binaryExpression, scope);

				return false;

			}

		},

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v SL \"s2\"]\n" + 

		"[ev SL \"s2\"]\n" + 

		"[v SL \"s3\"]\n" + 

		"[ev SL \"s3\"]\n" + 

		"[v SL \"s4\"]\n" + 

		"[ev SL \"s4\"]\n" + 

		"[v BE ((((((s1 + \"l1\") + s...) + s4)]\n" + 

		"[ev BE ((((((s1 + \"l1\") + s...) + s4)]\n");

	CombinedBinaryExpression.defaultArityMaxStartingValue = 

		CombinedBinaryExpression.ARITY_MAX_MIN;

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions - case of one-deep expression

public void test0008_combined_binary_expression() {

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    String s2 = \"s2\";\n" + 

		"    System.out.println(s1 + \"l1\" + s2 + \"l2\");\n" + 

		"    System.out.println(s1 + s2);\n" + 

		"  }\n" + 

		"}\n",

		defaultParser,		

		new ASTBinaryExpressionCollector() {

			public void endVisit(BinaryExpression binaryExpression, BlockScope scope) {

				if (binaryExpression instanceof CombinedBinaryExpression) {

					this.collector.append("[ev CBE " + 

						cut(binaryExpression.toString()) + "]\n");

				} else {

					super.endVisit(binaryExpression, scope);

				}

			}

		},

		"[v SL \"s1\"]\n" + 

		"[ev SL \"s1\"]\n" + 

		"[v SL \"s2\"]\n" + 

		"[ev SL \"s2\"]\n" + 

		"[v BE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v BE ((s1 + \"l1\") + s2)]\n" + 

		"[v BE (s1 + \"l1\")]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[v SL \"l1\"]\n" + 

		"[ev SL \"l1\"]\n" + 

		"[ev BE (s1 + \"l1\")]\n" + 

		"[v SNR s2]\n" + 

		"[ev SNR s2]\n" + 

		"[ev BE ((s1 + \"l1\") + s2)]\n" + 

		"[v SL \"l2\"]\n" + 

		"[ev SL \"l2\"]\n" + 

		"[ev CBE (((s1 + \"l1\") + s2) + \"l2\")]\n" + 

		"[v BE (s1 + s2)]\n" + 

		"[v SNR s1]\n" + 

		"[ev SNR s1]\n" + 

		"[v SNR s2]\n" + 

		"[ev SNR s2]\n" + 

		"[ev BE (s1 + s2)]\n");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// check if the generated code is OK when leveraging CombinedBinaryExpression

public void test0009_combined_binary_expression() {

	assertEquals(20, CombinedBinaryExpression.ARITY_MAX_MIN);

	this.runConformTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"public static void main(String args[]) {\n" + 

			"    final int max = 30; \n" + 

			"    String s[] = new String[max];\n" + 

			"    for (int i = 0; i < max; i++) {\n" + 

			"        s[i] = \"a\";\n" + 

			"    }\n" + 

			"    foo(s);\n" + 

			"}\n" + 

			"static void foo (String s[]) {\n" + 

			"    System.out.println(\n" + 

			"        s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + \n" +

			"        s[7] + s[8] + s[9] + s[10] + s[11] + s[12] + s[13] +\n" +

			"        s[14] + s[15] + s[16] + s[17] + s[18] + s[19] + \n" + 

			"        s[20] + s[21] + s[22] + s[23] + s[24] + s[25] + \n" +

			"        s[26] + s[27] + s[28] + s[29]\n" + 

			"        );\n" + 

			"}\n" + 

			"}"},

		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// check if the generated code is OK when leveraging CombinedBinaryExpression

// variant involving constant binary expressions deep in the tree

public void test0010_combined_binary_expression() {

	assertEquals(20, CombinedBinaryExpression.ARITY_MAX_MIN);

	this.runConformTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"public static void main(String args[]) {\n" + 

			"    final int max = 30; \n" + 

			"    String s[] = new String[max];\n" + 

			"    for (int i = 0; i < max; i++) {\n" + 

			"        s[i] = \"a\";\n" + 

			"    }\n" + 

			"    foo(s);\n" + 

			"}\n" + 

			"static void foo (String s[]) {\n" +

			"    final String c = \"a\";" + 

			"    System.out.println(\n" + 

			"        c + c + c + c + s[4] + s[5] + s[6] + s[7] + s[8] + \n" +

			"        s[9] + s[10] + s[11] + s[12] + s[13] + s[14] + \n" +

			"        s[15] + s[16] + s[17] + s[18] + s[19] + s[20] + \n" +

			"        s[21] + s[22] + s[23] + s[24] + s[25] + s[26] + \n" +

			"        s[27] + s[28] + s[29]\n" + 

			"        );\n" + 

			"}\n" + 

			"}"

		},

		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// check if the generated code is OK when leveraging CombinedBinaryExpression

// variant involving a constant combined binary expression

public void test0011_combined_binary_expression() {

	assertEquals(20, CombinedBinaryExpression.ARITY_MAX_MIN);

	this.runConformTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"public static void main(String args[]) {\n" + 

			"    final int max = 30; \n" + 

			"    String s[] = new String[max];\n" + 

			"    for (int i = 0; i < max; i++) {\n" + 

			"        s[i] = \"a\";\n" + 

			"    }\n" + 

			"    foo(s);\n" + 

			"}\n" + 

			"static void foo (String s[]) {\n" +

			"    final String c = \"a\";" + 

			"    System.out.println(\n" + 

			"        c + c + c + c + c + c + c + c + c + c + \n" + 

			"        c + c + c + c + c + c + c + c + c + c + \n" + 

			"        c + c + s[22] + s[23] + s[24] + s[25] + s[26] + \n" +

			"        s[27] + s[28] + s[29]\n" + 

			"        );\n" + 

			"}\n" + 

			"}"

		},

		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

}

// AST implementation - visiting binary expressions

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// Adding combined binary expressions - checking recursive print

public void test0012_combined_binary_expression() {

	CombinedBinaryExpression.defaultArityMaxStartingValue = 2; 

	runConformTest(

		"X.java", 

		"public class X {\n" + 

		"  void foo() {\n" + 

		"    String s1 = \"s1\";\n" + 

		"    String s2 = \"s2\";\n" + 

		"    String s3 = \"s3\";\n" + 

		"    String s4 = \"s4\";\n" + 

		"    System.out.println(s1 + \"l1\" + s2 + \"l2\" +\n" +

		"      s3 + s1 + s4);\n" + 

		"  }\n" + 

		"}\n",

		defaultParser,

		new ASTCollector() {

			public boolean visit(BinaryExpression binaryExpression, 

					BlockScope scope) {

				super.visit(binaryExpression, scope);

				this.collector.append(binaryExpression);

				return true;

			}

		},

		"((((((s1 + \"l1\") + s2) + \"l2\") + s3) + s1) + s4)(((((s1 + \"l1\")" +

		" + s2) + \"l2\") + s3) + s1)((((s1 + \"l1\") + s2) + \"l2\") + s3)" +

		"(((s1 + \"l1\") + s2) + \"l2\")((s1 + \"l1\") + s2)(s1 + \"l1\")");

	CombinedBinaryExpression.defaultArityMaxStartingValue = 

		CombinedBinaryExpression.ARITY_MAX_MIN;

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// check if the generated code is OK when leveraging CombinedBinaryExpression

// variant involving a left-deep right expression at the topmost level

public void test0013_combined_binary_expression() {

	assertEquals(20, CombinedBinaryExpression.ARITY_MAX_MIN);

	this.runConformTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"public static void main(String args[]) {\n" + 

			"    final int max = 30; \n" + 

			"    String s[] = new String[max];\n" + 

			"    for (int i = 0; i < max; i++) {\n" + 

			"        s[i] = \"a\";\n" + 

			"    }\n" + 

			"    foo(s);\n" + 

			"}\n" + 

			"static void foo (String s[]) {\n" + 

			"    System.out.println(\n" + 

			"        \"b\" + (s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + \n" +

			"        s[7] + s[8] + s[9] + s[10] + s[11] + s[12] + s[13] +\n" +

			"        s[14] + s[15] + s[16] + s[17] + s[18] + s[19] + \n" + 

			"        s[20] + s[21] + s[22] + s[23] + s[24] + s[25] + \n" +

			"        s[26] + s[27] + s[28] + s[29])\n" + 

			"        );\n" + 

			"}\n" + 

			"}"

		},

		"baaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// check if the generated code is OK when leveraging CombinedBinaryExpression

// variant involving a left-deep right expression at the topmost level, with

// a constant high in tree

public void test0014_combined_binary_expression() {

	assertEquals(20, CombinedBinaryExpression.ARITY_MAX_MIN);

	this.runConformTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"public static void main(String args[]) {\n" + 

			"    final int max = 30; \n" + 

			"    String s[] = new String[max];\n" + 

			"    for (int i = 0; i < max; i++) {\n" + 

			"        s[i] = \"a\";\n" + 

			"    }\n" + 

			"    foo(s);\n" + 

			"}\n" + 

			"static void foo (String s[]) {\n" +

			"    final String c = \"c\";\n" + 

			"    System.out.println(\n" + 

			"        \"b\" + \n" +

			"         (c + c + c + c + c + c + c + c + c + c + \n" +

			"          c + c + c + c + c + c + c + c + c + c + \n" +

			"          c + c + s[0])\n" + 

			"        );\n" + 

			"}\n" + 

			"}"

		},

		"bcccccccccccccccccccccca");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

// check if the generated code is OK when leveraging CombinedBinaryExpression

// variant involving a left-deep right expression at the topmost level, with

// a constant low in tree

public void test0015_combined_binary_expression() {

	assertEquals(20, CombinedBinaryExpression.ARITY_MAX_MIN);

	this.runConformTest(

		new String[] {

			"X.java",

			"public class X {\n" + 

			"public static void main(String args[]) {\n" + 

			"    final int max = 30; \n" + 

			"    String s[] = new String[max];\n" + 

			"    for (int i = 0; i < max; i++) {\n" + 

			"        s[i] = \"a\";\n" + 

			"    }\n" + 

			"    foo(s);\n" + 

			"}\n" + 

			"static void foo (String s[]) {\n" +

			"    final String c = \"c\";\n" + 

			"    System.out.println(\n" + 

			"        \"b\" + \n" +

			"         (c + c + c + c + c + c + c + c + c + c + \n" +

			"          c + c + c + c + c + c + c + c + c + c + \n" +

			"          s[0] + s[1] + s[2])\n" + 

			"        );\n" + 

			"}\n" + 

			"}"

		},

		"bccccccccccccccccccccaaa");

}

//AST implementation - binary expressions

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=102728

//Adding combined binary expressions - alternate operands

public void test0016_combined_binary_expression() {

	CombinedBinaryExpression.defaultArityMaxStartingValue = 2; 

	this.runConformTest(

		"X.java", 

		"public class X {\n" + 

		"void foo(int i1, int i2, int i3, int i4) {\n" + 

		"  System.out.println(i1 - i2 + 0 + i3 + 0 + i4);\n" + 

		"}\n" + 

		"}\n",

		defaultParser,

		new ASTCollector() {

			public boolean visit(BinaryExpression binaryExpression, 

					BlockScope scope) {

				super.visit(binaryExpression, scope);

				this.collector.append(binaryExpression);

				return true;

			}

		},

		"(((((i1 - i2) + 0) + i3) + 0) + i4)((((i1 - i2) + 0) + i3) + 0)" +

			"(((i1 - i2) + 0) + i3)((i1 - i2) + 0)(i1 - i2)");

	CombinedBinaryExpression.defaultArityMaxStartingValue = 

		CombinedBinaryExpression.ARITY_MAX_MIN;

}

}

// Helper classes: define visitors leveraged by some tests

class ASTCollector extends ASTVisitor {

	StringBuffer collector = new StringBuffer();

public String result() {

	return this.collector.toString();

}

}

class ASTBinaryExpressionCollector extends ASTCollector {

static final int LIMIT = 30;

// help limit the output in length by suppressing the middle

// part of strings which length exceeds LIMIT

String cut(String source) {

	int length;

	if ((length = source.length()) > LIMIT) {

		StringBuffer result = new StringBuffer(length);

		result.append(source.substring(0, LIMIT - 10));

		result.append("...");

		result.append(source.substring(length - 7, length));

		return result.toString();

	} else {

		return source;

	}

}

public void endVisit(BinaryExpression binaryExpression, BlockScope scope) {

	this.collector.append("[ev BE " + cut(binaryExpression.toString()) + "]\n");

	super.endVisit(binaryExpression, scope);

}

public void endVisit(CharLiteral charLiteral, BlockScope scope) {

	this.collector.append("[ev CL " + cut(charLiteral.toString()) + "]\n");

	super.endVisit(charLiteral, scope);

}

public void endVisit(ExtendedStringLiteral literal, BlockScope scope) {

	this.collector.append("[ev ESL " + cut(literal.toString()) + "]\n");

	super.endVisit(literal, scope);

}

public void endVisit(SingleNameReference singleNameReference, 

		BlockScope scope) {

	this.collector.append("[ev SNR " + cut(singleNameReference.toString()) + 

		"]\n");

	super.endVisit(singleNameReference, scope);

}

public void endVisit(StringLiteral stringLiteral, BlockScope scope) {

	this.collector.append("[ev SL " + cut(stringLiteral.toString()) + "]\n");

	super.endVisit(stringLiteral, scope);

}

public void endVisit(StringLiteralConcatenation literal, BlockScope scope) {

	this.collector.append("[ev SLC " + cut(literal.toString()) + "]\n");

	super.endVisit(literal, scope);

}

public boolean visit(BinaryExpression binaryExpression, BlockScope scope) {

	this.collector.append("[v BE " + cut(binaryExpression.toString()) + "]\n");

	return super.visit(binaryExpression, scope);

}

public boolean visit(CharLiteral charLiteral, BlockScope scope) {

	this.collector.append("[v CL " + cut(charLiteral.toString()) + "]\n");

	return super.visit(charLiteral, scope);

}

public boolean visit(ExtendedStringLiteral literal, BlockScope scope) {

	this.collector.append("[v ESL " + cut(literal.toString()) + "]\n");

	return super.visit(literal, scope);

}

public boolean visit(SingleNameReference singleNameReference, 

		BlockScope scope) {

	this.collector.append("[v SNR " + cut(singleNameReference.toString()) + 

		"]\n");

	return super.visit(singleNameReference, scope);

}

public boolean visit(StringLiteral stringLiteral, BlockScope scope) {

	this.collector.append("[v SL " + cut(stringLiteral.toString()) + "]\n");

	return super.visit(stringLiteral, scope);

}

public boolean visit(StringLiteralConcatenation literal, BlockScope scope) {

	this.collector.append("[v SLC " + cut(literal.toString()) + "]\n");

	return super.visit(literal, scope);

}

}