Attachment #63595 for bug #146556




	public final static int Bit2 = 0x2; 						// return type (operator) | name reference kind (name ref) | has local type (type, method, field decl)
	public final static int Bit3 = 0x4; 						// return type (operator) | name reference kind (name ref) | implicit this (this ref)
	public final static int Bit4 = 0x8; 						// return type (operator) | first assignment to local (name ref,local decl) | undocumented empty block (block, type and method decl)
	public final static int Bit5 = 0x10; 						// value for return (expression) | has all method bodies (unit) | supertype ref (type ref) | resolved (field decl)
	public final static int Bit6 = 0x20; 						// depth (name ref, msg) | ignore need cast check (cast expression)
	public final static int Bit7 = 0x40; 						// depth (name ref, msg) | operator (operator) | need runtime checkcast (cast expression) | label used (labelStatement)
	public final static int Bit8 = 0x80; 						// depth (name ref, msg) | operator (operator) | unsafe cast (cast expression)

	public final static int Bit11 = 0x400; 					// depth (name ref, msg) | operator (operator) | is member type (type decl)
	public final static int Bit12 = 0x800; 					// depth (name ref, msg) | operator (operator) | has abstract methods (type decl)
	public final static int Bit13 = 0x1000; 				// depth (name ref, msg) | is secondary type (type decl)
	public final static int Bit14 = 0x2000; 				// strictly assigned (reference lhs) | discard enclosing instance (explicit constr call)
	public final static int Bit15 = 0x4000; 				// is unnecessary cast (expression) | is varargs (type ref) | isSubRoutineEscaping (try statement)
	public final static int Bit16 = 0x8000; 				// in javadoc comment (name ref, type ref, msg)
	public final static int Bit17 = 0x10000; 				// compound assigned (reference lhs)


	// for type, method and field declarations
	public static final int HasLocalType = Bit2; // cannot conflict with AddAssertionMASK
	public static final int HasBeenResolved = Bit5; // field decl only (to handle forward references)

	// for expression
	public static final int ParenthesizedSHIFT = 21; // Bit22 -> Bit29

	public static final int IsStrictlyAssigned = Bit14; // set only for true assignments, as opposed to compound ones
	public static final int IsCompoundAssigned = Bit17; // set only for compound assignments, as opposed to other ones

	// for explicit constructor call
	public static final int DiscardEnclosingInstance = Bit14; // used for codegen
	
	// for empty statement
	public static final int IsUsefulEmptyStatement = Bit1;





public class FieldDeclaration extends AbstractVariableDeclaration {
	
	public FieldBinding binding;
	boolean hasBeenResolved = false; // TODO (philippe) should use a tagBit instead
	public Javadoc javadoc;

	//allows to retrieve both the "type" part of the declaration (part1)

	public int endPart1Position;
	public int endPart2Position;

public FieldDeclaration() {
	// for subtypes or conversion
}

public FieldDeclaration(	char[] name, int sourceStart, int sourceEnd) {
	this.name = name;
	//due to some declaration like 
	// int x, y = 3, z , x ;
	//the sourceStart and the sourceEnd is ONLY on  the name
	this.sourceStart = sourceStart;
	this.sourceEnd = sourceEnd;
}
		// int x, y = 3, z , x ;
		//the sourceStart and the sourceEnd is ONLY on  the name
		this.sourceStart = sourceStart;
		this.sourceEnd = sourceEnd;
	}

