org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MemberValuePair.java - objectteams/org.eclipse.objectteams - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2017 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *     Stephan Herrmann - Contributions for
  *								bug 186342 - [compiler][null] Using annotations for null checking
  *								bug 365519 - editorial cleanup after bug 186342 and bug 365387
  *								Bug 434570 - Generic type mismatch for parametrized class annotation attribute with inner class
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.ast;

 import org.eclipse.jdt.internal.compiler.ASTVisitor;
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 import org.eclipse.jdt.internal.compiler.lookup.Binding;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
 import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
 import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
 import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
 import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;

 /**
  * MemberValuePair node
  */
 public class MemberValuePair extends ASTNode {

 	public char[] name;
 	public Expression value;
 	public MethodBinding binding;
 	/**
 	 *  The representation of this pair in the type system.
 	 */
 	public ElementValuePair compilerElementPair = null;

 	public MemberValuePair(char[] token, int sourceStart, int sourceEnd, Expression value) {
 		this.name = token;
 		this.sourceStart = sourceStart;
 		this.sourceEnd = sourceEnd;
 		this.value = value;
 		if (value instanceof ArrayInitializer) {
 			value.bits |= IsAnnotationDefaultValue;
 		}
 	}

 	@Override
 	public StringBuffer print(int indent, StringBuffer output) {
 		output
 			.append(this.name)
 			.append(" = "); //$NON-NLS-1$
 		this.value.print(0, output);
 		return output;
 	}

 	public void resolveTypeExpecting(final BlockScope scope, final TypeBinding requiredType) {
 		if (this.compilerElementPair != null) {
 			return;
 		}

 		if (this.value == null) {
 			this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
 			return;
 		}
 		if (requiredType == null) {
 			// fault tolerance: keep resolving
 			if (this.value instanceof ArrayInitializer) {
 				this.value.resolveTypeExpecting(scope, null);
 			} else {
 				this.value.resolveType(scope);
 			}
 			this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
 			return;
 		}

 		this.value.setExpectedType(requiredType); // needed in case of generic method invocation - looks suspect, generic method invocation here ???
 		final TypeBinding valueType;
 		if (this.value instanceof ArrayInitializer) {
 			ArrayInitializer initializer = (ArrayInitializer) this.value;
 			valueType = initializer.resolveTypeExpecting(scope, this.binding.returnType);
 		} else if (this.value instanceof ArrayAllocationExpression) {
 			scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
 			this.value.resolveType(scope);
 			valueType = null; // no need to pursue
 		} else {
 			valueType = this.value.resolveType(scope);
 			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=248897
 			ASTVisitor visitor = new ASTVisitor() {
 				@Override
 				public boolean visit(SingleNameReference reference, BlockScope scop) {
 					if (reference.binding instanceof LocalVariableBinding) {
 						((LocalVariableBinding) reference.binding).useFlag = LocalVariableBinding.USED;
 					}
 					return true;
 				}
 			};
 			this.value.traverse(visitor, scope);
 		}
 		this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
 		if (valueType == null)
 			return;

 		final TypeBinding leafType = requiredType.leafComponentType();
 		// the next check may need deferring:
 		final boolean[] shouldExit = { false };
 		Runnable check = new Runnable() {
 			@Override
 			public void run() {
 				if (!(MemberValuePair.this.value.isConstantValueOfTypeAssignableToType(valueType, requiredType)
 						|| valueType.isCompatibleWith(requiredType))) {
 					if (!(requiredType.isArrayType()
 							&& requiredType.dimensions() == 1
 							&& (MemberValuePair.this.value.isConstantValueOfTypeAssignableToType(valueType, leafType)
 									|| valueType.isCompatibleWith(leafType)))) {

 						if (leafType.isAnnotationType() && !valueType.isAnnotationType()) {
 							scope.problemReporter().annotationValueMustBeAnnotation(MemberValuePair.this.binding.declaringClass,
 									MemberValuePair.this.name, MemberValuePair.this.value, leafType);
 						} else {
 							scope.problemReporter().typeMismatchError(valueType, requiredType, MemberValuePair.this.value, null);
 						}
 						shouldExit[0] = true; // TODO may allow to proceed to find more errors at once
 					}
 				} else {
 					scope.compilationUnitScope().recordTypeConversion(requiredType.leafComponentType(), valueType.leafComponentType());
 					MemberValuePair.this.value.computeConversion(scope, requiredType, valueType);
 				}
 			}
 		};
 		// ... now or later?
 		if (!scope.deferCheck(check)) {
 			check.run();
 			if (shouldExit[0])
 				return;
 		}

 		// annotation methods can only return base types, String, Class, enum type, annotation types and arrays of these
 		checkAnnotationMethodType: {
 			switch (leafType.erasure().id) {
 				case T_byte :
 				case T_short :
 				case T_char :
 				case T_int :
 				case T_long :
 				case T_float :
 				case T_double :
 				case T_boolean :
 				case T_JavaLangString :
 					if (this.value instanceof ArrayInitializer) {
 						ArrayInitializer initializer = (ArrayInitializer) this.value;
 						final Expression[] expressions = initializer.expressions;
 						if (expressions != null) {
 							for (int i =0, max = expressions.length; i < max; i++) {
 								Expression expression = expressions[i];
 								if (expression.resolvedType == null) continue; // fault-tolerance
 								if (expression.constant == Constant.NotAConstant) {
 									scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, expressions[i], false);
 								}
 							}
 						}
 					} else if (this.value.constant == Constant.NotAConstant) {
 						if (valueType.isArrayType()) {
 							scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
 						} else {
 							scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, false);
 						}
 					}
 					break checkAnnotationMethodType;
 				case T_JavaLangClass :
 					if (this.value instanceof ArrayInitializer) {
 						ArrayInitializer initializer = (ArrayInitializer) this.value;
 						final Expression[] expressions = initializer.expressions;
 						if (expressions != null) {
 							for (int i =0, max = expressions.length; i < max; i++) {
 								Expression currentExpression = expressions[i];
 								if (!(currentExpression instanceof ClassLiteralAccess)) {
 									scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, currentExpression);
 								}
 							}
 						}
 					} else if (!(this.value instanceof ClassLiteralAccess)) {
 						scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, this.value);
 					}
 					break checkAnnotationMethodType;
 			}
 			if (leafType.isEnum()) {
 				if (this.value instanceof NullLiteral) {
 					scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
 				} else if (this.value instanceof ArrayInitializer) {
 					ArrayInitializer initializer = (ArrayInitializer) this.value;
 					final Expression[] expressions = initializer.expressions;
 					if (expressions != null) {
 						for (int i =0, max = expressions.length; i < max; i++) {
 							Expression currentExpression = expressions[i];
 							if (currentExpression instanceof NullLiteral) {
 								scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
 							} else if (currentExpression instanceof NameReference) {
 								NameReference nameReference = (NameReference) currentExpression;
 								final Binding nameReferenceBinding = nameReference.binding;
 								if (nameReferenceBinding.kind() == Binding.FIELD) {
 									FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
 									if (!fieldBinding.declaringClass.isEnum()) {
 										scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
 									}
 								}
 							}
 						}
 					}
 				} else if (this.value instanceof NameReference) {
 					NameReference nameReference = (NameReference) this.value;
 					final Binding nameReferenceBinding = nameReference.binding;
 					if (nameReferenceBinding.kind() == Binding.FIELD) {
 						FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
 						if (!fieldBinding.declaringClass.isEnum()) {
 							if (!fieldBinding.type.isArrayType()) {
 								scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
 							} else {
 								scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
 							}
 						}
 					}
 				}  else {
 					scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
 				}
 				break checkAnnotationMethodType;
 			}
 			if (leafType.isAnnotationType()) {
 				if (!valueType.leafComponentType().isAnnotationType()) { // check annotation type and also reject null literal
 					scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
 				} else if (this.value instanceof ArrayInitializer) {
 					ArrayInitializer initializer = (ArrayInitializer) this.value;
 					final Expression[] expressions = initializer.expressions;
 					if (expressions != null) {
 						for (int i =0, max = expressions.length; i < max; i++) {
 							Expression currentExpression = expressions[i];
 							if (currentExpression instanceof NullLiteral || !(currentExpression instanceof Annotation)) {
 								scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, currentExpression, leafType);
 							}
 						}
 					}
 				} else if (!(this.value instanceof Annotation)) {
 					scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
 				}
 				break checkAnnotationMethodType;
 			}
 		}
 	}

 	@Override
 	public void traverse(ASTVisitor visitor, BlockScope scope) {
 		if (visitor.visit(this, scope)) {
 			if (this.value != null) {
 				this.value.traverse(visitor, scope);
 			}
 		}
 		visitor.endVisit(this, scope);
 	}
 	public void traverse(ASTVisitor visitor, ClassScope scope) {
 		if (visitor.visit(this, scope)) {
 			if (this.value != null) {
 				this.value.traverse(visitor, scope);
 			}
 		}
 		visitor.endVisit(this, scope);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2017 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Stephan Herrmann - Contributions for
	* bug 186342 - [compiler][null] Using annotations for null checking
	* bug 365519 - editorial cleanup after bug 186342 and bug 365387
	* Bug 434570 - Generic type mismatch for parametrized class annotation attribute with inner class
	*******************************************************************************/
	package org.eclipse.jdt.internal.compiler.ast;

	import org.eclipse.jdt.internal.compiler.ASTVisitor;
	import org.eclipse.jdt.internal.compiler.impl.Constant;
	import org.eclipse.jdt.internal.compiler.lookup.Binding;
	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
	import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
	import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;

	/**
	* MemberValuePair node
	*/
	public class MemberValuePair extends ASTNode {

	public char[] name;
	public Expression value;
	public MethodBinding binding;
	/**
	* The representation of this pair in the type system.
	*/
	public ElementValuePair compilerElementPair = null;

	public MemberValuePair(char[] token, int sourceStart, int sourceEnd, Expression value) {
	this.name = token;
	this.sourceStart = sourceStart;
	this.sourceEnd = sourceEnd;
	this.value = value;
	if (value instanceof ArrayInitializer) {
	value.bits \|= IsAnnotationDefaultValue;
	}
	}

	@Override
	public StringBuffer print(int indent, StringBuffer output) {
	output
	.append(this.name)
	.append(" = "); //$NON-NLS-1$
	this.value.print(0, output);
	return output;
	}

	public void resolveTypeExpecting(final BlockScope scope, final TypeBinding requiredType) {
	if (this.compilerElementPair != null) {
	return;
	}

	if (this.value == null) {
	this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
	return;
	}
	if (requiredType == null) {
	// fault tolerance: keep resolving
	if (this.value instanceof ArrayInitializer) {
	this.value.resolveTypeExpecting(scope, null);
	} else {
	this.value.resolveType(scope);
	}
	this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
	return;
	}

	this.value.setExpectedType(requiredType); // needed in case of generic method invocation - looks suspect, generic method invocation here ???
	final TypeBinding valueType;
	if (this.value instanceof ArrayInitializer) {
	ArrayInitializer initializer = (ArrayInitializer) this.value;
	valueType = initializer.resolveTypeExpecting(scope, this.binding.returnType);
	} else if (this.value instanceof ArrayAllocationExpression) {
	scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
	this.value.resolveType(scope);
	valueType = null; // no need to pursue
	} else {
	valueType = this.value.resolveType(scope);
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=248897
	ASTVisitor visitor = new ASTVisitor() {
	@Override
	public boolean visit(SingleNameReference reference, BlockScope scop) {
	if (reference.binding instanceof LocalVariableBinding) {
	((LocalVariableBinding) reference.binding).useFlag = LocalVariableBinding.USED;
	}
	return true;
	}
	};
	this.value.traverse(visitor, scope);
	}
	this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
	if (valueType == null)
	return;

	final TypeBinding leafType = requiredType.leafComponentType();
	// the next check may need deferring:
	final boolean[] shouldExit = { false };
	Runnable check = new Runnable() {
	@Override
	public void run() {
	if (!(MemberValuePair.this.value.isConstantValueOfTypeAssignableToType(valueType, requiredType)
	\|\| valueType.isCompatibleWith(requiredType))) {
	if (!(requiredType.isArrayType()
	&& requiredType.dimensions() == 1
	&& (MemberValuePair.this.value.isConstantValueOfTypeAssignableToType(valueType, leafType)
	\|\| valueType.isCompatibleWith(leafType)))) {

	if (leafType.isAnnotationType() && !valueType.isAnnotationType()) {
	scope.problemReporter().annotationValueMustBeAnnotation(MemberValuePair.this.binding.declaringClass,
	MemberValuePair.this.name, MemberValuePair.this.value, leafType);
	} else {
	scope.problemReporter().typeMismatchError(valueType, requiredType, MemberValuePair.this.value, null);
	}
	shouldExit[0] = true; // TODO may allow to proceed to find more errors at once
	}
	} else {
	scope.compilationUnitScope().recordTypeConversion(requiredType.leafComponentType(), valueType.leafComponentType());
	MemberValuePair.this.value.computeConversion(scope, requiredType, valueType);
	}
	}
	};
	// ... now or later?
	if (!scope.deferCheck(check)) {
	check.run();
	if (shouldExit[0])
	return;
	}

	// annotation methods can only return base types, String, Class, enum type, annotation types and arrays of these
	checkAnnotationMethodType: {
	switch (leafType.erasure().id) {
	case T_byte :
	case T_short :
	case T_char :
	case T_int :
	case T_long :
	case T_float :
	case T_double :
	case T_boolean :
	case T_JavaLangString :
	if (this.value instanceof ArrayInitializer) {
	ArrayInitializer initializer = (ArrayInitializer) this.value;
	final Expression[] expressions = initializer.expressions;
	if (expressions != null) {
	for (int i =0, max = expressions.length; i < max; i++) {
	Expression expression = expressions[i];
	if (expression.resolvedType == null) continue; // fault-tolerance
	if (expression.constant == Constant.NotAConstant) {
	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, expressions[i], false);
	}
	}
	}
	} else if (this.value.constant == Constant.NotAConstant) {
	if (valueType.isArrayType()) {
	scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
	} else {
	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, false);
	}
	}
	break checkAnnotationMethodType;
	case T_JavaLangClass :
	if (this.value instanceof ArrayInitializer) {
	ArrayInitializer initializer = (ArrayInitializer) this.value;
	final Expression[] expressions = initializer.expressions;
	if (expressions != null) {
	for (int i =0, max = expressions.length; i < max; i++) {
	Expression currentExpression = expressions[i];
	if (!(currentExpression instanceof ClassLiteralAccess)) {
	scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, currentExpression);
	}
	}
	}
	} else if (!(this.value instanceof ClassLiteralAccess)) {
	scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, this.value);
	}
	break checkAnnotationMethodType;
	}
	if (leafType.isEnum()) {
	if (this.value instanceof NullLiteral) {
	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
	} else if (this.value instanceof ArrayInitializer) {
	ArrayInitializer initializer = (ArrayInitializer) this.value;
	final Expression[] expressions = initializer.expressions;
	if (expressions != null) {
	for (int i =0, max = expressions.length; i < max; i++) {
	Expression currentExpression = expressions[i];
	if (currentExpression instanceof NullLiteral) {
	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
	} else if (currentExpression instanceof NameReference) {
	NameReference nameReference = (NameReference) currentExpression;
	final Binding nameReferenceBinding = nameReference.binding;
	if (nameReferenceBinding.kind() == Binding.FIELD) {
	FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
	if (!fieldBinding.declaringClass.isEnum()) {
	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
	}
	}
	}
	}
	}
	} else if (this.value instanceof NameReference) {
	NameReference nameReference = (NameReference) this.value;
	final Binding nameReferenceBinding = nameReference.binding;
	if (nameReferenceBinding.kind() == Binding.FIELD) {
	FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
	if (!fieldBinding.declaringClass.isEnum()) {
	if (!fieldBinding.type.isArrayType()) {
	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
	} else {
	scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
	}
	}
	}
	} else {
	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
	}
	break checkAnnotationMethodType;
	}
	if (leafType.isAnnotationType()) {
	if (!valueType.leafComponentType().isAnnotationType()) { // check annotation type and also reject null literal
	scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
	} else if (this.value instanceof ArrayInitializer) {
	ArrayInitializer initializer = (ArrayInitializer) this.value;
	final Expression[] expressions = initializer.expressions;
	if (expressions != null) {
	for (int i =0, max = expressions.length; i < max; i++) {
	Expression currentExpression = expressions[i];
	if (currentExpression instanceof NullLiteral \|\| !(currentExpression instanceof Annotation)) {
	scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, currentExpression, leafType);
	}
	}
	}
	} else if (!(this.value instanceof Annotation)) {
	scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
	}
	break checkAnnotationMethodType;
	}
	}
	}

	@Override
	public void traverse(ASTVisitor visitor, BlockScope scope) {
	if (visitor.visit(this, scope)) {
	if (this.value != null) {
	this.value.traverse(visitor, scope);
	}
	}
	visitor.endVisit(this, scope);
	}
	public void traverse(ASTVisitor visitor, ClassScope scope) {
	if (visitor.visit(this, scope)) {
	if (this.value != null) {
	this.value.traverse(visitor, scope);
	}
	}
	visitor.endVisit(this, scope);
	}
	}