import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation; //导入依赖的package包/类
public InfixExpression convert(StringLiteralConcatenation expression) {
	expression.computeConstant();
	final InfixExpression infixExpression = new InfixExpression(this.ast);
	infixExpression.setOperator(InfixExpression.Operator.PLUS);
	org.eclipse.jdt.internal.compiler.ast.Expression[] stringLiterals = expression.literals;
	infixExpression.setLeftOperand(convert(stringLiterals[0]));
	infixExpression.setRightOperand(convert(stringLiterals[1]));
	for (int i = 2; i < expression.counter; i++) {
		infixExpression.extendedOperands().add(convert(stringLiterals[i]));
	}
	if (this.resolveBindings) {
		this.recordNodes(infixExpression, expression);
	}
	infixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
	return infixExpression;
}
 

import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation; //导入依赖的package包/类
public boolean visit(StringLiteralConcatenation stringLiteral, BlockScope scope) {
	if (((stringLiteral.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {
		addRealFragment(stringLiteral);
	} else {
		for (int i = 0, max = stringLiteral.counter; i < max; i++) {
			addRealFragment(stringLiteral.literals[i]);
			if (i < max - 1) {
				this.operatorsList.add(new Integer(TerminalTokens.TokenNamePLUS));
			}
		}
	}
	return false;
}
 

import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation; //导入依赖的package包/类
@Override
public void endVisit(StringLiteralConcatenation x, BlockScope scope) {
  try {
    SourceInfo info = makeSourceInfo(x);
    push(getStringLiteral(info, x.constant.stringValue()));
  } catch (Throwable e) {
    throw translateException(x, e);
  }
}
 

import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation; //导入依赖的package包/类
@Override public boolean visit(StringLiteralConcatenation node, BlockScope scope) {
	fixPositions(setGeneratedBy(node, source));
	return super.visit(node, scope);
}
 

import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation; //导入依赖的package包/类
/**
 * @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.NullLiteral, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
 */
public boolean visit(StringLiteralConcatenation stringLiteral, BlockScope scope) {
	final int numberOfParens = (stringLiteral.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT;
	if (numberOfParens > 0) {
		manageOpeningParenthesizedExpression(stringLiteral, numberOfParens);
	}

	this.scribe.printComment(Scribe.PRESERVE_EMPTY_LINES_IN_STRING_LITERAL_CONCATENATION);
	ASTNode[] fragments = stringLiteral.literals;
	int fragmentsSize = stringLiteral.counter;
	Alignment binaryExpressionAlignment = this.scribe.createAlignment(
			Alignment.STRING_CONCATENATION,
			this.preferences.alignment_for_binary_expression,
			Alignment.R_OUTERMOST,
			fragmentsSize,
			this.scribe.scanner.currentPosition);
	this.scribe.enterAlignment(binaryExpressionAlignment);
	boolean ok = false;
	do {
		try {
			for (int i = 0; i < fragmentsSize - 1; i++) {
				ASTNode fragment = fragments[i];
				fragment.traverse(this, scope);
				this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				if (this.scribe.lastNumberOfNewLines == 1) {
					// a new line has been inserted by printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT)
					this.scribe.indentationLevel = binaryExpressionAlignment.breakIndentationLevel;
				}
				this.scribe.alignFragment(binaryExpressionAlignment, i);
				this.scribe.printNextToken(TerminalTokens.TokenNamePLUS, this.preferences.insert_space_before_binary_operator);
				if (this.preferences.insert_space_after_binary_operator) {
					this.scribe.space();
				}
			}
			fragments[fragmentsSize - 1].traverse(this, scope);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			ok = true;
		} catch(AlignmentException e){
			this.scribe.redoAlignment(e);
		}
	} while (!ok);
	this.scribe.exitAlignment(binaryExpressionAlignment, true);

	if (numberOfParens > 0) {
		manageClosingParenthesizedExpression(stringLiteral, numberOfParens);
	}
	return false;
}
 

import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation; //导入依赖的package包/类
@Override public boolean visit(StringLiteralConcatenation node, BlockScope scope) {
	setGeneratedBy(node, source);
	applyOffsetExpression(node);
	return super.visit(node, scope);
}