org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/AtomicObjectCleanUp.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2020 Fabrice TIERCELIN and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Fabrice TIERCELIN - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.ui.fix;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;

 import org.eclipse.core.runtime.CoreException;

 import org.eclipse.text.edits.TextEditGroup;

 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ASTVisitor;
 import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
 import org.eclipse.jdt.core.dom.ArrayAccess;
 import org.eclipse.jdt.core.dom.ArrayCreation;
 import org.eclipse.jdt.core.dom.Assignment;
 import org.eclipse.jdt.core.dom.Block;
 import org.eclipse.jdt.core.dom.ClassInstanceCreation;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.ExpressionStatement;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
 import org.eclipse.jdt.core.dom.LambdaExpression;
 import org.eclipse.jdt.core.dom.MethodInvocation;
 import org.eclipse.jdt.core.dom.NullLiteral;
 import org.eclipse.jdt.core.dom.ParameterizedType;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
 import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
 import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
 import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;

 import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
 import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix;
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix.CompilationUnitRewriteOperation;
 import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
 import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
 import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

 import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
 import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
 import org.eclipse.jdt.ui.text.java.IProblemLocation;

 /**
  * A fix that replaces an array with one index by an atomic object.
  */
 public class AtomicObjectCleanUp extends AbstractMultiFix {
 	public AtomicObjectCleanUp() {
 		this(Collections.emptyMap());
 	}

 	public AtomicObjectCleanUp(Map<String, String> options) {
 		super(options);
 	}

 	@Override
 	public CleanUpRequirements getRequirements() {
 		boolean requireAST= isEnabled(CleanUpConstants.ATOMIC_OBJECT);
 		return new CleanUpRequirements(requireAST, false, false, null);
 	}

 	@Override
 	public String[] getStepDescriptions() {
 		if (isEnabled(CleanUpConstants.ATOMIC_OBJECT)) {
 			return new String[] { MultiFixMessages.CodeStyleCleanUp_AtomicObject_description };
 		}

 		return new String[0];
 	}

 	@Override
 	public String getPreview() {
 		if (isEnabled(CleanUpConstants.ATOMIC_OBJECT)) {
 			return "AtomicBoolean booleanRef= new AtomicBoolean();\n" //$NON-NLS-1$
 					+ "Runnable runnable = () -> booleanRef.set(true);\n" //$NON-NLS-1$
 					+ "runnable.run();\n" //$NON-NLS-1$
 					+ "boolean b = booleanRef.get();\n"; //$NON-NLS-1$
 		}

 		return "boolean[] booleanRef= new boolean[1];\n" //$NON-NLS-1$
 				+ "Runnable runnable = () -> booleanRef[0] = true;\n" //$NON-NLS-1$
 				+ "runnable.run();\n" //$NON-NLS-1$
 				+ "boolean b = booleanRef[0];\n"; //$NON-NLS-1$
 	}

 	@Override
 	protected ICleanUpFix createFix(CompilationUnit unit) throws CoreException {
 		if (!isEnabled(CleanUpConstants.ATOMIC_OBJECT) || !JavaModelUtil.is50OrHigher(unit.getJavaElement().getJavaProject())) {
 			return null;
 		}

 		final List<CompilationUnitRewriteOperation> rewriteOperations= new ArrayList<>();

 		unit.accept(new ASTVisitor() {
 			@Override
 			public boolean visit(final Block node) {
 				ArrayOccurrencesVisitor arrayOccurrencesVisitor= new ArrayOccurrencesVisitor(node);
 				node.accept(arrayOccurrencesVisitor);
 				return arrayOccurrencesVisitor.result;
 			}

 			final class ArrayOccurrencesVisitor extends ASTVisitor {
 				private final Block startNode;
 				private boolean result= true;

 				public ArrayOccurrencesVisitor(final Block startNode) {
 					this.startNode= startNode;
 				}

 				@Override
 				public boolean visit(final Block node) {
 					return startNode == node;
 				}

 				@Override
 				public boolean visit(final VariableDeclarationStatement node) {
 					if (node.fragments().size() != 1) {
 						return true;
 					}

 					VariableDeclarationFragment fragment= (VariableDeclarationFragment) node.fragments().get(0);
 					return visitVariable(node.getType(), fragment.resolveBinding(), fragment.extraDimensions(), fragment.getName(), fragment.getInitializer());
 				}

 				@Override
 				public boolean visit(final VariableDeclarationExpression node) {
 					if (node.fragments().size() != 1) {
 						return true;
 					}

 					VariableDeclarationFragment fragment= (VariableDeclarationFragment) node.fragments().get(0);
 					return visitVariable(node.getType(), fragment.resolveBinding(), fragment.extraDimensions(), fragment.getName(), fragment.getInitializer());
 				}

 				@Override
 				public boolean visit(final SingleVariableDeclaration node) {
 					return visitVariable(node.getType(), node.resolveBinding(), node.extraDimensions(), node.getName(), node.getInitializer());
 				}

 				private boolean visitVariable(final Type type, final IVariableBinding variableBinding, final List<?> variableDimensions, final SimpleName declaration, final Expression initializer) {
 					ArrayCreation arrayCreation= ASTNodes.as(initializer, ArrayCreation.class);

 					if (result
 							&& arrayCreation != null
 							&& (arrayCreation.getInitializer() != null
 									? arrayCreation.getInitializer().expressions().size() == 1
 									: arrayCreation.dimensions().size() == 1 && Long.valueOf(1L).equals(ASTNodes.getIntegerLiteral((Expression) arrayCreation.dimensions().get(0))))
 							&& type != null
 							&& type.resolveBinding() != null
 							&& (type.resolveBinding().isArray()
 									? variableDimensions.isEmpty() && type.resolveBinding().getDimensions() == 1 && equalNotNull(type.resolveBinding().getElementType(), arrayCreation.getType().getElementType().resolveBinding())
 											: variableDimensions.size() == 1 && equalNotNull(type.resolveBinding(), arrayCreation.getType().getElementType().resolveBinding()))
 							&& !ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(),
 									double.class.getCanonicalName(),
 									float.class.getCanonicalName(),
 									short.class.getCanonicalName(),
 									char.class.getCanonicalName(),
 									byte.class.getCanonicalName())) {
 						VarDefinitionsUsesVisitor varOccurrencesVisitor= new VarDefinitionsUsesVisitor(variableBinding,
 						startNode, true);

 						List<SimpleName> reads= varOccurrencesVisitor.getReads();
 						List<SimpleName> writes= varOccurrencesVisitor.getWrites();
 						writes.remove(declaration);

 						if (writes.isEmpty()) {
 							Set<Assignment> assignmentReads= new HashSet<>();
 							Set<ArrayAccess> accessReads= new HashSet<>();

 							for (SimpleName simpleName : reads) {
 								if (!isReadValid(simpleName, assignmentReads, accessReads)) {
 									return true;
 								}
 							}

 							boolean hasOneWriteInDynamicCode= false;

 							for (Assignment assignmentRead : assignmentReads) {
 								ASTNode dynamicCode= ASTNodes.getFirstAncestorOrNull(assignmentRead, LambdaExpression.class, AnonymousClassDeclaration.class);

 								if (dynamicCode != null && ASTNodes.isParent(dynamicCode, startNode)) {
 									hasOneWriteInDynamicCode= true;
 									break;
 								}
 							}

 							if (hasOneWriteInDynamicCode) {
 								rewriteOperations.add(new AtomicObjectOperation(type, variableDimensions, arrayCreation, assignmentReads, accessReads));

 								result= false;
 								return false;
 							}
 						}
 					}

 					return true;
 				}

 				private boolean equalNotNull(ITypeBinding elementType, ITypeBinding resolveBinding) {
 					return elementType != null && Objects.equals(elementType, resolveBinding);
 				}

 				private boolean isReadValid(final SimpleName simpleName, final Set<Assignment> assignmentReads, final Set<ArrayAccess> accessReads) {
 					if (simpleName.getParent() instanceof ArrayAccess
 							&& simpleName.getLocationInParent() == ArrayAccess.ARRAY_PROPERTY) {
 						ArrayAccess arrayAccess= (ArrayAccess) simpleName.getParent();

 						if (Long.valueOf(0L).equals(ASTNodes.getIntegerLiteral(arrayAccess.getIndex()))) {
 							if (arrayAccess.getParent() instanceof Assignment
 									&& arrayAccess.getLocationInParent() == Assignment.LEFT_HAND_SIDE_PROPERTY) {
 								Assignment assignment= (Assignment) arrayAccess.getParent();

 								if (ASTNodes.hasOperator(assignment, Assignment.Operator.ASSIGN)
 										&& (assignment.getParent() instanceof ExpressionStatement
 										|| assignment.getParent() instanceof LambdaExpression && assignment.getLocationInParent() == LambdaExpression.BODY_PROPERTY)) {
 									assignmentReads.add(assignment);
 									return true;
 								}
 							} else if ((!(arrayAccess.getParent() instanceof PrefixExpression)
 									|| !ASTNodes.hasOperator((PrefixExpression) arrayAccess.getParent(), PrefixExpression.Operator.INCREMENT, PrefixExpression.Operator.DECREMENT))
 									&& (!(arrayAccess.getParent() instanceof PostfixExpression)
 											|| !ASTNodes.hasOperator((PostfixExpression) arrayAccess.getParent(), PostfixExpression.Operator.INCREMENT, PostfixExpression.Operator.DECREMENT))) {
 								accessReads.add(arrayAccess);
 								return true;
 							}
 						}
 					}

 					return false;
 				}
 			}
 		});

 		if (rewriteOperations.isEmpty()) {
 			return null;
 		}

 		return new CompilationUnitRewriteOperationsFix(MultiFixMessages.CodeStyleCleanUp_AtomicObject_description, unit,
 				rewriteOperations.toArray(new CompilationUnitRewriteOperation[0]));
 	}

 	@Override
 	public boolean canFix(final ICompilationUnit compilationUnit, final IProblemLocation problem) {
 		return false;
 	}

 	@Override
 	protected ICleanUpFix createFix(final CompilationUnit unit, final IProblemLocation[] problems) throws CoreException {
 		return null;
 	}

 	private static class AtomicObjectOperation extends CompilationUnitRewriteOperation {
 		private final Type type;
 		private final List<?> variableDimensions;
 		private final ArrayCreation arrayCreation;
 		private final Set<Assignment> assignmentReads;
 		private final Set<ArrayAccess> accessReads;

 		public AtomicObjectOperation(final Type type, final List<?> variableDimensions, final ArrayCreation arrayCreation, final Set<Assignment> assignmentReads, final Set<ArrayAccess> accessReads) {
 			this.type= type;
 			this.variableDimensions= variableDimensions;
 			this.arrayCreation= arrayCreation;
 			this.assignmentReads= assignmentReads;
 			this.accessReads= accessReads;
 		}

 		@Override
 		public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModel linkedModel) throws CoreException {
 			ASTRewrite rewrite= cuRewrite.getASTRewrite();
 			AST ast= cuRewrite.getRoot().getAST();
 			ImportRewrite importRewrite= cuRewrite.getImportRewrite();
 			TextEditGroup groupdeclaration= createTextEditGroup(MultiFixMessages.CodeStyleCleanUp_AtomicObject_declaration, cuRewrite);

 			Class<?> atomicClass;
 			Type objectClass= null;
 			if (ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(), boolean.class.getCanonicalName())) {
 				atomicClass= AtomicBoolean.class;
 			} else if (ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(), int.class.getCanonicalName())) {
 				atomicClass= AtomicInteger.class;
 			} else if (ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(), long.class.getCanonicalName())) {
 				atomicClass= AtomicLong.class;
 			} else {
 				atomicClass= AtomicReference.class;
 				objectClass= arrayCreation.getType().getElementType();
 			}

 			String atomicClassNameText= importRewrite.addImport(atomicClass.getCanonicalName());
 			Type atomicInstance= ast.newSimpleType(ASTNodeFactory.newName(ast, atomicClassNameText));

 			if (objectClass != null) {
 				ParameterizedType newParameterizedType= ast.newParameterizedType(atomicInstance);

 				if (!JavaModelUtil.is1d7OrHigher(((CompilationUnit) type.getRoot()).getJavaElement().getJavaProject())) {
 					newParameterizedType.typeArguments().add(rewrite.createCopyTarget(objectClass));
 				}

 				atomicInstance= newParameterizedType;
 			}

 			ClassInstanceCreation newAtomicObject= ast.newClassInstanceCreation();
 			newAtomicObject.setType(atomicInstance);

 			if (arrayCreation.getInitializer() != null
 					&& !ASTNodes.is((Expression) arrayCreation.getInitializer().expressions().get(0), NullLiteral.class)) {
 				List<Expression> arguments= newAtomicObject.arguments();
 				arguments.add(ASTNodes.createMoveTarget(rewrite, (Expression) arrayCreation.getInitializer().expressions().get(0)));
 			}

 			ASTNodes.replaceButKeepComment(rewrite, arrayCreation, newAtomicObject, groupdeclaration);

 			for (Object variableDimension : variableDimensions) {
 				rewrite.remove((ASTNode) variableDimension, groupdeclaration);
 			}

 			Type atomicType= ast.newSimpleType(ASTNodeFactory.newName(ast, atomicClassNameText));

 			if (objectClass != null) {
 				ParameterizedType newParameterizedType= ast.newParameterizedType(atomicType);
 				newParameterizedType.typeArguments().add(rewrite.createCopyTarget(objectClass));
 				atomicInstance= newParameterizedType;
 			}

 			ASTNodes.replaceButKeepComment(rewrite, type, atomicInstance, groupdeclaration);

 			int i=1;
 			for (ArrayAccess accessRead : accessReads) {
 				MethodInvocation newMethodInvocation= ast.newMethodInvocation();
 				newMethodInvocation.setExpression(ASTNodes.createMoveTarget(rewrite, accessRead.getArray()));
 				newMethodInvocation.setName(ast.newSimpleName("get")); //$NON-NLS-1$
 				TextEditGroup groupusage= createTextEditGroup(MultiFixMessages.CodeStyleCleanUp_AtomicObject_usage+" "+Integer.toString(i++), cuRewrite); //$NON-NLS-1$
 				ASTNodes.replaceButKeepComment(rewrite, accessRead, newMethodInvocation, groupusage);
 			}

 			for (Assignment assignmentRead : assignmentReads) {
 				MethodInvocation newMethodInvocation= ast.newMethodInvocation();
 				newMethodInvocation.setExpression(ASTNodes.createMoveTarget(rewrite, ((ArrayAccess) assignmentRead.getLeftHandSide()).getArray()));
 				newMethodInvocation.setName(ast.newSimpleName("set")); //$NON-NLS-1$
 				newMethodInvocation.arguments().add(ASTNodes.createMoveTarget(rewrite, assignmentRead.getRightHandSide()));
 				TextEditGroup groupusage= createTextEditGroup(MultiFixMessages.CodeStyleCleanUp_AtomicObject_usage+" "+Integer.toString(i++), cuRewrite); //$NON-NLS-1$
 				ASTNodes.replaceButKeepComment(rewrite, assignmentRead, newMethodInvocation, groupusage);
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2020 Fabrice TIERCELIN and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Fabrice TIERCELIN - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.ui.fix;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Objects;
	import java.util.Set;
	import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.concurrent.atomic.AtomicInteger;
	import java.util.concurrent.atomic.AtomicLong;
	import java.util.concurrent.atomic.AtomicReference;

	import org.eclipse.core.runtime.CoreException;

	import org.eclipse.text.edits.TextEditGroup;

	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.dom.AST;
	import org.eclipse.jdt.core.dom.ASTNode;
	import org.eclipse.jdt.core.dom.ASTVisitor;
	import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
	import org.eclipse.jdt.core.dom.ArrayAccess;
	import org.eclipse.jdt.core.dom.ArrayCreation;
	import org.eclipse.jdt.core.dom.Assignment;
	import org.eclipse.jdt.core.dom.Block;
	import org.eclipse.jdt.core.dom.ClassInstanceCreation;
	import org.eclipse.jdt.core.dom.CompilationUnit;
	import org.eclipse.jdt.core.dom.Expression;
	import org.eclipse.jdt.core.dom.ExpressionStatement;
	import org.eclipse.jdt.core.dom.ITypeBinding;
	import org.eclipse.jdt.core.dom.IVariableBinding;
	import org.eclipse.jdt.core.dom.LambdaExpression;
	import org.eclipse.jdt.core.dom.MethodInvocation;
	import org.eclipse.jdt.core.dom.NullLiteral;
	import org.eclipse.jdt.core.dom.ParameterizedType;
	import org.eclipse.jdt.core.dom.PostfixExpression;
	import org.eclipse.jdt.core.dom.PrefixExpression;
	import org.eclipse.jdt.core.dom.SimpleName;
	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
	import org.eclipse.jdt.core.dom.Type;
	import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
	import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
	import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
	import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;

	import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
	import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix;
	import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix.CompilationUnitRewriteOperation;
	import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
	import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

	import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
	import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
	import org.eclipse.jdt.ui.text.java.IProblemLocation;

	/**
	* A fix that replaces an array with one index by an atomic object.
	*/
	public class AtomicObjectCleanUp extends AbstractMultiFix {
	public AtomicObjectCleanUp() {
	this(Collections.emptyMap());
	}

	public AtomicObjectCleanUp(Map<String, String> options) {
	super(options);
	}

	@Override
	public CleanUpRequirements getRequirements() {
	boolean requireAST= isEnabled(CleanUpConstants.ATOMIC_OBJECT);
	return new CleanUpRequirements(requireAST, false, false, null);
	}

	@Override
	public String[] getStepDescriptions() {
	if (isEnabled(CleanUpConstants.ATOMIC_OBJECT)) {
	return new String[] { MultiFixMessages.CodeStyleCleanUp_AtomicObject_description };
	}

	return new String[0];
	}

	@Override
	public String getPreview() {
	if (isEnabled(CleanUpConstants.ATOMIC_OBJECT)) {
	return "AtomicBoolean booleanRef= new AtomicBoolean();\n" //$NON-NLS-1$
	+ "Runnable runnable = () -> booleanRef.set(true);\n" //$NON-NLS-1$
	+ "runnable.run();\n" //$NON-NLS-1$
	+ "boolean b = booleanRef.get();\n"; //$NON-NLS-1$
	}

	return "boolean[] booleanRef= new boolean[1];\n" //$NON-NLS-1$
	+ "Runnable runnable = () -> booleanRef[0] = true;\n" //$NON-NLS-1$
	+ "runnable.run();\n" //$NON-NLS-1$
	+ "boolean b = booleanRef[0];\n"; //$NON-NLS-1$
	}

	@Override
	protected ICleanUpFix createFix(CompilationUnit unit) throws CoreException {
	if (!isEnabled(CleanUpConstants.ATOMIC_OBJECT) \|\| !JavaModelUtil.is50OrHigher(unit.getJavaElement().getJavaProject())) {
	return null;
	}

	final List<CompilationUnitRewriteOperation> rewriteOperations= new ArrayList<>();

	unit.accept(new ASTVisitor() {
	@Override
	public boolean visit(final Block node) {
	ArrayOccurrencesVisitor arrayOccurrencesVisitor= new ArrayOccurrencesVisitor(node);
	node.accept(arrayOccurrencesVisitor);
	return arrayOccurrencesVisitor.result;
	}

	final class ArrayOccurrencesVisitor extends ASTVisitor {
	private final Block startNode;
	private boolean result= true;

	public ArrayOccurrencesVisitor(final Block startNode) {
	this.startNode= startNode;
	}

	@Override
	public boolean visit(final Block node) {
	return startNode == node;
	}

	@Override
	public boolean visit(final VariableDeclarationStatement node) {
	if (node.fragments().size() != 1) {
	return true;
	}

	VariableDeclarationFragment fragment= (VariableDeclarationFragment) node.fragments().get(0);
	return visitVariable(node.getType(), fragment.resolveBinding(), fragment.extraDimensions(), fragment.getName(), fragment.getInitializer());
	}

	@Override
	public boolean visit(final VariableDeclarationExpression node) {
	if (node.fragments().size() != 1) {
	return true;
	}

	VariableDeclarationFragment fragment= (VariableDeclarationFragment) node.fragments().get(0);
	return visitVariable(node.getType(), fragment.resolveBinding(), fragment.extraDimensions(), fragment.getName(), fragment.getInitializer());
	}

	@Override
	public boolean visit(final SingleVariableDeclaration node) {
	return visitVariable(node.getType(), node.resolveBinding(), node.extraDimensions(), node.getName(), node.getInitializer());
	}

	private boolean visitVariable(final Type type, final IVariableBinding variableBinding, final List<?> variableDimensions, final SimpleName declaration, final Expression initializer) {
	ArrayCreation arrayCreation= ASTNodes.as(initializer, ArrayCreation.class);

	if (result
	&& arrayCreation != null
	&& (arrayCreation.getInitializer() != null
	? arrayCreation.getInitializer().expressions().size() == 1
	: arrayCreation.dimensions().size() == 1 && Long.valueOf(1L).equals(ASTNodes.getIntegerLiteral((Expression) arrayCreation.dimensions().get(0))))
	&& type != null
	&& type.resolveBinding() != null
	&& (type.resolveBinding().isArray()
	? variableDimensions.isEmpty() && type.resolveBinding().getDimensions() == 1 && equalNotNull(type.resolveBinding().getElementType(), arrayCreation.getType().getElementType().resolveBinding())
	: variableDimensions.size() == 1 && equalNotNull(type.resolveBinding(), arrayCreation.getType().getElementType().resolveBinding()))
	&& !ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(),
	double.class.getCanonicalName(),
	float.class.getCanonicalName(),
	short.class.getCanonicalName(),
	char.class.getCanonicalName(),
	byte.class.getCanonicalName())) {
	VarDefinitionsUsesVisitor varOccurrencesVisitor= new VarDefinitionsUsesVisitor(variableBinding,
	startNode, true);

	List<SimpleName> reads= varOccurrencesVisitor.getReads();
	List<SimpleName> writes= varOccurrencesVisitor.getWrites();
	writes.remove(declaration);

	if (writes.isEmpty()) {
	Set<Assignment> assignmentReads= new HashSet<>();
	Set<ArrayAccess> accessReads= new HashSet<>();

	for (SimpleName simpleName : reads) {
	if (!isReadValid(simpleName, assignmentReads, accessReads)) {
	return true;
	}
	}

	boolean hasOneWriteInDynamicCode= false;

	for (Assignment assignmentRead : assignmentReads) {
	ASTNode dynamicCode= ASTNodes.getFirstAncestorOrNull(assignmentRead, LambdaExpression.class, AnonymousClassDeclaration.class);

	if (dynamicCode != null && ASTNodes.isParent(dynamicCode, startNode)) {
	hasOneWriteInDynamicCode= true;
	break;
	}
	}

	if (hasOneWriteInDynamicCode) {
	rewriteOperations.add(new AtomicObjectOperation(type, variableDimensions, arrayCreation, assignmentReads, accessReads));

	result= false;
	return false;
	}
	}
	}

	return true;
	}

	private boolean equalNotNull(ITypeBinding elementType, ITypeBinding resolveBinding) {
	return elementType != null && Objects.equals(elementType, resolveBinding);
	}

	private boolean isReadValid(final SimpleName simpleName, final Set<Assignment> assignmentReads, final Set<ArrayAccess> accessReads) {
	if (simpleName.getParent() instanceof ArrayAccess
	&& simpleName.getLocationInParent() == ArrayAccess.ARRAY_PROPERTY) {
	ArrayAccess arrayAccess= (ArrayAccess) simpleName.getParent();

	if (Long.valueOf(0L).equals(ASTNodes.getIntegerLiteral(arrayAccess.getIndex()))) {
	if (arrayAccess.getParent() instanceof Assignment
	&& arrayAccess.getLocationInParent() == Assignment.LEFT_HAND_SIDE_PROPERTY) {
	Assignment assignment= (Assignment) arrayAccess.getParent();

	if (ASTNodes.hasOperator(assignment, Assignment.Operator.ASSIGN)
	&& (assignment.getParent() instanceof ExpressionStatement
	\|\| assignment.getParent() instanceof LambdaExpression && assignment.getLocationInParent() == LambdaExpression.BODY_PROPERTY)) {
	assignmentReads.add(assignment);
	return true;
	}
	} else if ((!(arrayAccess.getParent() instanceof PrefixExpression)
	\|\| !ASTNodes.hasOperator((PrefixExpression) arrayAccess.getParent(), PrefixExpression.Operator.INCREMENT, PrefixExpression.Operator.DECREMENT))
	&& (!(arrayAccess.getParent() instanceof PostfixExpression)
	\|\| !ASTNodes.hasOperator((PostfixExpression) arrayAccess.getParent(), PostfixExpression.Operator.INCREMENT, PostfixExpression.Operator.DECREMENT))) {
	accessReads.add(arrayAccess);
	return true;
	}
	}
	}

	return false;
	}
	}
	});

	if (rewriteOperations.isEmpty()) {
	return null;
	}

	return new CompilationUnitRewriteOperationsFix(MultiFixMessages.CodeStyleCleanUp_AtomicObject_description, unit,
	rewriteOperations.toArray(new CompilationUnitRewriteOperation[0]));
	}

	@Override
	public boolean canFix(final ICompilationUnit compilationUnit, final IProblemLocation problem) {
	return false;
	}

	@Override
	protected ICleanUpFix createFix(final CompilationUnit unit, final IProblemLocation[] problems) throws CoreException {
	return null;
	}

	private static class AtomicObjectOperation extends CompilationUnitRewriteOperation {
	private final Type type;
	private final List<?> variableDimensions;
	private final ArrayCreation arrayCreation;
	private final Set<Assignment> assignmentReads;
	private final Set<ArrayAccess> accessReads;

	public AtomicObjectOperation(final Type type, final List<?> variableDimensions, final ArrayCreation arrayCreation, final Set<Assignment> assignmentReads, final Set<ArrayAccess> accessReads) {
	this.type= type;
	this.variableDimensions= variableDimensions;
	this.arrayCreation= arrayCreation;
	this.assignmentReads= assignmentReads;
	this.accessReads= accessReads;
	}

	@Override
	public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModel linkedModel) throws CoreException {
	ASTRewrite rewrite= cuRewrite.getASTRewrite();
	AST ast= cuRewrite.getRoot().getAST();
	ImportRewrite importRewrite= cuRewrite.getImportRewrite();
	TextEditGroup groupdeclaration= createTextEditGroup(MultiFixMessages.CodeStyleCleanUp_AtomicObject_declaration, cuRewrite);

	Class<?> atomicClass;
	Type objectClass= null;
	if (ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(), boolean.class.getCanonicalName())) {
	atomicClass= AtomicBoolean.class;
	} else if (ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(), int.class.getCanonicalName())) {
	atomicClass= AtomicInteger.class;
	} else if (ASTNodes.hasType(arrayCreation.getType().getElementType().resolveBinding(), long.class.getCanonicalName())) {
	atomicClass= AtomicLong.class;
	} else {
	atomicClass= AtomicReference.class;
	objectClass= arrayCreation.getType().getElementType();
	}

	String atomicClassNameText= importRewrite.addImport(atomicClass.getCanonicalName());
	Type atomicInstance= ast.newSimpleType(ASTNodeFactory.newName(ast, atomicClassNameText));

	if (objectClass != null) {
	ParameterizedType newParameterizedType= ast.newParameterizedType(atomicInstance);

	if (!JavaModelUtil.is1d7OrHigher(((CompilationUnit) type.getRoot()).getJavaElement().getJavaProject())) {
	newParameterizedType.typeArguments().add(rewrite.createCopyTarget(objectClass));
	}

	atomicInstance= newParameterizedType;
	}

	ClassInstanceCreation newAtomicObject= ast.newClassInstanceCreation();
	newAtomicObject.setType(atomicInstance);

	if (arrayCreation.getInitializer() != null
	&& !ASTNodes.is((Expression) arrayCreation.getInitializer().expressions().get(0), NullLiteral.class)) {
	List<Expression> arguments= newAtomicObject.arguments();
	arguments.add(ASTNodes.createMoveTarget(rewrite, (Expression) arrayCreation.getInitializer().expressions().get(0)));
	}

	ASTNodes.replaceButKeepComment(rewrite, arrayCreation, newAtomicObject, groupdeclaration);

	for (Object variableDimension : variableDimensions) {
	rewrite.remove((ASTNode) variableDimension, groupdeclaration);
	}

	Type atomicType= ast.newSimpleType(ASTNodeFactory.newName(ast, atomicClassNameText));

	if (objectClass != null) {
	ParameterizedType newParameterizedType= ast.newParameterizedType(atomicType);
	newParameterizedType.typeArguments().add(rewrite.createCopyTarget(objectClass));
	atomicInstance= newParameterizedType;
	}

	ASTNodes.replaceButKeepComment(rewrite, type, atomicInstance, groupdeclaration);

	int i=1;
	for (ArrayAccess accessRead : accessReads) {
	MethodInvocation newMethodInvocation= ast.newMethodInvocation();
	newMethodInvocation.setExpression(ASTNodes.createMoveTarget(rewrite, accessRead.getArray()));
	newMethodInvocation.setName(ast.newSimpleName("get")); //$NON-NLS-1$
	TextEditGroup groupusage= createTextEditGroup(MultiFixMessages.CodeStyleCleanUp_AtomicObject_usage+" "+Integer.toString(i++), cuRewrite); //$NON-NLS-1$
	ASTNodes.replaceButKeepComment(rewrite, accessRead, newMethodInvocation, groupusage);
	}

	for (Assignment assignmentRead : assignmentReads) {
	MethodInvocation newMethodInvocation= ast.newMethodInvocation();
	newMethodInvocation.setExpression(ASTNodes.createMoveTarget(rewrite, ((ArrayAccess) assignmentRead.getLeftHandSide()).getArray()));
	newMethodInvocation.setName(ast.newSimpleName("set")); //$NON-NLS-1$
	newMethodInvocation.arguments().add(ASTNodes.createMoveTarget(rewrite, assignmentRead.getRightHandSide()));
	TextEditGroup groupusage= createTextEditGroup(MultiFixMessages.CodeStyleCleanUp_AtomicObject_usage+" "+Integer.toString(i++), cuRewrite); //$NON-NLS-1$
	ASTNodes.replaceButKeepComment(rewrite, assignmentRead, newMethodInvocation, groupusage);
	}
	}
	}
	}