Attachment #131006 for bug #270367




	 */
	boolean resolveBoxing(Expression expression) {
		org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);
		if (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression) {
			org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;
			return (compilerExpression.implicitConversion & TypeIds.BOXING) != 0;
		}

	 */
	boolean resolveUnboxing(Expression expression) {
		org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);
		if (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression) {
			org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;
			return (compilerExpression.implicitConversion & TypeIds.UNBOXING) != 0;
		}

	 */
	Object resolveConstantExpressionValue(Expression expression) {
		org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);
		if (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression) {
			org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;
			Constant constant = compilerExpression.constant;
			if (constant != null && constant != Constant.NotAConstant) {

						if (typeBinding != null) {
							return typeBinding;
						}
					} else if (astNode instanceof AllocationExpression) {
						// should be an AllocationExpression
						AllocationExpression allocationExpression = (AllocationExpression) astNode;
						return this.getTypeBinding(allocationExpression.resolvedType);

				case ASTNode.CHARACTER_LITERAL :
				case ASTNode.NUMBER_LITERAL :
					Literal literal = (Literal) this.newAstToOldAst.get(expression);
					if (literal != null) {
						return this.getTypeBinding(literal.literalType(null));
					}
					break;
				case ASTNode.THIS_EXPRESSION :
					ThisReference thisReference = (ThisReference) this.newAstToOldAst.get(expression);
					BlockScope blockScope = (BlockScope) this.astNodesToBlockScope.get(expression);

							}
						}
					}
				}
			}
		} else if (node instanceof QualifiedSuperReference) {
			QualifiedSuperReference qualifiedSuperReference = (QualifiedSuperReference) node;

		org.eclipse.jdt.internal.compiler.ast.Expression expression = (org.eclipse.jdt.internal.compiler.ast.Expression) this.newAstToOldAst.get(ref);
		if (expression instanceof TypeReference) {
			return getTypeBinding(expression.resolvedType);
		} else if (expression instanceof JavadocFieldReference) {
		else if (expression instanceof JavadocFieldReference) {
			JavadocFieldReference fieldRef = (JavadocFieldReference) expression;
			if (fieldRef.methodBinding != null) {
				return getMethodBinding(fieldRef.methodBinding);

	 */
	synchronized IMemberValuePairBinding resolveMemberValuePair(org.eclipse.jdt.core.dom.MemberValuePair memberValuePair) {
		MemberValuePair valuePair = (MemberValuePair) this.newAstToOldAst.get(memberValuePair);
		if (valuePair != null) {
			return getMemberValuePairBinding(valuePair.compilerElementPair);
		}
		return null;
	}

	/* (non-Javadoc)

		org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(type);
		org.eclipse.jdt.internal.compiler.lookup.TypeBinding binding = null;
		if (node != null) {
			if (node instanceof ParameterizedQualifiedTypeReference) {
 				ParameterizedQualifiedTypeReference typeReference = (ParameterizedQualifiedTypeReference) node;
				org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding = typeReference.resolvedType;
				int index;
				if (type.isQualifiedType()) {
					index = ((QualifiedType) type).index;
				} else if (type.isParameterizedType()) {
					index = ((ParameterizedType) type).index;
				} else {
					index = 1;
				}
				final int numberOfTypeArgumentsNotNull = getTypeArguments(typeReference);
				if (index != numberOfTypeArgumentsNotNull) {
					int  i = numberOfTypeArgumentsNotNull;
					while (i != index) {
						typeBinding = typeBinding.enclosingType();
						i --;
					}
	 				binding = typeBinding;
 				} else {
					binding = typeBinding;
				} else {
					binding = typeBinding;
				}
			} else if (node instanceof TypeReference) {
				TypeReference typeReference = (TypeReference) node;
				binding = typeReference.resolvedType;
			} else if (node instanceof SingleNameReference && ((SingleNameReference)node).isTypeReference()) {




	}

	static {
//		TESTS_NUMBERS = new int[] { 324 };
//		TESTS_RANGE = new int[] { 308, -1 };
//		TESTS_NAMES = new String[] {"test0204"};
	}

			);
		assertNotNull("No node", buildAST(contents, this.workingCopy, false, true, true));
	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=270367
	public void test0324() throws JavaModelException {
		String contents = "package test0324;\n"
			+ "public class X {\n"
			+ "  public void someMethod() {\n"
			+ "     int i = /*start*/(new Integer(getId())).intValue()/*end*/;\n"
			+ "  }\n"
			+ "  public String getId() {\n"
			+ "     return null;\n"
			+ "  }\n"
			+ "}";
		this.workingCopy = getWorkingCopy("/Converter15/src/test0324/X.java", contents, true/*resolve*/
		);
		MethodInvocation methodCall = (MethodInvocation) buildAST(contents, this.workingCopy, false, true, true);
		ParenthesizedExpression intValueReceiver = (ParenthesizedExpression) methodCall.getExpression();
		ParenthesizedExpression newParenthesizedExpression = (ParenthesizedExpression) ASTNode.copySubtree(
				intValueReceiver.getAST(), intValueReceiver);
		replaceNodeInParent(methodCall, newParenthesizedExpression);
		
		// copied node
		ClassInstanceCreation constructorCall = (ClassInstanceCreation) newParenthesizedExpression.getExpression();
		constructorCall.resolveTypeBinding();
		IMethodBinding constructorBinding = constructorCall.resolveConstructorBinding();
		assertNull("Not null constructor binding", constructorBinding);

		// original node
		constructorCall = (ClassInstanceCreation) intValueReceiver.getExpression();
		constructorCall.resolveTypeBinding(); // This should not throw a NPE
		constructorBinding = constructorCall.resolveConstructorBinding();
		assertNotNull("Null constructor binding", constructorBinding);
	}

	// Utility method to replace "node" by "replacement"
	private void replaceNodeInParent(Expression node, Expression replacement) {
		StructuralPropertyDescriptor loc = node.getLocationInParent();
		if (loc.isChildProperty()) {
			node.getParent().setStructuralProperty(loc, replacement);
		}
		else {
			List l = (List) node.getParent().getStructuralProperty(loc);
			for (int i = 0; i < l.size(); i++) {
				if (node.equals(l.get(i))) {
					l.set(i, replacement);
					break;
				}
			}
		}
	}
}

Return to bug 270367

Lines 550-556 Link Here

(-)dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java (-30 / +35 lines)
550	*/	550	*/
551	boolean resolveBoxing(Expression expression) {	551	boolean resolveBoxing(Expression expression) {
552	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);	552	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);
553	if (node != null && (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression)) {	553	if (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression) {
554	org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;	554	org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;
555	return (compilerExpression.implicitConversion & TypeIds.BOXING) != 0;	555	return (compilerExpression.implicitConversion & TypeIds.BOXING) != 0;
556	}	556	}
Lines 562-568 Link Here
562	*/	562	*/
563	boolean resolveUnboxing(Expression expression) {	563	boolean resolveUnboxing(Expression expression) {
564	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);	564	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);
565	if (node != null && (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression)) {	565	if (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression) {
566	org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;	566	org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;
567	return (compilerExpression.implicitConversion & TypeIds.UNBOXING) != 0;	567	return (compilerExpression.implicitConversion & TypeIds.UNBOXING) != 0;
568	}	568	}
Lines 574-580 Link Here
574	*/	574	*/
575	Object resolveConstantExpressionValue(Expression expression) {	575	Object resolveConstantExpressionValue(Expression expression) {
576	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);	576	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(expression);
577	if (node != null && (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression)) {	577	if (node instanceof org.eclipse.jdt.internal.compiler.ast.Expression) {
578	org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;	578	org.eclipse.jdt.internal.compiler.ast.Expression compilerExpression = (org.eclipse.jdt.internal.compiler.ast.Expression) node;
579	Constant constant = compilerExpression.constant;	579	Constant constant = compilerExpression.constant;
580	if (constant != null && constant != Constant.NotAConstant) {	580	if (constant != null && constant != Constant.NotAConstant) {
Lines 662-668 Link Here
662	if (typeBinding != null) {	662	if (typeBinding != null) {
663	return typeBinding;	663	return typeBinding;
664	}	664	}
665	} else {	665	} else if (astNode instanceof AllocationExpression) {
666	// should be an AllocationExpression	666	// should be an AllocationExpression
667	AllocationExpression allocationExpression = (AllocationExpression) astNode;	667	AllocationExpression allocationExpression = (AllocationExpression) astNode;
668	return this.getTypeBinding(allocationExpression.resolvedType);	668	return this.getTypeBinding(allocationExpression.resolvedType);
Lines 704-710 Link Here
704	case ASTNode.CHARACTER_LITERAL :	704	case ASTNode.CHARACTER_LITERAL :
705	case ASTNode.NUMBER_LITERAL :	705	case ASTNode.NUMBER_LITERAL :
706	Literal literal = (Literal) this.newAstToOldAst.get(expression);	706	Literal literal = (Literal) this.newAstToOldAst.get(expression);
707	return this.getTypeBinding(literal.literalType(null));	707	if (literal != null) {
		708	return this.getTypeBinding(literal.literalType(null));
		709	}
		710	break;
708	case ASTNode.THIS_EXPRESSION :	711	case ASTNode.THIS_EXPRESSION :
709	ThisReference thisReference = (ThisReference) this.newAstToOldAst.get(expression);	712	ThisReference thisReference = (ThisReference) this.newAstToOldAst.get(expression);
710	BlockScope blockScope = (BlockScope) this.astNodesToBlockScope.get(expression);	713	BlockScope blockScope = (BlockScope) this.astNodesToBlockScope.get(expression);
Lines 1302-1308 Link Here
1302	}	1305	}
1303	}	1306	}
1304	}	1307	}
1305	}	1308	}
1306	}	1309	}
1307	} else if (node instanceof QualifiedSuperReference) {	1310	} else if (node instanceof QualifiedSuperReference) {
1308	QualifiedSuperReference qualifiedSuperReference = (QualifiedSuperReference) node;	1311	QualifiedSuperReference qualifiedSuperReference = (QualifiedSuperReference) node;
Lines 1398-1405 Link Here
1398	org.eclipse.jdt.internal.compiler.ast.Expression expression = (org.eclipse.jdt.internal.compiler.ast.Expression) this.newAstToOldAst.get(ref);	1401	org.eclipse.jdt.internal.compiler.ast.Expression expression = (org.eclipse.jdt.internal.compiler.ast.Expression) this.newAstToOldAst.get(ref);
1399	if (expression instanceof TypeReference) {	1402	if (expression instanceof TypeReference) {
1400	return getTypeBinding(expression.resolvedType);	1403	return getTypeBinding(expression.resolvedType);
1401	}	1404	} else if (expression instanceof JavadocFieldReference) {
1402	else if (expression instanceof JavadocFieldReference) {
1403	JavadocFieldReference fieldRef = (JavadocFieldReference) expression;	1405	JavadocFieldReference fieldRef = (JavadocFieldReference) expression;
1404	if (fieldRef.methodBinding != null) {	1406	if (fieldRef.methodBinding != null) {
1405	return getMethodBinding(fieldRef.methodBinding);	1407	return getMethodBinding(fieldRef.methodBinding);
Lines 1415-1421 Link Here
1415	*/	1417	*/
1416	synchronized IMemberValuePairBinding resolveMemberValuePair(org.eclipse.jdt.core.dom.MemberValuePair memberValuePair) {	1418	synchronized IMemberValuePairBinding resolveMemberValuePair(org.eclipse.jdt.core.dom.MemberValuePair memberValuePair) {
1417	MemberValuePair valuePair = (MemberValuePair) this.newAstToOldAst.get(memberValuePair);	1419	MemberValuePair valuePair = (MemberValuePair) this.newAstToOldAst.get(memberValuePair);
1418	return getMemberValuePairBinding(valuePair.compilerElementPair);	1420	if (valuePair != null) {
		1421	return getMemberValuePairBinding(valuePair.compilerElementPair);
		1422	}
		1423	return null;
1419	}	1424	}
1420		1425
1421	/* (non-Javadoc)	1426	/* (non-Javadoc)
Lines 1503-1531 Link Here
1503	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(type);	1508	org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(type);
1504	org.eclipse.jdt.internal.compiler.lookup.TypeBinding binding = null;	1509	org.eclipse.jdt.internal.compiler.lookup.TypeBinding binding = null;
1505	if (node != null) {	1510	if (node != null) {
1506	if (node instanceof ParameterizedQualifiedTypeReference) {	1511	if (node instanceof ParameterizedQualifiedTypeReference) {
1507	ParameterizedQualifiedTypeReference typeReference = (ParameterizedQualifiedTypeReference) node;	1512	ParameterizedQualifiedTypeReference typeReference = (ParameterizedQualifiedTypeReference) node;
1508	org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding = typeReference.resolvedType;	1513	org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding = typeReference.resolvedType;
1509	int index;	1514	int index;
1510	if (type.isQualifiedType()) {	1515	if (type.isQualifiedType()) {
1511	index = ((QualifiedType) type).index;	1516	index = ((QualifiedType) type).index;
1512	} else if (type.isParameterizedType()) {	1517	} else if (type.isParameterizedType()) {
1513	index = ((ParameterizedType) type).index;	1518	index = ((ParameterizedType) type).index;
1514	} else {	1519	} else {
1515	index = 1;	1520	index = 1;
1516	}	1521	}
1517	final int numberOfTypeArgumentsNotNull = getTypeArguments(typeReference);	1522	final int numberOfTypeArgumentsNotNull = getTypeArguments(typeReference);
1518	if (index != numberOfTypeArgumentsNotNull) {	1523	if (index != numberOfTypeArgumentsNotNull) {
1519	int i = numberOfTypeArgumentsNotNull;	1524	int i = numberOfTypeArgumentsNotNull;
1520	while (i != index) {	1525	while (i != index) {
1521	typeBinding = typeBinding.enclosingType();	1526	typeBinding = typeBinding.enclosingType();
1522	i --;	1527	i --;
1523	}	1528	}
1524	binding = typeBinding;
1525	} else {
1526	binding = typeBinding;	1529	binding = typeBinding;
1527	}	1530	} else {
1528	} else if (node instanceof TypeReference) {	1531	binding = typeBinding;
		1532	}
		1533	} else if (node instanceof TypeReference) {
1529	TypeReference typeReference = (TypeReference) node;	1534	TypeReference typeReference = (TypeReference) node;
1530	binding = typeReference.resolvedType;	1535	binding = typeReference.resolvedType;
1531	} else if (node instanceof SingleNameReference && ((SingleNameReference)node).isTypeReference()) {	1536	} else if (node instanceof SingleNameReference && ((SingleNameReference)node).isTypeReference()) {

Lines 46-52 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java (-1 / +50 lines)
46	}	46	}
47		47
48	static {	48	static {
49	// TESTS_NUMBERS = new int[] { 323 };	49	// TESTS_NUMBERS = new int[] { 324 };
50	// TESTS_RANGE = new int[] { 308, -1 };	50	// TESTS_RANGE = new int[] { 308, -1 };
51	// TESTS_NAMES = new String[] {"test0204"};	51	// TESTS_NAMES = new String[] {"test0204"};
52	}	52	}
Lines 10491-10494 Link Here
10491	);	10491	);
10492	assertNotNull("No node", buildAST(contents, this.workingCopy, false, true, true));	10492	assertNotNull("No node", buildAST(contents, this.workingCopy, false, true, true));
10493	}	10493	}
		10494
		10495	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=270367
		10496	public void test0324() throws JavaModelException {
		10497	String contents = "package test0324;\n"
		10498	+ "public class X {\n"
		10499	+ " public void someMethod() {\n"
		10500	+ " int i = /start/(new Integer(getId())).intValue()/end/;\n"
		10501	+ " }\n"
		10502	+ " public String getId() {\n"
		10503	+ " return null;\n"
		10504	+ " }\n"
		10505	+ "}";
		10506	this.workingCopy = getWorkingCopy("/Converter15/src/test0324/X.java", contents, true/resolve/
		10507	);
		10508	MethodInvocation methodCall = (MethodInvocation) buildAST(contents, this.workingCopy, false, true, true);
		10509	ParenthesizedExpression intValueReceiver = (ParenthesizedExpression) methodCall.getExpression();
		10510	ParenthesizedExpression newParenthesizedExpression = (ParenthesizedExpression) ASTNode.copySubtree(
		10511	intValueReceiver.getAST(), intValueReceiver);
		10512	replaceNodeInParent(methodCall, newParenthesizedExpression);
		10513
		10514	// copied node
		10515	ClassInstanceCreation constructorCall = (ClassInstanceCreation) newParenthesizedExpression.getExpression();
		10516	constructorCall.resolveTypeBinding();
		10517	IMethodBinding constructorBinding = constructorCall.resolveConstructorBinding();
		10518	assertNull("Not null constructor binding", constructorBinding);
		10519
		10520	// original node
		10521	constructorCall = (ClassInstanceCreation) intValueReceiver.getExpression();
		10522	constructorCall.resolveTypeBinding(); // This should not throw a NPE
		10523	constructorBinding = constructorCall.resolveConstructorBinding();
		10524	assertNotNull("Null constructor binding", constructorBinding);
		10525	}
		10526
		10527	// Utility method to replace "node" by "replacement"
		10528	private void replaceNodeInParent(Expression node, Expression replacement) {
		10529	StructuralPropertyDescriptor loc = node.getLocationInParent();
		10530	if (loc.isChildProperty()) {
		10531	node.getParent().setStructuralProperty(loc, replacement);
		10532	}
		10533	else {
		10534	List l = (List) node.getParent().getStructuralProperty(loc);
		10535	for (int i = 0; i < l.size(); i++) {
		10536	if (node.equals(l.get(i))) {
		10537	l.set(i, replacement);
		10538	break;
		10539	}
		10540	}
		10541	}
		10542	}
10494	}	10543	}