private static ASTRewriteCorrectionProposal createNoSideEffectProposal(IInvocationContext context, SimpleName nodeToQualify, IVariableBinding fieldBinding, String label, int relevance) {
	AST ast= nodeToQualify.getAST();

	Expression qualifier;
	if (Modifier.isStatic(fieldBinding.getModifiers())) {
		ITypeBinding declaringClass= fieldBinding.getDeclaringClass();
		qualifier= ast.newSimpleName(declaringClass.getTypeDeclaration().getName());
	} else {
		qualifier= ast.newThisExpression();
	}

	ASTRewrite rewrite= ASTRewrite.create(ast);
	FieldAccess access= ast.newFieldAccess();
	access.setName((SimpleName) rewrite.createCopyTarget(nodeToQualify));
	access.setExpression(qualifier);
	rewrite.replace(nodeToQualify, access, null);


	Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
	return new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, relevance, image);
}
 

public static boolean evaluateMissingSwitchCases(ITypeBinding enumBindings, List<Statement> switchStatements, ArrayList<String> enumConstNames) {
	IVariableBinding[] fields= enumBindings.getDeclaredFields();
	for (int i= 0; i < fields.length; i++) {
		if (fields[i].isEnumConstant()) {
			enumConstNames.add(fields[i].getName());
		}
	}

	boolean hasDefault=false;
	List<Statement> statements= switchStatements;
	for (int i= 0; i < statements.size(); i++) {
		Statement curr= statements.get(i);
		if (curr instanceof SwitchCase) {
			Expression expression= ((SwitchCase) curr).getExpression();
			if (expression instanceof SimpleName) {
				enumConstNames.remove(((SimpleName) expression).getFullyQualifiedName());
			} else if(expression== null){
				hasDefault=true;
			}
		}
	}
	return hasDefault;
}
 

private boolean considerBinding(IBinding binding, ASTNode node) {
	if (!(binding instanceof IVariableBinding))
		return false;
	boolean result= Bindings.equals(fFieldBinding, ((IVariableBinding)binding).getVariableDeclaration());
	if (!result || fEncapsulateDeclaringClass)
		return result;

	if (binding instanceof IVariableBinding) {
		AbstractTypeDeclaration type= (AbstractTypeDeclaration)ASTNodes.getParent(node, AbstractTypeDeclaration.class);
		if (type != null) {
			ITypeBinding declaringType= type.resolveBinding();
			return !Bindings.equals(fDeclaringClassBinding, declaringType);
		}
	}
	return true;
}
 

public GenerateToStringDialog(Shell shell, CompilationUnitEditor editor, IType type, IVariableBinding[] fields, IVariableBinding[] inheritedFields, IVariableBinding[] selectedFields,
		IMethodBinding[] methods, IMethodBinding[] inheritededMethods) throws JavaModelException {
	super(shell, new BindingLabelProvider(), new GenerateToStringContentProvider(fields, inheritedFields, methods, inheritededMethods), editor, type, false);
	setEmptyListMessage(JavaUIMessages.GenerateHashCodeEqualsDialog_no_entries);

	List<Object> selected= new ArrayList<Object>(Arrays.asList(selectedFields));
	if (selectedFields.length == fields.length && selectedFields.length > 0)
		selected.add(getContentProvider().getParent(selectedFields[0]));
	setInitialElementSelections(selected);

	setTitle(JavaUIMessages.GenerateToStringDialog_dialog_title);
	setMessage(JavaUIMessages.GenerateToStringDialog_select_fields_to_include);
	setValidator(new GenerateToStringValidator(fields.length + inheritedFields.length, methods.length + inheritededMethods.length));
	setSize(60, 18);
	setInput(new Object());

	fGenerationSettings= new ToStringGenerationSettings(getDialogSettings());
}
 

