Attachment #174374 for bug #277574

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 1-5 Link Here

(-)eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.java (-2 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 28-34 Link Here
28		28
29	public static String ASTInstructionCompiler_unrecognized_postfix_operator____15;	29	public static String ASTInstructionCompiler_unrecognized_postfix_operator____15;
30	public static String ASTInstructionCompiler_unrecognized_prefix_operator____16;	30	public static String ASTInstructionCompiler_unrecognized_prefix_operator____16;
31	public static String ASTInstructionCompiler_binding_null_for__17;
32		31
33	public static String ASTInstructionCompiler_super_constructor_invocation_cannot_be_used_in_an_evaluation_expression_19;	32	public static String ASTInstructionCompiler_super_constructor_invocation_cannot_be_used_in_an_evaluation_expression_19;
34	public static String ASTInstructionCompiler_Try_statement_cannot_be_used_in_an_evaluation_expression_23;	33	public static String ASTInstructionCompiler_Try_statement_cannot_be_used_in_an_evaluation_expression_23;
Lines 48-55 Link Here
48	public static String ASTEvaluationEngine_AST_evaluation_engine_cannot_evaluate_expression;	47	public static String ASTEvaluationEngine_AST_evaluation_engine_cannot_evaluate_expression;
49	public static String ASTEvaluationEngine_An_unknown_error_occurred_during_evaluation;	48	public static String ASTEvaluationEngine_An_unknown_error_occurred_during_evaluation;
50	public static String ASTEvaluationEngine_Cannot_perform_nested_evaluations;	49	public static String ASTEvaluationEngine_Cannot_perform_nested_evaluations;
		50	public static String ASTInstructionCompiler_3;
51	public static String ASTInstructionCompiler_36;	51	public static String ASTInstructionCompiler_36;
52	public static String ASTInstructionCompiler_0;	52	public static String ASTInstructionCompiler_0;
		53	public static String ASTInstructionCompiler_1;
		54	public static String ASTInstructionCompiler_2;
		55	public static String ASTInstructionCompiler_5;
53		56
54	static {	57	static {
55	// load message values from bundle file	58	// load message values from bundle file




import org.eclipse.jdt.internal.debug.eval.ast.instructions.Value;
import org.eclipse.jdt.internal.debug.eval.ast.instructions.XorAssignmentOperator;
import org.eclipse.jdt.internal.debug.eval.ast.instructions.XorOperator;
import com.ibm.icu.text.MessageFormat;
/**
 * The AST instruction compiler generates a sequence
 * of instructions (InstructionSequence) from a


		if (expression instanceof MethodInvocation) {
			IMethodBinding methodBinding= (IMethodBinding)((MethodInvocation)expression).getName().resolveBinding();
			if (methodBinding != null && "void".equals(methodBinding.getReturnType().getName())) { //$NON-NLS-1$
				pop= false;
			}
		} else if (expression instanceof SuperMethodInvocation) {
			IMethodBinding methodBinding= (IMethodBinding)((SuperMethodInvocation)expression).getName().resolveBinding();
			if (methodBinding != null && "void".equals(methodBinding.getReturnType().getName())) { //$NON-NLS-1$
				pop= false;
			}
		} else if (expression instanceof VariableDeclarationExpression) {

	public void endVisit(ArrayAccess node) {
		if (!isActive() || hasErrors())
			return;
		ITypeBinding typeBinding = node.getIndex().resolveTypeBinding();
		if (typeBinding != null) {
			storeInstruction();
		}
	}

	/**


		ArrayType arrayType= node.getType();

		ITypeBinding binding = resolveTypeBinding(arrayType);
		if (binding != null && isALocalType(arrayType.resolveBinding().getElementType())) {
			addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Local_type_array_instance_creation_cannot_be_used_in_an_evaluation_expression_29); 
			setHasError(true);
			return false;
		}

		push(new ArrayAllocation(arrayType.getDimensions(), node.dimensions().size(), node.getInitializer() != null, fCounter));

			return false;
		}

		ITypeBinding typeBinding= resolveTypeBinding(node);
		if (typeBinding != null) {
			int dimension = typeBinding.getDimensions();
			String signature = getTypeSignature(typeBinding.getElementType());
		push(new ArrayInitializerInstruction(signature, node.expressions().size(), dimension, fCounter));

			push(new ArrayInitializerInstruction(signature, node.expressions()
					.size(), dimension, fCounter));
		}
		return true;
	}


		if (!isActive()) {
			return false;
		}
		ITypeBinding arrayTypeBinding= resolveTypeBinding(node);
		if (arrayTypeBinding != null) {
			int dimension = arrayTypeBinding.getDimensions();
			String signature = getTypeSignature(arrayTypeBinding
					.getElementType());

			push(new PushArrayType(signature, dimension, fCounter));
		}
		return false;
	}


		}
		setHasError(true);
		addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Assert_statement_cannot_be_used_in_an_evaluation_expression_3); 
		return false;
	}

	/**

			char2 = opToken.charAt(2);
		}

		ITypeBinding rightBinding = resolveTypeBinding(rightHandSide);
		if (rightBinding == null) {
			return false;
		}
		ITypeBinding leftBinding = resolveTypeBinding(leftHandSide);
		if (leftBinding == null) {
			return false;
		}
		if (variableTypeId == Instruction.T_Object) {
			// If the variable is an object, the value may need to be boxed for
			// the simple assignment.

			if (char0 == '=') {
				
				boolean storeRequired= false;
				if (rightBinding.isPrimitive()) {
					boxing(leftBinding, rightBinding);
					storeRequired= true;
				}
				rightHandSide.accept(this);

				boolean unrecognized = false;
				
				
				boxing(leftBinding, rightBinding);
				
				switch (char0) {
					case '=': // equal

					return false;
				}

				unBoxing(leftBinding);
				push(new Dup());
				storeInstruction(); // dupe
				storeInstruction(); // un-boxing
			
				boolean storeRequired= unBoxing(rightBinding);
				rightHandSide.accept(this);
				if (storeRequired) {
					storeInstruction(); // un-boxing

			}
			
			leftHandSide.accept(this);
			boolean storeRequired= unBoxing(rightBinding);
			rightHandSide.accept(this);
			if (storeRequired) {
				storeInstruction();


		Type type= node.getType();
		int typeId= getTypeId(type);
		ITypeBinding typeBinding= type.resolveBinding();

		String baseTypeSignature;
		int dimension= typeBinding.getDimensions();

		if (typeBinding.isArray()) {
			typeBinding= typeBinding.getElementType();
		}
		
		ITypeBinding typeBinding= resolveTypeBinding(type);

		if (typeBinding != null) {

			String baseTypeSignature;
			int dimension = typeBinding.getDimensions();

			if (typeBinding.isArray()) {
				typeBinding = typeBinding.getElementType();
			}
			baseTypeSignature = getTypeName(typeBinding);
			push(new Cast(typeId, baseTypeSignature, dimension, fCounter));
			node.getExpression().accept(this);
		}

		return false;
	}

		}
		setHasError(true);
		addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Catch_clause_cannot_be_used_in_an_evaluation_expression_6); 
		return false;
	}

	/**

		}

		IMethodBinding methodBinding= node.resolveConstructorBinding();
		if (methodBinding == null) {
			setHasError(true);
			addErrorMessage(MessageFormat.format(
					EvaluationEngineMessages.ASTInstructionCompiler_1,
					new String[] { node.toString() }));
			return false;
		}
		ITypeBinding typeBinding= methodBinding.getDeclaringClass();
		ITypeBinding enclosingTypeBinding= typeBinding.getDeclaringClass();

		boolean isInstanceMemberType= typeBinding.isMember() && ! Modifier.isStatic(typeBinding.getModifiers());




		if (hasErrors()) {
			return false;
		}

		int argCount= methodBinding.getParameterTypes().length;
		ITypeBinding enclosingTypeBinding= null;
		String enclosingTypeSignature= null;
		if (isInstanceMemberType) {
			enclosingTypeBinding = typeBinding.getDeclaringClass();
			if (enclosingTypeBinding == null) {
				setHasError(true);
				addErrorMessage(MessageFormat.format(
						EvaluationEngineMessages.ASTInstructionCompiler_2,
						new String[] { typeBinding.getQualifiedName() }));
				return false;
			}
			enclosingTypeSignature= getTypeSignature(enclosingTypeBinding);
			argCount++;
		}

				if (Modifier.isStatic(((MethodDeclaration)parent).getModifiers())) {
					setHasError(true);
					addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Must_explicitly_qualify_the_allocation_with_an_instance_of_the_enclosing_type_33); 
					return false;
				}

				push(new PushThis(getEnclosingLevel(node, enclosingTypeBinding)));

		push(new NoOp(fCounter));
		
		
		ITypeBinding typeBinding = resolveTypeBinding(node.getExpression());
		if (typeBinding == null) {
			return false;
		}
		Type paramType = node.getParameter().getType();
		ITypeBinding paramBinding = resolveTypeBinding(paramType);
		if (paramBinding == null) {
			return false;
		}
		String typeSignature= getTypeSignature(paramBinding);
		int paramTypeId= getTypeId(paramType);
		boolean isParamPrimitiveType= paramTypeId != Instruction.T_Object && paramTypeId != Instruction.T_String;

		Expression rightOperand= node.getRightOperand();
		int leftTypeId;
		int rightTypeId;
		ITypeBinding leftBinding = resolveTypeBinding(leftOperand);
					if (leftBinding == null) {
			return false;
		}
		ITypeBinding rightBinding = resolveTypeBinding(rightOperand);
		if (rightBinding == null) {
			return false;
		}
		// == case, do not un-box, if the two operands are objects
		boolean unbox= char0 != '=' || leftBinding.isPrimitive() || rightBinding.isPrimitive();
		if (unbox) {
			leftTypeId= getUnBoxedTypeId(leftOperand);
			rightTypeId = getUnBoxedTypeId(rightOperand);

		}

		if (hasErrors()) {
			return false;
		}

		iterator = extendedOperands.iterator();

			ConditionalJump[] conditionalJumps= new ConditionalJump[operatorNumber];
			int[] conditionalJumpAddresses = new int[operatorNumber];

			boolean storeRequired= unBoxing(leftBinding);
			leftOperand.accept(this);
			if (storeRequired) {
				storeInstruction();

			push(conditionalJump);
			storeInstruction();

			storeRequired= unBoxing(rightBinding);
			rightOperand.accept(this);
			if (storeRequired) {
				storeInstruction();

				push(conditionalJump);
				storeInstruction();
				Expression operand= (Expression) iterator.next();
				ITypeBinding typeBinding = resolveTypeBinding(operand);
				if (typeBinding == null) {
					return false;
				}
				storeRequired = unBoxing(typeBinding);
				operand.accept(this);
				if (storeRequired) {
					storeInstruction();


			boolean storeRequired= false;
			if (unbox) {
				storeRequired= unBoxing(leftBinding);
			}
			leftOperand.accept(this);
			if (storeRequired) {
				storeInstruction();
			}
			if (unbox) {
				storeRequired= unBoxing(rightBinding);
			}
			rightOperand.accept(this);
			if (storeRequired) {

			for (int i= 1; i < operatorNumber; i ++) {
				Expression operand= (Expression) iterator.next();
				if (unbox) {
					ITypeBinding typeBinding = resolveTypeBinding(operand);
					if (typeBinding == null) {
						return false;
					}
					storeRequired= unBoxing(typeBinding);
				}
				operand.accept(this);
				if (storeRequired) {

		}
		
		if (hasErrors()) {
			return false;
		}

		if (containsALocalType(methodBinding)) {
			setHasError(true);
			addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Method_which_contains_a_local_type_as_parameter_cannot_be_used_in_an_evaluation_expression_32);
			return false;

		if (hasErrors()) {
			return true;
		}

		ITypeBinding[] parameterTypes = methodBinding.getParameterTypes();


		List arguments = node.arguments();
		int argCount = arguments.size();
		ITypeBinding lastArgBinding = null;
		if (methodBinding.isVarargs()) {
			Expression lastArg = (Expression) arguments.get(argCount - 1);
			lastArgBinding = resolveTypeBinding(lastArg);
			if (lastArgBinding == null) {
				return false;
			}
		}
		if (methodBinding.isVarargs()
				&& !(paramCount == argCount && parameterTypes[paramCount - 1]
						.getDimensions() == lastArgBinding.getDimensions())) {
			// if this method is a varargs, and if the method is invoked using
			// the varargs syntax
			// (multiple arguments) and not an array
			Iterator iterator = arguments.iterator();
			// process the first arguments (no part of the variable argument)
			for (int i= 0; i < paramCount - 1; i++) {
				Expression argument= (Expression)iterator.next();

		if (!isActive()) {
			return false;
		}
		ITypeBinding typeBinding  = resolveTypeBinding(node);
		if (typeBinding != null) {
			push(new PushType(getTypeName(typeBinding)));
		}
		return false;
	}


				default:
					setHasError(true);
					addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_unrecognized_postfix_operator____15 + opToken); 
					return false;
			}
			push(new Value(fCounter));
			push(new Dup());

			storeInstruction(); // value
			push(new DupX1());
			storeInstruction(); // dup_x1
			ITypeBinding typeBinding = resolveTypeBinding(operand);
			if (typeBinding == null) {
				return false;
			}
			unBoxing(typeBinding);
			storeInstruction(); // un-boxing
			push(new PushInt(1));
			storeInstruction(); // push 1
			storeInstruction(); // operator
			boxing(typeBinding, null);
			storeInstruction(); // boxing
			storeInstruction(); // assignment
			push(new Pop(assignmentInstruction.getSize() + 1));

			default:
				setHasError(true);
				addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_unrecognized_postfix_operator____15 + opToken); 
				return false;
		}

		return true;

			
			int expressionUnBoxedTypeId= getUnBoxedTypeId(operand);
			
			ITypeBinding typeBinding = resolveTypeBinding(operand);
			if (typeBinding == null) {
				return false;
			}
			
			if (char1 == '\0') {
				switch (char0) {
					case '+': // unary plus

					default:
						setHasError(true);
						addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_unrecognized_prefix_operator____16 + opToken); 
						return false;
				}
	
				unBoxing(typeBinding);
				operand.accept(this);
				storeInstruction(); // un-boxing
				

				
				operand.accept(this);
				
				boxing(typeBinding, null);
				
				switch (char1) {
					case '+':

					default:
						setHasError(true);
						addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_unrecognized_prefix_operator____16 + opToken); 
						unBoxing(typeBinding);
				}
				
				unBoxing(typeBinding);
				push(new Dup());
				storeInstruction(); // dupe
				storeInstruction(); // un-boxing


		if (unrecognized) {
			setHasError(true);
			addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_unrecognized_prefix_operator____16 + opToken);
			return false;
		}

		return true;

		if (!isActive()) {
			return false;
		}
		ITypeBinding typeBinding  = resolveTypeBinding(node);
		if (typeBinding != null) {
			push(new PushPrimitiveType(getTypeName(typeBinding)));
		}
		return false;
	}


			return true;
		}

		IBinding binding = resolveBinding(node);
		if (binding == null) {
			return false;
		}
		switch (binding.getKind()) {
			case IBinding.TYPE:
				node.getName().accept(this);
				break;
			case IBinding.VARIABLE:
				SimpleName fieldName= node.getName();
				IVariableBinding fieldBinding = (IVariableBinding) resolveBinding(fieldName);
				if (fieldBinding == null) {
					return false;
				}
				ITypeBinding declaringTypeBinding= fieldBinding.getDeclaringClass();
				String fieldId = fieldName.getIdentifier();


		if (!isActive()) {
			return false;
		}
		ITypeBinding typeBinding  = resolveTypeBinding(node);
		if (typeBinding != null) {
			push(new PushType(getTypeName(typeBinding)));
		}
		return false;
	}


			return true;
		}

		IBinding binding = resolveBinding(node);

		String variableId = node.getIdentifier();
		if (binding == null) {
			setHasError(true);
			addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_binding_null_for__17 + variableId); 
			return true;
		}
		
		String variableId = node.getIdentifier();

		switch (binding.getKind()) {
			case IBinding.TYPE:

			return false;
		}

		ITypeBinding typeBinding  = resolveTypeBinding(node);
		if (typeBinding != null) {
			push(new PushType(getTypeName(typeBinding)));
		}
		return false;
	}


		if (!isActive()) {
			return false;
		}
		ITypeBinding typeBinding = resolveTypeBinding(node.getType());
		if (typeBinding != null) {
			int typeDimension = typeBinding.getDimensions();
			if (typeDimension != 0) {
				typeBinding = typeBinding.getElementType();
			}
			Expression initializer = node.getInitializer();
			push(new LocalVariableCreation(node.getName().getIdentifier(),
					getTypeSignature(typeBinding), typeDimension, typeBinding
							.isPrimitive(), initializer != null, fCounter));
			if (initializer != null) {
				initializer.accept(this);
			}
		}
		return false;
	}

		}

		SimpleName fieldName= node.getName();
		IVariableBinding fieldBinding = (IVariableBinding) resolveBinding(fieldName);
		if (fieldBinding == null) {
			return false;
		}
		ITypeBinding declaringTypeBinding= fieldBinding.getDeclaringClass();
		String fieldId = fieldName.getIdentifier();


			int superLevel= 1;
			int enclosingLevel= 0;
			if (qualifier != null) {
				ITypeBinding typeBinding = resolveTypeBinding(qualifier);
				if (typeBinding == null) {
					return false;
				}
				superLevel = getSuperLevel(typeBinding, declaringTypeBinding);
				ITypeBinding binding = (ITypeBinding) resolveBinding(qualifier);
				if (binding == null) {
					return false;
				}
				enclosingLevel = getEnclosingLevel(node, binding);
			}
			push(new PushFieldVariable(fieldId, superLevel, fCounter));
			push(new PushThis(enclosingLevel));

			return false;
		}

		IMethodBinding methodBinding = (IMethodBinding) resolveBinding(node
				.getName());
		if (methodBinding == null) {
			return false;
		}

		if (containsALocalType(methodBinding)) {
			setHasError(true);
			addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Method_which_contains_a_local_type_as_parameter_cannot_be_used_in_an_evaluation_expression_32);
			return false;

		if (hasErrors()) {
			return true;
		}

		ITypeBinding[] parameterTypes = methodBinding.getParameterTypes();

			push(new SendMessage(selector, signature, paramCount, getTypeSignature(methodBinding.getDeclaringClass()), fCounter));
			int enclosingLevel= 0;
			if (qualifier != null) {
				ITypeBinding typeBinding = (ITypeBinding) resolveBinding(qualifier);
				if (typeBinding == null) {
					return false;
				}
				enclosingLevel= getEnclosingLevel(node, typeBinding);
			}
			push(new PushThis(enclosingLevel));
			storeInstruction();


		List arguments = node.arguments();
		int argCount = arguments.size();
		
		ITypeBinding lastArgBinding = null;
		
		if (methodBinding.isVarargs()) {
			lastArgBinding = resolveTypeBinding((Expression) arguments
					.get(argCount - 1));
			if (lastArgBinding == null) {
				return false;
			}
		}
		if (methodBinding.isVarargs()
				&& !(paramCount == argCount && parameterTypes[paramCount - 1]
						.getDimensions() == lastArgBinding.getDimensions())) {
			// if this method is a varargs, and if the method is invoked using the varargs syntax
			// (multiple arguments) and not an array
			Iterator iterator= arguments.iterator();

		Name qualifier= node.getQualifier();
		int enclosingLevel= 0;
		if (qualifier != null) {
			ITypeBinding binding = (ITypeBinding) resolveBinding(qualifier);
			if (binding == null) {
				return false;
			}
			enclosingLevel = getEnclosingLevel(node, binding);
		}
		push(new PushThis(enclosingLevel));


		}
		setHasError(true);
		addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Try_statement_cannot_be_used_in_an_evaluation_expression_23); 
		return false;
	}

	/**

		ASTNode parent= node.getParent();
		switch (parent.getNodeType()) {
			case ASTNode.VARIABLE_DECLARATION_EXPRESSION:
				varTypeBinding= resolveTypeBinding(((VariableDeclarationExpression)parent).getType());
				break;
			case ASTNode.VARIABLE_DECLARATION_STATEMENT:
				varTypeBinding= resolveTypeBinding(((VariableDeclarationStatement)parent).getType());
				break;
			default:
				setHasError(true);
				addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Error_in_type_declaration_statement); 
				return false;
		}
		if (varTypeBinding == null) {
			return false;
		}
		int typeDimension= varTypeBinding.getDimensions();
		ITypeBinding elementBinding = varTypeBinding;
		if (typeDimension != 0) {


	private int getTypeId(Expression expression) {
		ITypeBinding typeBinding = expression.resolveTypeBinding();
		if (typeBinding == null) {
			return Instruction.T_undefined;
		}
		String typeName = typeBinding.getQualifiedName();
		if (typeBinding.isPrimitive()) {
			return getPrimitiveTypeId(typeName);


	private int getUnBoxedTypeId(Expression expression) {
		ITypeBinding typeBinding = expression.resolveTypeBinding();
		if (typeBinding == null) {
			return Instruction.T_undefined;
		}
		String typeName = typeBinding.getQualifiedName();
		if (typeBinding.isPrimitive()) {
			return getPrimitiveTypeId(typeName);

		}
		return Instruction.T_undefined;
	}
	
			
			/**
			 * Resolves and returns the type binding from the given expression reporting an error
			 * if the binding is <code>null</code>.
			 *  
			 * @param expression expression to resolve type binding for
			 * @return type binding or <code>null</code> if not available
			 */
			private ITypeBinding resolveTypeBinding(Expression expression) {
				ITypeBinding typeBinding = expression.resolveTypeBinding();
				if (typeBinding == null) {
					setHasError(true);
					addErrorMessage(MessageFormat.format(EvaluationEngineMessages.ASTInstructionCompiler_3, new String[]{expression.toString()}));
				}
				return typeBinding;
			}
			
			/**
			 * Resolves and returns the type binding for the give type reporting an error
			 * if the binding is <code>null</code>.
			 * 
			 * @param type type to resolve binding for
			 * @return type binding or <code>null</code> if not available
			 */
			private ITypeBinding resolveTypeBinding(Type type) {
				ITypeBinding typeBinding = type.resolveBinding();
				if (typeBinding == null) {
					setHasError(true);
					addErrorMessage(MessageFormat.format(EvaluationEngineMessages.ASTInstructionCompiler_3, new String[]{type.toString()}));
				}
				return typeBinding;
			}
			
			/**
			 * Resolves and returns the binding for the given name reporting an error
			 * if the binding is <code>null</code>.
			 * 
			 * @param name name to resolve binding for
			 * @return binding or <code>null</code> if not available
			 */
			private IBinding resolveBinding(Name name) {
				IBinding binding = name.resolveBinding();
				if (binding == null) {
					setHasError(true);
					addErrorMessage(MessageFormat.format(EvaluationEngineMessages.ASTInstructionCompiler_5, new String[]{name.getFullyQualifiedName()}));
				}
				return binding;
			}	
			
			/**
			 * Resolves and returns the type binding for the given name reporting an error
			 * if the binding is <code>null</code>.
			 * 
			 * @param name name to resolve type binding for
			 * @return type binding or <code>null</code> if not available
			 */
			private ITypeBinding resolveTypeBinding(Name name) {
				ITypeBinding typeBinding = name.resolveTypeBinding();
				if (typeBinding == null) {
					setHasError(true);
					addErrorMessage(MessageFormat.format(EvaluationEngineMessages.ASTInstructionCompiler_3, new String[]{name.getFullyQualifiedName()}));
				}
				return typeBinding;
			}
}

Return to bug 277574

Lines 1-5 Link Here

(-)eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.properties (-2 / +5 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2000, 2007 IBM Corporation and others.	2	# Copyright (c) 2000, 2010 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials	3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0	4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at	5	# which accompanies this distribution, and is available at
Lines 22-28 Link Here
22		22
23	ASTInstructionCompiler_unrecognized_postfix_operator____15=unrecognized postfix operator :	23	ASTInstructionCompiler_unrecognized_postfix_operator____15=unrecognized postfix operator :
24	ASTInstructionCompiler_unrecognized_prefix_operator____16=unrecognized prefix operator :	24	ASTInstructionCompiler_unrecognized_prefix_operator____16=unrecognized prefix operator :
25	ASTInstructionCompiler_binding_null_for__17=binding == null for
26		25
27	ASTInstructionCompiler_super_constructor_invocation_cannot_be_used_in_an_evaluation_expression_19=super constructor invocation cannot be used in an evaluation expression	26	ASTInstructionCompiler_super_constructor_invocation_cannot_be_used_in_an_evaluation_expression_19=super constructor invocation cannot be used in an evaluation expression
28	ASTInstructionCompiler_Try_statement_cannot_be_used_in_an_evaluation_expression_23=Try statement cannot be used in an evaluation expression	27	ASTInstructionCompiler_Try_statement_cannot_be_used_in_an_evaluation_expression_23=Try statement cannot be used in an evaluation expression
Lines 43-50 Link Here
43	ASTEvaluationEngine_An_unknown_error_occurred_during_evaluation=An unknown error occurred during evaluation	42	ASTEvaluationEngine_An_unknown_error_occurred_during_evaluation=An unknown error occurred during evaluation
44	ASTEvaluationEngine_Cannot_perform_nested_evaluations=Cannot perform nested evaluations.	43	ASTEvaluationEngine_Cannot_perform_nested_evaluations=Cannot perform nested evaluations.
45		44
		45	ASTInstructionCompiler_3=Unable to resolve type binding for: {0}
46	ASTInstructionCompiler_36=Local type field access cannot be used in an evaluation expression	46	ASTInstructionCompiler_36=Local type field access cannot be used in an evaluation expression
47	ASTInstructionCompiler_0=Enum declaration cannot be used in an evaluation expression	47	ASTInstructionCompiler_0=Enum declaration cannot be used in an evaluation expression
		48	ASTInstructionCompiler_1=Unable to resolve type binding of constructor: {0}
		49	ASTInstructionCompiler_2=Unable to resolve type binding of declaring type of: {0}
		50	ASTInstructionCompiler_5=Unable to resolve binding for: {0}
48	ASTEvaluationEngine_0=Unable to evaluate expressions in the context of an interface	51	ASTEvaluationEngine_0=Unable to evaluate expressions in the context of an interface
49	ASTEvaluationEngine_1=Unable to retrieve type for java.lang.Object	52	ASTEvaluationEngine_1=Unable to retrieve type for java.lang.Object
50	ArrayRuntimeContext_0=Unable to retrieve type for java.lang.Object	53	ArrayRuntimeContext_0=Unable to retrieve type for java.lang.Object