Attachment 27054 Details for Bug 109333 – Proposed fix

[patch] Proposed fix

patch_109333.txt (text/plain), 10.17 KB, created by Olivier Thomann

on 2005-09-12 17:06:16 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Olivier Thomann

Created: 2005-09-12 17:06:16 EDT

Size: 10.17 KB

patch

obsolete

>Index: dom/org/eclipse/jdt/core/dom/ASTConverter.java
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java,v
>retrieving revision 1.215
>diff -u -r1.215 ASTConverter.java
>--- dom/org/eclipse/jdt/core/dom/ASTConverter.java	7 Sep 2005 07:45:56 -0000	1.215
>+++ dom/org/eclipse/jdt/core/dom/ASTConverter.java	12 Sep 2005 21:05:07 -0000
>@@ -597,8 +597,71 @@
> 
> 	public Expression convert(org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression expression) {
> 		InfixExpression infixExpression = new InfixExpression(this.ast);
>+		infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_AND);
> 		if (this.resolveBindings) {
>-			recordNodes(infixExpression, expression);
>+			this.recordNodes(infixExpression, expression);
>+		}
>+		final int expressionOperatorID = (expression.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT;
>+		if (expression.left instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
>+				&& ((expression.left.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)) {
>+			// create an extended string literal equivalent => use the extended operands list
>+			infixExpression.extendedOperands().add(convert(expression.right));
>+			org.eclipse.jdt.internal.compiler.ast.Expression leftOperand = expression.left;
>+			org.eclipse.jdt.internal.compiler.ast.Expression rightOperand = null;
>+			do {
>+				rightOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).right;
>+				if ((((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID
>+							&& ((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))
>+					 || ((rightOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
>+				 			&& ((rightOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID)
>+							&& ((rightOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))) {
>+				 	List extendedOperands = infixExpression.extendedOperands();
>+				 	InfixExpression temp = new InfixExpression(this.ast);
>+					if (this.resolveBindings) {
>+						this.recordNodes(temp, expression);
>+					}
>+				 	temp.setOperator(getOperatorFor(expressionOperatorID));
>+				 	Expression leftSide = convert(leftOperand);
>+					temp.setLeftOperand(leftSide);
>+					temp.setSourceRange(leftSide.getStartPosition(), leftSide.getLength());
>+					int size = extendedOperands.size();
>+				 	for (int i = 0; i < size - 1; i++) {
>+				 		Expression expr = temp;
>+				 		temp = new InfixExpression(this.ast);
>+				 		
>+						if (this.resolveBindings) {
>+							this.recordNodes(temp, expression);
>+						}				 	
>+				 		temp.setLeftOperand(expr);
>+					 	temp.setOperator(getOperatorFor(expressionOperatorID));
>+						temp.setSourceRange(expr.getStartPosition(), expr.getLength());
>+				 	}
>+				 	infixExpression = temp;
>+				 	for (int i = 0; i < size; i++) {
>+				 		Expression extendedOperand = (Expression) extendedOperands.remove(size - 1 - i);
>+				 		temp.setRightOperand(extendedOperand);
>+				 		int startPosition = temp.getLeftOperand().getStartPosition();
>+				 		temp.setSourceRange(startPosition, extendedOperand.getStartPosition() + extendedOperand.getLength() - startPosition);
>+				 		if (temp.getLeftOperand().getNodeType() == ASTNode.INFIX_EXPRESSION) {
>+				 			temp = (InfixExpression) temp.getLeftOperand();
>+				 		}
>+				 	}
>+					int startPosition = infixExpression.getLeftOperand().getStartPosition();
>+					infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
>+					if (this.resolveBindings) {
>+						this.recordNodes(infixExpression, expression);
>+					}
>+					return infixExpression;
>+				}
>+				infixExpression.extendedOperands().add(0, convert(rightOperand));
>+				leftOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).left;
>+			} while (leftOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression && ((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0));
>+			Expression leftExpression = convert(leftOperand);
>+			infixExpression.setLeftOperand(leftExpression);
>+			infixExpression.setRightOperand((Expression)infixExpression.extendedOperands().remove(0));
>+			int startPosition = leftExpression.getStartPosition();
>+			infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
>+			return infixExpression;
> 		}
> 		Expression leftExpression = convert(expression.left);
> 		infixExpression.setLeftOperand(leftExpression);
>@@ -607,7 +670,6 @@
> 		int startPosition = leftExpression.getStartPosition();
> 		infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
> 		return infixExpression;
>-	
> 	}
> 
> 	public AnnotationTypeDeclaration convertToAnnotationDeclaration(org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDeclaration) {
>@@ -2019,16 +2081,79 @@
> 	}
> 
> 	public Expression convert(org.eclipse.jdt.internal.compiler.ast.OR_OR_Expression expression) {
>-		final InfixExpression infixExpression = new InfixExpression(this.ast);
>+		InfixExpression infixExpression = new InfixExpression(this.ast);
>+		infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_OR);
> 		if (this.resolveBindings) {
>-			recordNodes(infixExpression, expression);
>+			this.recordNodes(infixExpression, expression);
>+		}
>+		final int expressionOperatorID = (expression.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT;
>+		if (expression.left instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
>+				&& ((expression.left.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)) {
>+			// create an extended string literal equivalent => use the extended operands list
>+			infixExpression.extendedOperands().add(convert(expression.right));
>+			org.eclipse.jdt.internal.compiler.ast.Expression leftOperand = expression.left;
>+			org.eclipse.jdt.internal.compiler.ast.Expression rightOperand = null;
>+			do {
>+				rightOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).right;
>+				if ((((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID
>+							&& ((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))
>+					 || ((rightOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
>+				 			&& ((rightOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID)
>+							&& ((rightOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))) {
>+				 	List extendedOperands = infixExpression.extendedOperands();
>+				 	InfixExpression temp = new InfixExpression(this.ast);
>+					if (this.resolveBindings) {
>+						this.recordNodes(temp, expression);
>+					}
>+				 	temp.setOperator(getOperatorFor(expressionOperatorID));
>+				 	Expression leftSide = convert(leftOperand);
>+					temp.setLeftOperand(leftSide);
>+					temp.setSourceRange(leftSide.getStartPosition(), leftSide.getLength());
>+					int size = extendedOperands.size();
>+				 	for (int i = 0; i < size - 1; i++) {
>+				 		Expression expr = temp;
>+				 		temp = new InfixExpression(this.ast);
>+				 		
>+						if (this.resolveBindings) {
>+							this.recordNodes(temp, expression);
>+						}				 	
>+				 		temp.setLeftOperand(expr);
>+					 	temp.setOperator(getOperatorFor(expressionOperatorID));
>+						temp.setSourceRange(expr.getStartPosition(), expr.getLength());
>+				 	}
>+				 	infixExpression = temp;
>+				 	for (int i = 0; i < size; i++) {
>+				 		Expression extendedOperand = (Expression) extendedOperands.remove(size - 1 - i);
>+				 		temp.setRightOperand(extendedOperand);
>+				 		int startPosition = temp.getLeftOperand().getStartPosition();
>+				 		temp.setSourceRange(startPosition, extendedOperand.getStartPosition() + extendedOperand.getLength() - startPosition);
>+				 		if (temp.getLeftOperand().getNodeType() == ASTNode.INFIX_EXPRESSION) {
>+				 			temp = (InfixExpression) temp.getLeftOperand();
>+				 		}
>+				 	}
>+					int startPosition = infixExpression.getLeftOperand().getStartPosition();
>+					infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
>+					if (this.resolveBindings) {
>+						this.recordNodes(infixExpression, expression);
>+					}
>+					return infixExpression;
>+				}
>+				infixExpression.extendedOperands().add(0, convert(rightOperand));
>+				leftOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).left;
>+			} while (leftOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression && ((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0));
>+			Expression leftExpression = convert(leftOperand);
>+			infixExpression.setLeftOperand(leftExpression);
>+			infixExpression.setRightOperand((Expression)infixExpression.extendedOperands().remove(0));
>+			int startPosition = leftExpression.getStartPosition();
>+			infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
>+			return infixExpression;
> 		}
> 		Expression leftExpression = convert(expression.left);
> 		infixExpression.setLeftOperand(leftExpression);
> 		infixExpression.setRightOperand(convert(expression.right));
> 		infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_OR);
>-		int sourceStart = leftExpression.getStartPosition();
>-		infixExpression.setSourceRange(sourceStart, expression.sourceEnd - sourceStart + 1);
>+		int startPosition = leftExpression.getStartPosition();
>+		infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
> 		return infixExpression;
> 	}
>

Actions: View | Diff

Attachments on bug 109333: 27054 | 27055