private void sortTypes(ITypeBinding[] typeProposals) {
	ITypeBinding oldType;
	if (fBinding instanceof IMethodBinding) {
		oldType= ((IMethodBinding) fBinding).getReturnType();
	} else {
		oldType= ((IVariableBinding) fBinding).getType();
	}
	if (! oldType.isParameterizedType())
		return;
	
	final ITypeBinding oldTypeDeclaration= oldType.getTypeDeclaration();
	Arrays.sort(typeProposals, new Comparator<ITypeBinding>() {
		public int compare(ITypeBinding o1, ITypeBinding o2) {
			return rank(o2) - rank(o1);
		}

		private int rank(ITypeBinding type) {
			if (type.getTypeDeclaration().equals(oldTypeDeclaration))
				return 1;
			return 0;
		}
	});
}
 

private Expression convert(org.eclipse.jdt.core.dom.QualifiedName expression) {
  IBinding binding = expression.resolveBinding();
  if (binding instanceof IVariableBinding) {
    IVariableBinding variableBinding = (IVariableBinding) binding;
    checkArgument(
        variableBinding.isField(),
        internalCompilerErrorMessage("Unexpected QualifiedName that is not a field"));

    Expression qualifier = convert(expression.getQualifier());
    return JdtUtils.createFieldAccess(qualifier, variableBinding);
  }

  if (binding instanceof ITypeBinding) {
    return null;
  }

  throw internalCompilerError(
      "Unexpected type for QualifiedName binding: %s ", binding.getClass().getName());
}
 

private Expression evaluateArgumentExpressions(AST ast, ITypeBinding requiredType, String key) {
	CompilationUnit root= (CompilationUnit) fCallerNode.getRoot();

	int offset= fCallerNode.getStartPosition();
	Expression best= null;
	ITypeBinding bestType= null;

	ScopeAnalyzer analyzer= new ScopeAnalyzer(root);
	IBinding[] bindings= analyzer.getDeclarationsInScope(offset, ScopeAnalyzer.VARIABLES);
	for (int i= 0; i < bindings.length; i++) {
		IVariableBinding curr= (IVariableBinding) bindings[i];
		ITypeBinding type= curr.getType();
		if (type != null && canAssign(type, requiredType) && testModifier(curr)) {
			if (best == null || isMoreSpecific(bestType, type)) {
				best= ast.newSimpleName(curr.getName());
				bestType= type;
			}
		}
	}
	Expression defaultExpression= ASTNodeFactory.newDefaultExpression(ast, requiredType);
	if (best == null) {
		best= defaultExpression;
	}
	return best;
}
 

private void adjustArgumentsAndMethodLocals() {
	for (int i= 0; i < fArguments.length; i++) {
		IVariableBinding argument= fArguments[i];
		// Both arguments and locals consider FlowInfo.WRITE_POTENTIAL. But at the end a variable
		// can either be a local of an argument. Fix this based on the compute return type which
		// didn't exist when we computed the locals and arguments (see computeInput())
		if (fInputFlowInfo.hasAccessMode(fInputFlowContext, argument, FlowInfo.WRITE_POTENTIAL)) {
			if (argument != fReturnValue)
				fArguments[i]= null;
			// We didn't remove the argument. So we have to remove the local declaration
			if (fArguments[i] != null) {
				for (int l= 0; l < fMethodLocals.length; l++) {
					if (fMethodLocals[l] == argument)
						fMethodLocals[l]= null;
				}
			}
		}
	}
}
 

private void computeUsedNames() {
	fUsedReadNames = new ArrayList<>(0);
	fUsedModifyNames = new ArrayList<>(0);
	IVariableBinding binding = fFieldDeclaration.resolveBinding();
	ITypeBinding type = binding.getType();
	IMethodBinding[] methods = binding.getDeclaringClass().getDeclaredMethods();
	for (int i = 0; i < methods.length; i++) {
		IMethodBinding method = methods[i];
		ITypeBinding[] parameters = methods[i].getParameterTypes();
		if (parameters == null || parameters.length == 0) {
			fUsedReadNames.add(method);
		} else if (parameters.length == 1 && parameters[0] == type) {
			fUsedModifyNames.add(method);
		}
	}
}
 