public FlowInfo analyseCode(MethodScope initializationScope, FlowContext flowContext, FlowInfo flowInfo) {
	if (this.binding != null && !this.binding.isUsed()) {
		if (this.binding.isPrivate() || (this.binding.declaringClass != null && this.binding.declaringClass.isLocalType())) {
			if (!initializationScope.referenceCompilationUnit().compilationResult.hasSyntaxError) {
				initializationScope.problemReporter().unusedPrivateField(this);
		if (this.binding != null && !this.binding.isUsed()) {
			if (this.binding.isPrivate() || (this.binding.declaringClass != null && this.binding.declaringClass.isLocalType())) {
				if (!initializationScope.referenceCompilationUnit().compilationResult.hasSyntaxError) {
					initializationScope.problemReporter().unusedPrivateField(this);
				}
			}
		}
		// cannot define static non-constant field inside nested class
		if (this.binding != null
				&& this.binding.isValidBinding()
				&& this.binding.isStatic()
				&& this.binding.constant() == Constant.NotAConstant
				&& this.binding.declaringClass.isNestedType()
				&& !this.binding.declaringClass.isStatic()) {
			initializationScope.problemReporter().unexpectedStaticModifierForField(
				(SourceTypeBinding) this.binding.declaringClass,
				this);
		}

		if (this.initialization != null) {
			flowInfo =
				this.initialization
					.analyseCode(initializationScope, flowContext, flowInfo)
					.unconditionalInits();
			flowInfo.markAsDefinitelyAssigned(this.binding);
		}
		return flowInfo;
	}
	// cannot define static non-constant field inside nested class
	if (this.binding != null
			&& this.binding.isValidBinding()
			&& this.binding.isStatic()
			&& this.binding.constant() == Constant.NotAConstant
			&& this.binding.declaringClass.isNestedType()
			&& !this.binding.declaringClass.isStatic()) {
		initializationScope.problemReporter().unexpectedStaticModifierForField(
			(SourceTypeBinding) this.binding.declaringClass,
			this);
		if ((this.bits & IsReachable) == 0) {
			return;
		}
		// do not generate initialization code if final and static (constant is then
		// recorded inside the field itself).
		int pc = codeStream.position;
		boolean isStatic;
		if (this.initialization != null
			&& !((isStatic = this.binding.isStatic()) && this.binding.constant() != Constant.NotAConstant)) {
			// non-static field, need receiver
			if (!isStatic)
				codeStream.aload_0();
			// generate initialization value
			this.initialization.generateCode(currentScope, codeStream, true);
			// store into field
			if (isStatic) {
				codeStream.putstatic(this.binding);
			} else {
				codeStream.putfield(this.binding);
			}
		}
		codeStream.recordPositionsFrom(pc, this.sourceStart);
	}

	if (this.initialization != null) {
		flowInfo =
			this.initialization
				.analyseCode(initializationScope, flowContext, flowInfo)
				.unconditionalInits();
		flowInfo.markAsDefinitelyAssigned(this.binding);
	}
	return flowInfo;
}

/**
 * Code generation for a field declaration:
 *	   standard assignment to a field 
 *
 * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
 */
public void generateCode(BlockScope currentScope, CodeStream codeStream) {
	if ((this.bits & IsReachable) == 0) {
		return;
	}
	// do not generate initialization code if final and static (constant is then
	// recorded inside the field itself).
	int pc = codeStream.position;
	boolean isStatic;
	if (this.initialization != null
		&& !((isStatic = this.binding.isStatic()) && this.binding.constant() != Constant.NotAConstant)) {
		// non-static field, need receiver
		if (!isStatic)
			codeStream.aload_0();
		// generate initialization value
		this.initialization.generateCode(currentScope, codeStream, true);
		// store into field
		if (isStatic) {
			codeStream.putstatic(this.binding);
		} else {
			codeStream.putfield(this.binding);
		}
		return super.printStatement(indent, output);
	}
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

/**
 * @see org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration#getKind()
 */
public int getKind() {
	return this.type == null ? ENUM_CONSTANT : FIELD;
}

public boolean isStatic() {
	if (this.binding != null)
		return this.binding.isStatic();
	return (this.modifiers & ClassFileConstants.AccStatic) != 0;
}

public StringBuffer printStatement(int indent, StringBuffer output) {
	if (this.javadoc != null) {
		this.javadoc.print(indent, output);
	}
	return super.printStatement(indent, output);
}

public void resolve(MethodScope initializationScope) {
	// the two <constant = Constant.NotAConstant> could be regrouped into
	// a single line but it is clearer to have two lines while the reason of their
	// existence is not at all the same. See comment for the second one.

	//--------------------------------------------------------
	if ((this.bits & ASTNode.HasBeenResolved) != 0) return;
	if (this.binding == null || !this.binding.isValidBinding()) return;
	
	this.bits |= ASTNode.HasBeenResolved;

	// check if field is hiding some variable - issue is that field binding already got inserted in scope
	// thus must lookup separately in super type and outer context
	ClassScope classScope = initializationScope.enclosingClassScope();
	
	if (classScope != null) {
		checkHiding: {
			SourceTypeBinding declaringType = classScope.enclosingSourceType();
			checkHidingSuperField: {
				if (declaringType.superclass == null) break checkHidingSuperField;
				Binding existingVariable = classScope.findField(declaringType.superclass, this.name, this,  false /*do not resolve hidden field*/);
				if (existingVariable == null) break checkHidingSuperField; // keep checking outer scenario
				if (!existingVariable.isValidBinding())  break checkHidingSuperField; // keep checking outer scenario
				if (existingVariable instanceof FieldBinding) {
					FieldBinding existingField = (FieldBinding) existingVariable;
					if (existingField.original() == this.binding) break checkHidingSuperField; // keep checking outer scenario
						}
						// collision with supertype field
						initializationScope.problemReporter().fieldHiding(this, existingVariable);
						break checkHiding; // already found a matching field
					}					
					// only corner case is: lookup of outer field through static declaringType, which isn't detected by #getBinding as lookup starts
					// from outer scope. Subsequent static contexts are detected for free.
					Scope outerScope = classScope.parent;
					if (outerScope.kind == Scope.COMPILATION_UNIT_SCOPE) break checkHiding;
					Binding existingVariable = outerScope.getBinding(this.name, Binding.VARIABLE, this, false /*do not resolve hidden field*/);
					if (existingVariable == null) break checkHiding;
					if (!existingVariable.isValidBinding()) break checkHiding;
					if (existingVariable == this.binding) break checkHiding;
					if (existingVariable instanceof FieldBinding) {
						FieldBinding existingField = (FieldBinding) existingVariable;
						if (existingField.original() == this.binding) break checkHiding;
						if (!existingField.isStatic() && declaringType.isStatic()) break checkHiding;
					}
					// collision with outer field or local variable
					initializationScope.problemReporter().fieldHiding(this, existingVariable);
				}
				// collision with supertype field
				initializationScope.problemReporter().fieldHiding(this, existingVariable);
				break checkHiding; // already found a matching field
			}					
			// only corner case is: lookup of outer field through static declaringType, which isn't detected by #getBinding as lookup starts
			// from outer scope. Subsequent static contexts are detected for free.
			Scope outerScope = classScope.parent;
			if (outerScope.kind == Scope.COMPILATION_UNIT_SCOPE) break checkHiding;
			Binding existingVariable = outerScope.getBinding(this.name, Binding.VARIABLE, this, false /*do not resolve hidden field*/);
			if (existingVariable == null) break checkHiding;
			if (!existingVariable.isValidBinding()) break checkHiding;
			if (existingVariable == this.binding) break checkHiding;
			if (existingVariable instanceof FieldBinding) {
				FieldBinding existingField = (FieldBinding) existingVariable;
				if (existingField.original() == this.binding) break checkHiding;
				if (!existingField.isStatic() && declaringType.isStatic()) break checkHiding;
			}
			// collision with outer field or local variable
			initializationScope.problemReporter().fieldHiding(this, existingVariable);
		}
	}
	
	if (this.type != null ) { // enum constants have no declared type
		this.type.resolvedType = this.binding.type; // update binding for type reference
	}

	FieldBinding previousField = initializationScope.initializedField;
	int previousFieldID = initializationScope.lastVisibleFieldID;
	try {
		initializationScope.initializedField = this.binding;
		initializationScope.lastVisibleFieldID = this.binding.id;

		resolveAnnotations(initializationScope, this.annotations, this.binding);
		// check @Deprecated annotation presence
		if ((this.binding.getAnnotationTagBits() & TagBits.AnnotationDeprecated) == 0
				&& (this.binding.modifiers & ClassFileConstants.AccDeprecated) != 0
				&& initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
			initializationScope.problemReporter().missingDeprecatedAnnotationForField(this);
		}						
		// the resolution of the initialization hasn't been done
		if (this.initialization == null) {
			this.binding.setConstant(Constant.NotAConstant);
		} else {
			// break dead-lock cycles by forcing constant to NotAConstant
			this.binding.setConstant(Constant.NotAConstant);
			
			TypeBinding fieldType = this.binding.type;
			TypeBinding initializationType;
			this.initialization.setExpectedType(fieldType); // needed in case of generic method invocation
			if (this.initialization instanceof ArrayInitializer) {

				if ((initializationType = this.initialization.resolveTypeExpecting(initializationScope, fieldType)) != null) {
					((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationType;
					this.initialization.computeConversion(initializationScope, fieldType, initializationType);
				}
			} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {

				if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
					initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
				if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
						|| (fieldType.isBaseType() && BaseTypeBinding.isWidening(fieldType.id, initializationType.id))
						|| initializationType.isCompatibleWith(fieldType)) {
					this.initialization.computeConversion(initializationScope, fieldType, initializationType);
					if (initializationType.needsUncheckedConversion(fieldType)) {
						    initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);
				if ((this.binding.getAnnotationTagBits() & TagBits.AnnotationDeprecated) == 0
						&& (this.binding.modifiers & ClassFileConstants.AccDeprecated) != 0
						&& initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
					initializationScope.problemReporter().missingDeprecatedAnnotationForField(this);
				}						
				// the resolution of the initialization hasn't been done
				if (this.initialization == null) {
					this.binding.setConstant(Constant.NotAConstant);
				} else {
					// break dead-lock cycles by forcing constant to NotAConstant
					this.binding.setConstant(Constant.NotAConstant);
					
					TypeBinding fieldType = this.binding.type;
					TypeBinding initializationType;
					this.initialization.setExpectedType(fieldType); // needed in case of generic method invocation
					if (this.initialization instanceof ArrayInitializer) {

						if ((initializationType = this.initialization.resolveTypeExpecting(initializationScope, fieldType)) != null) {
							((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationType;
							this.initialization.computeConversion(initializationScope, fieldType, initializationType);
						}
					} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {

						if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
							initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
						if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
								|| (fieldType.isBaseType() && BaseTypeBinding.isWidening(fieldType.id, initializationType.id))
								|| initializationType.isCompatibleWith(fieldType)) {
							this.initialization.computeConversion(initializationScope, fieldType, initializationType);
							if (initializationType.needsUncheckedConversion(fieldType)) {
								    initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);
							}
							if (this.initialization instanceof CastExpression 
									&& (this.initialization.bits & ASTNode.UnnecessaryCast) == 0) {
								CastExpression.checkNeedForAssignedCast(initializationScope, fieldType, (CastExpression) this.initialization);
							}								
						} else if (initializationScope.isBoxingCompatibleWith(initializationType, fieldType) 
											|| (initializationType.isBaseType()  // narrowing then boxing ?
													&& initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
													&& !fieldType.isBaseType()
													&& initialization.isConstantValueOfTypeAssignableToType(initializationType, initializationScope.environment().computeBoxingType(fieldType)))) {
							this.initialization.computeConversion(initializationScope, fieldType, initializationType);
							if (this.initialization instanceof CastExpression 
									&& (this.initialization.bits & ASTNode.UnnecessaryCast) == 0) {
								CastExpression.checkNeedForAssignedCast(initializationScope, fieldType, (CastExpression) this.initialization);
							}							
						} else {
							initializationScope.problemReporter().typeMismatchError(initializationType, fieldType, this);
						}
						if (this.binding.isFinal()){ // cast from constant actual type to variable type
							this.binding.setConstant(this.initialization.constant.castTo((this.binding.type.id << 4) + this.initialization.constant.typeID()));
						}
					} else {
						this.binding.setConstant(Constant.NotAConstant);
					}
					if (this.initialization instanceof CastExpression 
							&& (this.initialization.bits & ASTNode.UnnecessaryCast) == 0) {
						CastExpression.checkNeedForAssignedCast(initializationScope, fieldType, (CastExpression) this.initialization);
					}								
				} else if (initializationScope.isBoxingCompatibleWith(initializationType, fieldType) 
									|| (initializationType.isBaseType()  // narrowing then boxing ?
											&& initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
											&& !fieldType.isBaseType()
											&& initialization.isConstantValueOfTypeAssignableToType(initializationType, initializationScope.environment().computeBoxingType(fieldType)))) {
					this.initialization.computeConversion(initializationScope, fieldType, initializationType);
					if (this.initialization instanceof CastExpression 
							&& (this.initialization.bits & ASTNode.UnnecessaryCast) == 0) {
						CastExpression.checkNeedForAssignedCast(initializationScope, fieldType, (CastExpression) this.initialization);
					}							
				} else {
					initializationScope.problemReporter().typeMismatchError(initializationType, fieldType, this);
				}
				if (this.binding.isFinal()){ // cast from constant actual type to variable type
					this.binding.setConstant(this.initialization.constant.castTo((this.binding.type.id << 4) + this.initialization.constant.typeID()));
					/*
					if (classScope != null) {
						this.javadoc.resolve(classScope);
					}
					*/
					this.javadoc.resolve(initializationScope);
				} else if (this.binding.declaringClass != null && !this.binding.declaringClass.isLocalType()) {
					initializationScope.problemReporter().javadocMissing(this.sourceStart, this.sourceEnd, this.binding.modifiers);
				}
			} else {
				this.binding.setConstant(Constant.NotAConstant);
				initializationScope.lastVisibleFieldID = previousFieldID;
				if (this.binding.constant() == null)
					this.binding.setConstant(Constant.NotAConstant);
			}
			// check for assignment with no effect
			if (this.binding == Assignment.getDirectBinding(this.initialization)) {
				initializationScope.problemReporter().assignmentHasNoEffect(this, this.name);
			}					
		}
		// Resolve Javadoc comment if one is present
		if (this.javadoc != null) {
			/*
			if (classScope != null) {
				this.javadoc.resolve(classScope);
			}
			*/
			this.javadoc.resolve(initializationScope);
		} else if (this.binding.declaringClass != null && !this.binding.declaringClass.isLocalType()) {
			initializationScope.problemReporter().javadocMissing(this.sourceStart, this.sourceEnd, this.binding.modifiers);
		}
	} finally {
		initializationScope.initializedField = previousField;
		initializationScope.lastVisibleFieldID = previousFieldID;
		if (this.binding.constant() == null)
			this.binding.setConstant(Constant.NotAConstant);
	}
}

public void traverse(ASTVisitor visitor, MethodScope scope) {
	if (visitor.visit(this, scope)) {
		if (this.javadoc != null) {
			this.javadoc.traverse(visitor, scope);
				this.javadoc.traverse(visitor, scope);
			}
			if (this.annotations != null) {
				int annotationsLength = this.annotations.length;
				for (int i = 0; i < annotationsLength; i++)
					this.annotations[i].traverse(visitor, scope);
			}
			if (this.type != null) {
				this.type.traverse(visitor, scope);
			}
			if (this.initialization != null)
				this.initialization.traverse(visitor, scope);
		}
		if (this.annotations != null) {
			int annotationsLength = this.annotations.length;
			for (int i = 0; i < annotationsLength; i++)
				this.annotations[i].traverse(visitor, scope);
		}
		if (this.type != null) {
			this.type.traverse(visitor, scope);
		}
		if (this.initialization != null)
			this.initialization.traverse(visitor, scope);
	}
	visitor.endVisit(this, scope);
}
}




	public final static int This = 3;

	public VariableBinding[][] implicitArguments;
//	boolean discardEnclosingInstance;
	
	// TODO Remove once DOMParser is activated
	public int typeArgumentsSourceStart;

				codeStream.generateSyntheticEnclosingInstanceValues(
					currentScope,
					targetType,
					(this.bits & ASTNode.DiscardEnclosingInstance) != 0 ? null : qualification,
					this);
			}
			// generate arguments

					scope.problemReporter().unnecessaryEnclosingInstanceSpecification(
						qualification,
						receiverType);
					this.bits |= ASTNode.DiscardEnclosingInstance;
				} else {
					TypeBinding qTb = qualification.resolveTypeExpecting(scope, enclosingType);
					qualification.computeConversion(scope, qTb, qTb);




/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package org.eclipse.jdt.internal.compiler.ast;

import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.impl.*;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CaseLabel;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.impl.IntConstant;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;

public class CaseStatement extends Statement {
	
	public Expression constantExpression;
	public CaseLabel targetLabel;
	public boolean isEnumConstant;
	
public CaseStatement(Expression constantExpression, int sourceEnd, int sourceStart) {
	this.constantExpression = constantExpression;
	this.sourceEnd = sourceEnd;
	this.sourceStart = sourceStart;
}

public FlowInfo analyseCode(
	BlockScope currentScope,
	FlowContext flowContext,
	FlowInfo flowInfo) {

	if (this.constantExpression != null) {
		if (this.constantExpression.constant == Constant.NotAConstant 
				&& !this.constantExpression.resolvedType.isEnum()) {
			currentScope.problemReporter().caseExpressionMustBeConstant(this.constantExpression);
			this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);
		}
		this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);
	}
	return flowInfo;
}