private String getDisplayString(IBinding binding) {
	switch (binding.getKind()) {
		case IBinding.TYPE:
			return FixMessages.UnusedCodeFix_RemoveUnusedType_description;
		case IBinding.METHOD:
			if (((IMethodBinding) binding).isConstructor()) {
				return FixMessages.UnusedCodeFix_RemoveUnusedConstructor_description;
			} else {
				return FixMessages.UnusedCodeFix_RemoveUnusedPrivateMethod_description;
			}
		case IBinding.VARIABLE:
			if (((IVariableBinding) binding).isField()) {
				return FixMessages.UnusedCodeFix_RemoveUnusedField_description;
			} else {
				return FixMessages.UnusedCodeFix_RemoveUnusedVariabl_description;
			}
		default:
			return ""; //$NON-NLS-1$
	}
}
 

@Override
boolean generateCandidates() {
	IVariableBinding[] fCandidateFields= fTypeBinding.getDeclaredFields();

	allFields= new ArrayList<IVariableBinding>();
	selectedFields= new ArrayList<IVariableBinding>();
	for (int i= 0; i < fCandidateFields.length; i++) {
		if (!Modifier.isStatic(fCandidateFields[i].getModifiers())) {
			allFields.add(fCandidateFields[i]);
			if (!Modifier.isTransient(fCandidateFields[i].getModifiers()))
				selectedFields.add(fCandidateFields[i]);
		}
	}
	if (allFields.isEmpty()) {
		return false;
	}
	return true;
}
 

/**
 * Evaluates if the declaration is visible in a certain context.
 * @param binding The binding of the declaration to examine
 * @param context The context to test in
 * @return Returns
 */
public static boolean isVisible(IBinding binding, ITypeBinding context) {
	if (binding.getKind() == IBinding.VARIABLE && !((IVariableBinding) binding).isField()) {
		return true; // all local variables found are visible
	}
	ITypeBinding declaring= getDeclaringType(binding);
	if (declaring == null) {
		return false;
	}

	declaring= declaring.getTypeDeclaration();

	int modifiers= binding.getModifiers();
	if (Modifier.isPublic(modifiers) || declaring.isInterface()) {
		return true;
	} else if (Modifier.isProtected(modifiers) || !Modifier.isPrivate(modifiers)) {
		if (declaring.getPackage() == context.getPackage()) {
			return true;
		}
		return isTypeInScope(declaring, context, Modifier.isProtected(modifiers));
	}
	// private visibility
	return isTypeInScope(declaring, context, false);
}
 

/**
 * Creates a new add custom constructor operation.
 *
 * @param astRoot the compilation unit ast node
 * @param parentType the type to add the methods to
 * 	@param variables the variable bindings to use in the constructor
 * @param constructor the method binding of the super constructor
 * @param insert the insertion point, or <code>null</code>


 * @param settings the code generation settings to use
 * @param apply <code>true</code> if the resulting edit should be applied, <code>false</code> otherwise
 * @param save <code>true</code> if the changed compilation unit should be saved, <code>false</code> otherwise
 */
public AddCustomConstructorOperation(CompilationUnit astRoot, ITypeBinding parentType, IVariableBinding[] variables, IMethodBinding constructor, IJavaElement insert, CodeGenerationSettings settings, boolean apply, boolean save) {
	Assert.isTrue(astRoot != null && astRoot.getTypeRoot() instanceof ICompilationUnit);
	Assert.isNotNull(parentType);
	Assert.isNotNull(variables);
	Assert.isNotNull(constructor);
	Assert.isNotNull(settings);
	fParentType= parentType;
	fInsert= insert;
	fASTRoot= astRoot;
	fFieldBindings= variables;
	fConstructorBinding= constructor;
	fSettings= settings;
	fSave= save;
	fApply= apply;
}
 

@Override
public void endVisit(SimpleName node) {
	if (skipNode(node) || node.isDeclaration()) {
		return;
	}
	IBinding binding = node.resolveBinding();
	if (binding instanceof IVariableBinding) {
		IVariableBinding variable = (IVariableBinding) binding;
		if (!variable.isField()) {
			setFlowInfo(node, new LocalFlowInfo(variable, FlowInfo.READ, fFlowContext));
		}
	} else if (binding instanceof ITypeBinding) {
		ITypeBinding type = (ITypeBinding) binding;
		if (type.isTypeVariable()) {
			setFlowInfo(node, new TypeVariableFlowInfo(type, fFlowContext));
		}
	}
}
 

private void createFieldsForAccessedLocals(CompilationUnitRewrite rewrite, IVariableBinding[] varBindings, String[] fieldNames, List<BodyDeclaration> newBodyDeclarations) throws CoreException {
	final ImportRewrite importRewrite= rewrite.getImportRewrite();
	final ASTRewrite astRewrite= rewrite.getASTRewrite();
	final AST ast= astRewrite.getAST();

	for (int i= 0; i < varBindings.length; i++) {
		VariableDeclarationFragment fragment= ast.newVariableDeclarationFragment();
		fragment.setInitializer(null);
		fragment.setName(ast.newSimpleName(fieldNames[i]));
		FieldDeclaration field= ast.newFieldDeclaration(fragment);
		ITypeBinding varType= varBindings[i].getType();
		field.setType(importRewrite.addImport(varType, ast));
		field.modifiers().addAll(ASTNodeFactory.newModifiers(ast, Modifier.PRIVATE | Modifier.FINAL));
		if (doAddComments()) {
			String string= CodeGeneration.getFieldComment(rewrite.getCu(), varType.getName(), fieldNames[i], StubUtility.getLineDelimiterUsed(fCu));
			if (string != null) {
				Javadoc javadoc= (Javadoc) astRewrite.createStringPlaceholder(string, ASTNode.JAVADOC);
				field.setJavadoc(javadoc);
			}
		}

		newBodyDeclarations.add(field);

		addLinkedPosition(KEY_FIELD_NAME_EXT + i, fragment.getName(), astRewrite, false);
	}
}
 

private static String getExpressionBaseName(Expression expr) {
	IBinding argBinding= Bindings.resolveExpressionBinding(expr, true);
	if (argBinding instanceof IVariableBinding) {
		IJavaProject project= null;
		ASTNode root= expr.getRoot();
		if (root instanceof CompilationUnit) {
			ITypeRoot typeRoot= ((CompilationUnit) root).getTypeRoot();
			if (typeRoot != null)
				project= typeRoot.getJavaProject();
		}
		return StubUtility.getBaseName((IVariableBinding)argBinding, project);
	}
	if (expr instanceof SimpleName)
		return ((SimpleName) expr).getIdentifier();
	return null;
}
 

/**
 * End of visit the variable declaration fragment list.
 *
 * @param fragments the fragments (element type: <code>VariableDeclarationFragment</code>)
 * @param type the type of the fragments
 * @param parent the parent of the fragment list
 */
private void endVisit(final List<VariableDeclarationFragment> fragments, final Type type, final ASTNode parent) {
	final ConstraintVariable2 ancestor= (ConstraintVariable2) type.getProperty(PROPERTY_CONSTRAINT_VARIABLE);
	if (ancestor != null) {
		IVariableBinding binding= null;
		ConstraintVariable2 descendant= null;
		VariableDeclarationFragment fragment= null;
		for (int index= 0; index < fragments.size(); index++) {
			fragment= fragments.get(index);
			descendant= (ConstraintVariable2) fragment.getProperty(PROPERTY_CONSTRAINT_VARIABLE);
			if (descendant != null)
				fModel.createSubtypeConstraint(descendant, ancestor);
			binding= fragment.resolveBinding();
			if (binding != null) {
				descendant= fModel.createVariableVariable(binding);
				if (descendant != null)
					fModel.createEqualityConstraint(ancestor, descendant);
			}
		}
		parent.setProperty(PROPERTY_CONSTRAINT_VARIABLE, ancestor);
	}
}
 