public StringBuffer printStatement(int tab, StringBuffer output) {
	printIndent(tab, output);
	if (this.constantExpression == null) {
		output.append("default : "); //$NON-NLS-1$
	} else {
		output.append("case "); //$NON-NLS-1$
		this.constantExpression.printExpression(0, output).append(" : "); //$NON-NLS-1$
			constantExpression.printExpression(0, output).append(" : "); //$NON-NLS-1$
		}
		return output.append(';');
	}
	return output.append(';');
}
	 * Case code generation
	 *
	 */
	public void generateCode(BlockScope currentScope, CodeStream codeStream) {

/**
 * Case code generation
 *
 */
public void generateCode(BlockScope currentScope, CodeStream codeStream) {
	if ((this.bits & ASTNode.IsReachable) == 0) {
		return;
	}
	int pc = codeStream.position;
	this.targetLabel.place();
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

/**
 * No-op : should use resolveCase(...) instead.
 */
public void resolve(BlockScope scope) {
	// no-op : should use resolveCase(...) instead.
}

/**
 * Returns the constant intValue or ordinal for enum constants. If constant is NotAConstant, then answers Float.MIN_VALUE
 * @see org.eclipse.jdt.internal.compiler.ast.Statement#resolveCase(org.eclipse.jdt.internal.compiler.lookup.BlockScope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.ast.SwitchStatement)
 */
public Constant resolveCase(BlockScope scope, TypeBinding switchExpressionType, SwitchStatement switchStatement) {
	// switchExpressionType maybe null in error case
    scope.enclosingCase = this; // record entering in a switch case block
    
	if (this.constantExpression == null) {
		// remember the default case into the associated switch statement
		if (switchStatement.defaultCase != null)
			scope.problemReporter().duplicateDefaultCase(this);

		// on error the last default will be the selected one ...	
		switchStatement.defaultCase = this;
		return Constant.NotAConstant;
	}
	// add into the collection of cases of the associated switch statement
	switchStatement.cases[switchStatement.caseCount++] = this;
	// tag constant name with enum type for privileged access to its members
	if (switchExpressionType != null && switchExpressionType.isEnum() && (this.constantExpression instanceof SingleNameReference)) {
		((SingleNameReference) this.constantExpression).setActualReceiverType((ReferenceBinding)switchExpressionType);
	}
	TypeBinding caseType = this.constantExpression.resolveType(scope);
	if (caseType == null || switchExpressionType == null) return Constant.NotAConstant;
	if (this.constantExpression.isConstantValueOfTypeAssignableToType(caseType, switchExpressionType)
			|| caseType.isCompatibleWith(switchExpressionType)) {
		if (caseType.isEnum()) {
			if (((this.constantExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {
				scope.problemReporter().enumConstantsCannotBeSurroundedByParenthesis(this.constantExpression);
			}

			if (this.constantExpression instanceof NameReference
					&& (this.constantExpression.bits & ASTNode.RestrictiveFlagMASK) == Binding.FIELD) {
				NameReference reference = (NameReference) this.constantExpression;
				FieldBinding field = reference.fieldBinding();
				if ((field.modifiers & ClassFileConstants.AccEnum) == 0) {
					 scope.problemReporter().enumSwitchCannotTargetField(reference, field);
				} else 	if (reference instanceof QualifiedNameReference) {
					 scope.problemReporter().cannotUseQualifiedEnumConstantInCaseLabel(reference, field);
					}
					return IntConstant.fromValue(field.original().id + 1); // (ordinal value + 1) zero should not be returned see bug 141810
				}
				return IntConstant.fromValue(field.original().id + 1); // (ordinal value + 1) zero should not be returned see bug 141810
				return constantExpression.constant;
			}
		} else {
			return this.constantExpression.constant;
								&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
								&& !switchExpressionType.isBaseType()
								&& constantExpression.isConstantValueOfTypeAssignableToType(caseType, scope.environment().computeBoxingType(switchExpressionType)))) {
			// constantExpression.computeConversion(scope, caseType, switchExpressionType); - do not report boxing/unboxing conversion
			return constantExpression.constant;
		}
	} else if (scope.isBoxingCompatibleWith(caseType, switchExpressionType)
					|| (caseType.isBaseType()  // narrowing then boxing ?
							&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
							&& !switchExpressionType.isBaseType()
							&& this.constantExpression.isConstantValueOfTypeAssignableToType(caseType, scope.environment().computeBoxingType(switchExpressionType)))) {
		// constantExpression.computeConversion(scope, caseType, switchExpressionType); - do not report boxing/unboxing conversion
		return this.constantExpression.constant;
	}
	scope.problemReporter().typeMismatchError(caseType, switchExpressionType, this.constantExpression);
	return Constant.NotAConstant;
}

public void traverse(ASTVisitor visitor, 	BlockScope blockScope) {
	if (visitor.visit(this, blockScope)) {
		if (this.constantExpression != null) this.constantExpression.traverse(visitor, blockScope);
		BlockScope blockScope) {

		if (visitor.visit(this, blockScope)) {
			if (constantExpression != null) constantExpression.traverse(visitor, blockScope);
		}
		visitor.endVisit(this, blockScope);
	}
	visitor.endVisit(this, blockScope);
}
}

Lines 2282-2288 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-1 / +3 lines)
2282	char[][] alreadyUsedConstants = new char[switchStatement.caseCount][];	2282	char[][] alreadyUsedConstants = new char[switchStatement.caseCount][];
2283	int alreadyUsedConstantCount = 0;	2283	int alreadyUsedConstantCount = 0;
2284	for (int i = 0; i < switchStatement.caseCount; i++) {	2284	for (int i = 0; i < switchStatement.caseCount; i++) {
2285	if(cases[i].isEnumConstant && cases[i].constantExpression instanceof SingleNameReference) {	2285	Expression caseExpression = cases[i].constantExpression;
		2286	if((caseExpression instanceof SingleNameReference)
		2287	&& (caseExpression.resolvedType != null && caseExpression.resolvedType.isEnum())) {
2286	alreadyUsedConstants[alreadyUsedConstantCount++] = ((SingleNameReference)cases[i].constantExpression).token;	2288	alreadyUsedConstants[alreadyUsedConstantCount++] = ((SingleNameReference)cases[i].constantExpression).token;
2287	}	2289	}
2288	}	2290	}

Return to bug 146556

Lines 32-38 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ExplicitConstructorCall.java (-3 / +3 lines)
32	public final static int This = 3;	32	public final static int This = 3;
33		33
34	public VariableBinding[][] implicitArguments;	34	public VariableBinding[][] implicitArguments;
35	boolean discardEnclosingInstance;	35	// boolean discardEnclosingInstance;
36		36
37	// TODO Remove once DOMParser is activated	37	// TODO Remove once DOMParser is activated
38	public int typeArgumentsSourceStart;	38	public int typeArgumentsSourceStart;
Lines 117-123 Link Here
117	codeStream.generateSyntheticEnclosingInstanceValues(	117	codeStream.generateSyntheticEnclosingInstanceValues(
118	currentScope,	118	currentScope,
119	targetType,	119	targetType,
120	discardEnclosingInstance ? null : qualification,	120	(this.bits & ASTNode.DiscardEnclosingInstance) != 0 ? null : qualification,
121	this);	121	this);
122	}	122	}
123	// generate arguments	123	// generate arguments
Lines 296-302 Link Here
296	scope.problemReporter().unnecessaryEnclosingInstanceSpecification(	296	scope.problemReporter().unnecessaryEnclosingInstanceSpecification(
297	qualification,	297	qualification,
298	receiverType);	298	receiverType);
299	discardEnclosingInstance = true;	299	this.bits \|= ASTNode.DiscardEnclosingInstance;
300	} else {	300	} else {
301	TypeBinding qTb = qualification.resolveTypeExpecting(scope, enclosingType);	301	TypeBinding qTb = qualification.resolveTypeExpecting(scope, enclosingType);
302	qualification.computeConversion(scope, qTb, qTb);	302	qualification.computeConversion(scope, qTb, qTb);

Lines 27-33 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (-2 / +6 lines)
27	public final static int Bit2 = 0x2; // return type (operator) \| name reference kind (name ref) \| has local type (type, method, field decl)	27	public final static int Bit2 = 0x2; // return type (operator) \| name reference kind (name ref) \| has local type (type, method, field decl)
28	public final static int Bit3 = 0x4; // return type (operator) \| name reference kind (name ref) \| implicit this (this ref)	28	public final static int Bit3 = 0x4; // return type (operator) \| name reference kind (name ref) \| implicit this (this ref)
29	public final static int Bit4 = 0x8; // return type (operator) \| first assignment to local (name ref,local decl) \| undocumented empty block (block, type and method decl)	29	public final static int Bit4 = 0x8; // return type (operator) \| first assignment to local (name ref,local decl) \| undocumented empty block (block, type and method decl)
30	public final static int Bit5 = 0x10; // value for return (expression) \| has all method bodies (unit) \| supertype ref (type ref)	30	public final static int Bit5 = 0x10; // value for return (expression) \| has all method bodies (unit) \| supertype ref (type ref) \| resolved (field decl)
31	public final static int Bit6 = 0x20; // depth (name ref, msg) \| ignore need cast check (cast expression)	31	public final static int Bit6 = 0x20; // depth (name ref, msg) \| ignore need cast check (cast expression)
32	public final static int Bit7 = 0x40; // depth (name ref, msg) \| operator (operator) \| need runtime checkcast (cast expression) \| label used (labelStatement)	32	public final static int Bit7 = 0x40; // depth (name ref, msg) \| operator (operator) \| need runtime checkcast (cast expression) \| label used (labelStatement)
33	public final static int Bit8 = 0x80; // depth (name ref, msg) \| operator (operator) \| unsafe cast (cast expression)	33	public final static int Bit8 = 0x80; // depth (name ref, msg) \| operator (operator) \| unsafe cast (cast expression)
Lines 36-42 Link Here
36	public final static int Bit11 = 0x400; // depth (name ref, msg) \| operator (operator) \| is member type (type decl)	36	public final static int Bit11 = 0x400; // depth (name ref, msg) \| operator (operator) \| is member type (type decl)
37	public final static int Bit12 = 0x800; // depth (name ref, msg) \| operator (operator) \| has abstract methods (type decl)	37	public final static int Bit12 = 0x800; // depth (name ref, msg) \| operator (operator) \| has abstract methods (type decl)
38	public final static int Bit13 = 0x1000; // depth (name ref, msg) \| is secondary type (type decl)	38	public final static int Bit13 = 0x1000; // depth (name ref, msg) \| is secondary type (type decl)
39	public final static int Bit14 = 0x2000; // strictly assigned (reference lhs)	39	public final static int Bit14 = 0x2000; // strictly assigned (reference lhs) \| discard enclosing instance (explicit constr call)
40	public final static int Bit15 = 0x4000; // is unnecessary cast (expression) \| is varargs (type ref) \| isSubRoutineEscaping (try statement)	40	public final static int Bit15 = 0x4000; // is unnecessary cast (expression) \| is varargs (type ref) \| isSubRoutineEscaping (try statement)
41	public final static int Bit16 = 0x8000; // in javadoc comment (name ref, type ref, msg)	41	public final static int Bit16 = 0x8000; // in javadoc comment (name ref, type ref, msg)
42	public final static int Bit17 = 0x10000; // compound assigned (reference lhs)	42	public final static int Bit17 = 0x10000; // compound assigned (reference lhs)
Lines 141-146 Link Here
141		141
142	// for type, method and field declarations	142	// for type, method and field declarations
143	public static final int HasLocalType = Bit2; // cannot conflict with AddAssertionMASK	143	public static final int HasLocalType = Bit2; // cannot conflict with AddAssertionMASK
		144	public static final int HasBeenResolved = Bit5; // field decl only (to handle forward references)
144		145
145	// for expression	146	// for expression
146	public static final int ParenthesizedSHIFT = 21; // Bit22 -> Bit29	147	public static final int ParenthesizedSHIFT = 21; // Bit22 -> Bit29
Lines 151-156 Link Here
151	public static final int IsStrictlyAssigned = Bit14; // set only for true assignments, as opposed to compound ones	152	public static final int IsStrictlyAssigned = Bit14; // set only for true assignments, as opposed to compound ones
152	public static final int IsCompoundAssigned = Bit17; // set only for compound assignments, as opposed to other ones	153	public static final int IsCompoundAssigned = Bit17; // set only for compound assignments, as opposed to other ones
153		154
		155	// for explicit constructor call
		156	public static final int DiscardEnclosingInstance = Bit14; // used for codegen
		157
154	// for empty statement	158	// for empty statement
155	public static final int IsUsefulEmptyStatement = Bit1;	159	public static final int IsUsefulEmptyStatement = Bit1;
156		160

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/CaseStatement.java (-115 / +115 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 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 11-148 Link Here
11	package org.eclipse.jdt.internal.compiler.ast;	11	package org.eclipse.jdt.internal.compiler.ast;
12		12
13	import org.eclipse.jdt.internal.compiler.ASTVisitor;	13	import org.eclipse.jdt.internal.compiler.ASTVisitor;
14	import org.eclipse.jdt.internal.compiler.impl.*;
15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	14	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
16	import org.eclipse.jdt.internal.compiler.codegen.*;	15	import org.eclipse.jdt.internal.compiler.codegen.CaseLabel;
17	import org.eclipse.jdt.internal.compiler.flow.*;	16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
18	import org.eclipse.jdt.internal.compiler.lookup.*;	17	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
		18	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
		19	import org.eclipse.jdt.internal.compiler.impl.Constant;
		20	import org.eclipse.jdt.internal.compiler.impl.IntConstant;
		21	import org.eclipse.jdt.internal.compiler.lookup.Binding;
		22	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
		23	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
		24	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
		25	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
19		26
20	public class CaseStatement extends Statement {	27	public class CaseStatement extends Statement {
21		28
22	public Expression constantExpression;	29	public Expression constantExpression;
23	public CaseLabel targetLabel;	30	public CaseLabel targetLabel;
24	public boolean isEnumConstant;
25		31
26	public CaseStatement(Expression constantExpression, int sourceEnd, int sourceStart) {	32	public CaseStatement(Expression constantExpression, int sourceEnd, int sourceStart) {
27	this.constantExpression = constantExpression;	33	this.constantExpression = constantExpression;
28	this.sourceEnd = sourceEnd;	34	this.sourceEnd = sourceEnd;
29	this.sourceStart = sourceStart;	35	this.sourceStart = sourceStart;
30	}	36	}
31		37
32	public FlowInfo analyseCode(	38	public FlowInfo analyseCode(
33	BlockScope currentScope,	39	BlockScope currentScope,
34	FlowContext flowContext,	40	FlowContext flowContext,
35	FlowInfo flowInfo) {	41	FlowInfo flowInfo) {
36		42
37	if (constantExpression != null) {	43	if (this.constantExpression != null) {
38	if (!this.isEnumConstant && constantExpression.constant == Constant.NotAConstant) {	44	if (this.constantExpression.constant == Constant.NotAConstant
39	currentScope.problemReporter().caseExpressionMustBeConstant(constantExpression);	45	&& !this.constantExpression.resolvedType.isEnum()) {
40	}	46	currentScope.problemReporter().caseExpressionMustBeConstant(this.constantExpression);
41	this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);
42	}	47	}
43	return flowInfo;	48	this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);
44	}	49	}
		50	return flowInfo;
		51	}
45		52
46	public StringBuffer printStatement(int tab, StringBuffer output) {	53	public StringBuffer printStatement(int tab, StringBuffer output) {
47		54	printIndent(tab, output);
48	printIndent(tab, output);	55	if (this.constantExpression == null) {
49	if (constantExpression == null) {	56	output.append("default : "); //$NON-NLS-1$
50	output.append("default : "); //$NON-NLS-1$	57	} else {
51	} else {	58	output.append("case "); //$NON-NLS-1$
52	output.append("case "); //$NON-NLS-1$	59	this.constantExpression.printExpression(0, output).append(" : "); //$NON-NLS-1$
53	constantExpression.printExpression(0, output).append(" : "); //$NON-NLS-1$
54	}
55	return output.append(';');
56	}	60	}
57		61	return output.append(';');
58	/**	62	}
59	* Case code generation
60	*
61	*/
62	public void generateCode(BlockScope currentScope, CodeStream codeStream) {
63		63
64	if ((bits & IsReachable) == 0) {	64	/**
65	return;	65	* Case code generation
66	}	66	*
67	int pc = codeStream.position;	67	*/
68	targetLabel.place();	68	public void generateCode(BlockScope currentScope, CodeStream codeStream) {
69	codeStream.recordPositionsFrom(pc, this.sourceStart);	69	if ((this.bits & ASTNode.IsReachable) == 0) {
70	}	70	return;
71		71	}
72	/**	72	int pc = codeStream.position;
73	* No-op : should use resolveCase(...) instead.	73	this.targetLabel.place();
74	*/	74	codeStream.recordPositionsFrom(pc, this.sourceStart);
75	public void resolve(BlockScope scope) {	75	}
76	// no-op : should use resolveCase(...) instead.	76
77	}	77	/**
78		78	* No-op : should use resolveCase(...) instead.
79	/**	79	*/
80	* Returns the constant intValue or ordinal for enum constants. If constant is NotAConstant, then answers Float.MIN_VALUE	80	public void resolve(BlockScope scope) {
81	* @see org.eclipse.jdt.internal.compiler.ast.Statement#resolveCase(org.eclipse.jdt.internal.compiler.lookup.BlockScope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.ast.SwitchStatement)	81	// no-op : should use resolveCase(...) instead.
82	*/	82	}
83	public Constant resolveCase(BlockScope scope, TypeBinding switchExpressionType, SwitchStatement switchStatement) {	83
84	// switchExpressionType maybe null in error case	84	/**
85	scope.enclosingCase = this; // record entering in a switch case block	85	* Returns the constant intValue or ordinal for enum constants. If constant is NotAConstant, then answers Float.MIN_VALUE
86		86	* @see org.eclipse.jdt.internal.compiler.ast.Statement#resolveCase(org.eclipse.jdt.internal.compiler.lookup.BlockScope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.ast.SwitchStatement)
87	if (constantExpression == null) {	87	*/
88	// remember the default case into the associated switch statement	88	public Constant resolveCase(BlockScope scope, TypeBinding switchExpressionType, SwitchStatement switchStatement) {
89	if (switchStatement.defaultCase != null)	89	// switchExpressionType maybe null in error case
90	scope.problemReporter().duplicateDefaultCase(this);	90	scope.enclosingCase = this; // record entering in a switch case block
91		91
92	// on error the last default will be the selected one ...	92	if (this.constantExpression == null) {
93	switchStatement.defaultCase = this;	93	// remember the default case into the associated switch statement
94	return Constant.NotAConstant;	94	if (switchStatement.defaultCase != null)
95	}	95	scope.problemReporter().duplicateDefaultCase(this);
96	// add into the collection of cases of the associated switch statement	96
97	switchStatement.cases[switchStatement.caseCount++] = this;	97	// on error the last default will be the selected one ...
98	// tag constant name with enum type for privileged access to its members	98	switchStatement.defaultCase = this;
99	if (switchExpressionType != null && switchExpressionType.isEnum() && (constantExpression instanceof SingleNameReference)) {	99	return Constant.NotAConstant;
100	((SingleNameReference) constantExpression).setActualReceiverType((ReferenceBinding)switchExpressionType);	100	}
101	}	101	// add into the collection of cases of the associated switch statement
102	TypeBinding caseType = constantExpression.resolveType(scope);	102	switchStatement.cases[switchStatement.caseCount++] = this;
103	if (caseType == null \|\| switchExpressionType == null) return Constant.NotAConstant;	103	// tag constant name with enum type for privileged access to its members
104	if (constantExpression.isConstantValueOfTypeAssignableToType(caseType, switchExpressionType)	104	if (switchExpressionType != null && switchExpressionType.isEnum() && (this.constantExpression instanceof SingleNameReference)) {
105	\|\| caseType.isCompatibleWith(switchExpressionType)) {	105	((SingleNameReference) this.constantExpression).setActualReceiverType((ReferenceBinding)switchExpressionType);
106	if (caseType.isEnum()) {	106	}
107	this.isEnumConstant = true;	107	TypeBinding caseType = this.constantExpression.resolveType(scope);
108	if (((this.constantExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {	108	if (caseType == null \|\| switchExpressionType == null) return Constant.NotAConstant;
109	scope.problemReporter().enumConstantsCannotBeSurroundedByParenthesis(this.constantExpression);	109	if (this.constantExpression.isConstantValueOfTypeAssignableToType(caseType, switchExpressionType)
110	}	110	\|\| caseType.isCompatibleWith(switchExpressionType)) {
		111	if (caseType.isEnum()) {
		112	if (((this.constantExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {
		113	scope.problemReporter().enumConstantsCannotBeSurroundedByParenthesis(this.constantExpression);
		114	}
111		115
112	if (constantExpression instanceof NameReference	116	if (this.constantExpression instanceof NameReference
113	&& (constantExpression.bits & RestrictiveFlagMASK) == Binding.FIELD) {	117	&& (this.constantExpression.bits & ASTNode.RestrictiveFlagMASK) == Binding.FIELD) {
114	NameReference reference = (NameReference) constantExpression;	118	NameReference reference = (NameReference) this.constantExpression;
115	FieldBinding field = reference.fieldBinding();	119	FieldBinding field = reference.fieldBinding();
116	if ((field.modifiers & ClassFileConstants.AccEnum) == 0) {	120	if ((field.modifiers & ClassFileConstants.AccEnum) == 0) {
117	scope.problemReporter().enumSwitchCannotTargetField(reference, field);	121	scope.problemReporter().enumSwitchCannotTargetField(reference, field);
118	} else if (reference instanceof QualifiedNameReference) {	122	} else if (reference instanceof QualifiedNameReference) {
119	scope.problemReporter().cannotUseQualifiedEnumConstantInCaseLabel(reference, field);	123	scope.problemReporter().cannotUseQualifiedEnumConstantInCaseLabel(reference, field);
120	}
121	return IntConstant.fromValue(field.original().id + 1); // (ordinal value + 1) zero should not be returned see bug 141810
122	}	124	}
123	} else {	125	return IntConstant.fromValue(field.original().id + 1); // (ordinal value + 1) zero should not be returned see bug 141810
124	return constantExpression.constant;
125	}	126	}
126	} else if (scope.isBoxingCompatibleWith(caseType, switchExpressionType)	127	} else {
127	\|\| (caseType.isBaseType() // narrowing then boxing ?	128	return this.constantExpression.constant;
128	&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
129	&& !switchExpressionType.isBaseType()
130	&& constantExpression.isConstantValueOfTypeAssignableToType(caseType, scope.environment().computeBoxingType(switchExpressionType)))) {
131	// constantExpression.computeConversion(scope, caseType, switchExpressionType); - do not report boxing/unboxing conversion
132	return constantExpression.constant;
133	}	129	}
134	scope.problemReporter().typeMismatchError(caseType, switchExpressionType, constantExpression);	130	} else if (scope.isBoxingCompatibleWith(caseType, switchExpressionType)
135	return Constant.NotAConstant;	131	\|\| (caseType.isBaseType() // narrowing then boxing ?
		132	&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
		133	&& !switchExpressionType.isBaseType()
		134	&& this.constantExpression.isConstantValueOfTypeAssignableToType(caseType, scope.environment().computeBoxingType(switchExpressionType)))) {
		135	// constantExpression.computeConversion(scope, caseType, switchExpressionType); - do not report boxing/unboxing conversion
		136	return this.constantExpression.constant;
136	}	137	}
		138	scope.problemReporter().typeMismatchError(caseType, switchExpressionType, this.constantExpression);
		139	return Constant.NotAConstant;
		140	}
137		141
138		142	public void traverse(ASTVisitor visitor, BlockScope blockScope) {
139	public void traverse(	143	if (visitor.visit(this, blockScope)) {
140	ASTVisitor visitor,	144	if (this.constantExpression != null) this.constantExpression.traverse(visitor, blockScope);
141	BlockScope blockScope) {
142
143	if (visitor.visit(this, blockScope)) {
144	if (constantExpression != null) constantExpression.traverse(visitor, blockScope);
145	}
146	visitor.endVisit(this, blockScope);
147	}	145	}
		146	visitor.endVisit(this, blockScope);
		147	}
148	}	148	}