private IVariableBinding[] compressArray(IVariableBinding[] array) {
	if (array == null) {
		return null;
	}
	int size = 0;
	for (int i = 0; i < array.length; i++) {
		if (array[i] != null) {
			size++;
		}
	}
	if (size == array.length) {
		return array;
	}
	IVariableBinding[] result = new IVariableBinding[size];
	for (int i = 0, r = 0; i < array.length; i++) {
		if (array[i] != null) {
			result[r++] = array[i];
		}
	}
	return result;
}
 

private void initializeParameterInfos() {
	IVariableBinding[] arguments = fAnalyzer.getArguments();
	fParameterInfos = new ArrayList<>(arguments.length);
	ASTNode root = fAnalyzer.getEnclosingBodyDeclaration();
	ParameterInfo vararg = null;
	for (int i = 0; i < arguments.length; i++) {
		IVariableBinding argument = arguments[i];
		if (argument == null) {
			continue;
		}
		VariableDeclaration declaration = ASTNodes.findVariableDeclaration(argument, root);
		boolean isVarargs = declaration instanceof SingleVariableDeclaration ? ((SingleVariableDeclaration) declaration).isVarargs() : false;
		ParameterInfo info = new ParameterInfo(argument, getType(declaration, isVarargs), argument.getName(), i);
		if (isVarargs) {
			vararg = info;
		} else {
			fParameterInfos.add(info);
		}
	}
	if (vararg != null) {
		fParameterInfos.add(vararg);
	}
}
 

private boolean accessesAnonymousFields() {
    List<IVariableBinding> anonymousInnerFieldTypes = getAllEnclosingAnonymousTypesField();
    List<IBinding> accessedField = getAllAccessedFields();
    final Iterator<IVariableBinding> it = anonymousInnerFieldTypes.iterator();
    while(it.hasNext()) {
        final IVariableBinding variableBinding = it.next();
        final Iterator<IBinding> it2 = accessedField.iterator();
        while (it2.hasNext()) {
            IVariableBinding variableBinding2 = (IVariableBinding) it2.next();
            if(Bindings.equals(variableBinding, variableBinding2)) {
                return true;
            }
        }
    }
    return false;
}
 

private boolean allStaticFieldsWithinSystemBoundary(List<SimpleName> staticFields) {
	for(SimpleName staticField : staticFields) {
		IBinding binding = staticField.resolveBinding();
		if(binding != null && binding.getKind() == IBinding.VARIABLE) {
			IVariableBinding variableBinding = (IVariableBinding)binding;
			ITypeBinding declaringClassTypeBinding = variableBinding.getDeclaringClass();
			if(declaringClassTypeBinding != null) {
				if(getPositionInClassList(declaringClassTypeBinding.getQualifiedName()) == -1 && !declaringClassTypeBinding.isEnum())
					return false;
			}
		}
	}
	return true;
}
 

private boolean addUsage(Name node, IBinding binding) {
	if (binding != null && Bindings.equals(getBindingDeclaration(binding), fTarget)) {
		int flag= 0;
		String description= fReadDescription;
		if (fTarget instanceof IVariableBinding) {
			boolean isWrite= fWriteUsages.remove(node);
			flag= isWrite ? F_WRITE_OCCURRENCE : F_READ_OCCURRENCE;
			if (isWrite)
				description= fWriteDescription;
		}
		fResult.add(new OccurrenceLocation(node.getStartPosition(), node.getLength(), flag, description));
		return true;
	}
	return false;
}
 

private SimpleName setterMethodForField(MethodInvocation methodInvocation, SimpleName fieldName) {
	IMethodBinding methodBinding = methodInvocation.resolveMethodBinding();
	ITypeBinding declaringClassTypeBinding = methodBinding.getDeclaringClass();
	ClassObject declaringClass = ASTReader.getSystemObject().getClassObject(declaringClassTypeBinding.getQualifiedName());
	if(declaringClass != null) {
		ListIterator<MethodObject> methodIterator = declaringClass.getMethodIterator();
		while(methodIterator.hasNext()) {
			MethodObject method = methodIterator.next();
			MethodDeclaration methodDeclaration = method.getMethodDeclaration();
			if(methodDeclaration.resolveBinding().isEqualTo(methodInvocation.resolveMethodBinding())) {
				SimpleName setField = MethodDeclarationUtility.isSetter(methodDeclaration);
				if(setField != null) {
					if(setField.resolveBinding().getKind() == IBinding.VARIABLE &&
							fieldName.resolveBinding().getKind() == IBinding.VARIABLE) {
						IVariableBinding setFieldBinding = (IVariableBinding)setField.resolveBinding();
						IVariableBinding fieldNameBinding = (IVariableBinding)fieldName.resolveBinding();
						if(setFieldBinding.isEqualTo(fieldNameBinding) ||
								(setField.getIdentifier().equals(fieldName.getIdentifier()) &&
								setFieldBinding.getType().isEqualTo(fieldNameBinding.getType()) && setFieldBinding.getType().getQualifiedName().equals(fieldNameBinding.getType().getQualifiedName()))) {
							return setField;
						}
					}
				}
			}
		}
	}
	return null;
}
 

@Override
IWorkspaceRunnable createOperation(Object[] selectedBindings, CodeGenerationSettings settings, boolean regenerate, IJavaElement type, IJavaElement elementPosition) {
	final IVariableBinding[] selectedVariableBindings= Arrays.asList(selectedBindings).toArray(new IVariableBinding[0]);
	HashCodeEqualsGenerationSettings hashCodeEqualsGenerationSettings= (HashCodeEqualsGenerationSettings)settings;
	GenerateHashCodeEqualsOperation operation= new GenerateHashCodeEqualsOperation(fTypeBinding, selectedVariableBindings, fUnit, elementPosition, settings,
			hashCodeEqualsGenerationSettings.useInstanceOf, regenerate, true, false);
	operation.setUseBlocksForThen(hashCodeEqualsGenerationSettings.useBlocks);
	return operation;
}
 

private static boolean canAddFinal(IBinding binding, ASTNode declNode) {
	if (!(binding instanceof IVariableBinding))
		return false;

	IVariableBinding varbinding= (IVariableBinding)binding;
	int modifiers= varbinding.getModifiers();
	if (Modifier.isFinal(modifiers) || Modifier.isVolatile(modifiers) || Modifier.isTransient(modifiers))
		return false;

	ASTNode parent= ASTNodes.getParent(declNode, VariableDeclarationExpression.class);
	if (parent != null && ((VariableDeclarationExpression)parent).fragments().size() > 1)
		return false;

	if (varbinding.isField() && !Modifier.isPrivate(modifiers))
		return false;

	if (varbinding.isParameter()) {
		ASTNode varDecl= declNode.getParent();
		if (varDecl instanceof MethodDeclaration) {
			MethodDeclaration declaration= (MethodDeclaration)varDecl;
			if (declaration.getBody() == null)
				return false;
		}
	}

	return true;
}
 

private Expression convert(org.eclipse.jdt.core.dom.SimpleName expression) {
  IBinding binding = expression.resolveBinding();
  if (binding instanceof IVariableBinding) {
    IVariableBinding variableBinding = (IVariableBinding) binding;
    if (variableBinding.isField()) {
      // It refers to a field.
      FieldDescriptor fieldDescriptor = JdtUtils.createFieldDescriptor(variableBinding);
      if (!fieldDescriptor.isStatic()
          && !fieldDescriptor.isMemberOf(getCurrentType().getTypeDescriptor())) {
        return FieldAccess.Builder.from(fieldDescriptor)
            .setQualifier(
                resolveImplicitOuterClassReference(
                    fieldDescriptor.getEnclosingTypeDescriptor()))
            .build();
      } else {
        return FieldAccess.Builder.from(fieldDescriptor).build();
      }
    } else {
      // It refers to a local variable or parameter in a method or block.
      Variable variable = checkNotNull(variableByJdtBinding.get(variableBinding));
      return resolveVariableReference(variable);
    }
  }

  if (binding instanceof ITypeBinding) {
    return null;
  }

  throw internalCompilerError(
      "Unexpected binding class for SimpleName: %s", expression.getClass().getName());
}
 

private Variable createVariable(VariableDeclaration variableDeclaration) {
  IVariableBinding variableBinding = variableDeclaration.resolveBinding();
  Variable variable =
      JdtUtils.createVariable(
          getSourcePosition(variableBinding.getName(), variableDeclaration.getName()),
          variableBinding);
  variableByJdtBinding.put(variableBinding, variable);
  recordEnclosingType(variable, getCurrentType());
  return variable;
}
 

@Override
public boolean visit(FieldDeclaration node) {
    IVariableBinding variable = getVariableBinding(node);
    if (variable == null) {
        return super.visit(node);
    }
    ITypeBinding classBinding = variable.getDeclaringClass();
    if (!classBinding.isClass() && !classBinding.isInterface()) {
        // enum method, etc
        return super.visit(node);
    }

    // TODO support additional testDoc for Field
    String testDoc = ASTUtils.getTestDoc(variable, locales);
    if (testDoc == null) {
        return super.visit(node);
    }

    TestClass testClass = classBindingTestClass(classBinding);
    TestField testField = new TestField();
    testField.setTestClassKey(testClass.getKey());
    testField.setTestClass(testClass);
    testField.setKey(testClass.getKey() + "." + variable.getName());
    testField.setSimpleName(variable.getName());
    testField.setTestDoc(testDoc);
    testField.setValue(null); // TODO currently not supported
    fieldTable.addTestField(testField);

    testClass.addTestFieldKey(testField.getKey());
    testClass.addTestField(testField);

    return super.visit(node);
}
 

@Override
public boolean visit(SimpleName node) {
	ITypeBinding typeBinding= node.resolveTypeBinding();
	if (typeBinding != null && typeBinding.isLocal()) {
		if (node.isDeclaration()) {
			fLocalDefinitions.add(typeBinding);
		} else if (! fLocalDefinitions.contains(typeBinding)) {
			fLocalReferencesToEnclosing.add(node);
		}
	}
	if (typeBinding != null && typeBinding.isTypeVariable()) {
		if (node.isDeclaration()) {
			fLocalDefinitions.add(typeBinding);
		} else if (! fLocalDefinitions.contains(typeBinding)) {
			if (fMethodTypeVariables.contains(typeBinding)) {
				fLocalReferencesToEnclosing.add(node);
			} else {
				fClassTypeVariablesUsed= true;
			}
		}
	}
	IBinding binding= node.resolveBinding();
	if (binding != null && binding.getKind() == IBinding.VARIABLE && ! ((IVariableBinding)binding).isField()) {
		if (node.isDeclaration()) {
			fLocalDefinitions.add(binding);
		} else if (! fLocalDefinitions.contains(binding)) {
			fLocalReferencesToEnclosing.add(node);
		}
	}
	return super.visit(node);
}
 

/**
 * @since 2.4
 */
protected JvmField createField(StringBuilder typeName, IVariableBinding field) {
	JvmField result;
	if (!field.isEnumConstant()) {
		result = TypesFactory.eINSTANCE.createJvmField();
		Object constantValue = field.getConstantValue();
		if (constantValue != null) {
			result.setConstant(true);
			result.setConstantValue(constantValue);
		} else {
			result.setConstant(false);
		}
	} else
		result = TypesFactory.eINSTANCE.createJvmEnumerationLiteral();
	String name = field.getName();
	result.internalSetIdentifier(typeName.append(name).toString());
	result.setSimpleName(name);
	int modifiers = field.getModifiers();
	result.setFinal(Modifier.isFinal(modifiers));
	result.setStatic(Modifier.isStatic(modifiers));
	result.setTransient(Modifier.isTransient(modifiers));
	result.setVolatile(Modifier.isVolatile(modifiers));
	result.setDeprecated(field.isDeprecated());
	setVisibility(result, modifiers);
	result.setType(createTypeReference(field.getType()));
	createAnnotationValues(field, result);
	return result;
}