import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
	if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
		// e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation ...
		return false;
	}
	if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
			|| locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
			|| locationInParent == ReturnStatement.EXPRESSION_PROPERTY
			|| locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
			|| locationInParent == ForStatement.EXPRESSION_PROPERTY
			|| locationInParent == WhileStatement.EXPRESSION_PROPERTY
			|| locationInParent == DoStatement.EXPRESSION_PROPERTY
			|| locationInParent == AssertStatement.EXPRESSION_PROPERTY
			|| locationInParent == AssertStatement.MESSAGE_PROPERTY
			|| locationInParent == IfStatement.EXPRESSION_PROPERTY
			|| locationInParent == SwitchStatement.EXPRESSION_PROPERTY
			|| locationInParent == SwitchCase.EXPRESSION_PROPERTY
			|| locationInParent == ArrayAccess.INDEX_PROPERTY
			|| locationInParent == ThrowStatement.EXPRESSION_PROPERTY
			|| locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY
			|| locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
		return false;
	}
	return true;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private static Set<EnhancedForStatement> getEnhancedForStatements(IMethod method, IProgressMonitor pm)
		throws JavaModelException {
	ICompilationUnit iCompilationUnit = method.getCompilationUnit();

	// get the ASTParser of the method
	CompilationUnit compilationUnit = RefactoringASTParser.parseWithASTProvider(iCompilationUnit, true,
			new SubProgressMonitor(pm, 1));

	// get the method declaration ASTNode.
	MethodDeclaration methodDeclarationNode = ASTNodeSearchUtil.getMethodDeclarationNode(method, compilationUnit);

	final Set<EnhancedForStatement> statements = new LinkedHashSet<EnhancedForStatement>();
	// extract all enhanced for loop statements in the method.
	methodDeclarationNode.accept(new ASTVisitor() {

		@Override
		public boolean visit(EnhancedForStatement node) {
			statements.add(node);
			return super.visit(node);
		}
	});

	return statements;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@Override
public void endVisit(EnhancedForStatement node) {
	if (skipNode(node)) {
		return;
	}
	FlowInfo paramInfo = getFlowInfo(node.getParameter());
	FlowInfo expressionInfo = getFlowInfo(node.getExpression());
	FlowInfo actionInfo = getFlowInfo(node.getBody());
	EnhancedForFlowInfo forInfo = createEnhancedFor();
	setFlowInfo(node, forInfo);
	// If the for statement is the outermost loop then we only have to consider
	// the action. The parameter and expression are only evaluated once.
	if (node == fLoopNode) {
		forInfo.mergeAction(actionInfo, fFlowContext);
	} else {
		// Inner for loops are evaluated in the sequence expression, parameter,
		// action.
		forInfo.mergeExpression(expressionInfo, fFlowContext);
		forInfo.mergeParameter(paramInfo, fFlowContext);
		forInfo.mergeAction(actionInfo, fFlowContext);
	}
	forInfo.removeLabel(null);
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private Statement getParentLoopBody(ASTNode node) {
	Statement stmt = null;
	ASTNode start = node;
	while (start != null && !(start instanceof ForStatement) && !(start instanceof DoStatement) && !(start instanceof WhileStatement) && !(start instanceof EnhancedForStatement) && !(start instanceof SwitchStatement)) {
		start = start.getParent();
	}
	if (start instanceof ForStatement) {
		stmt = ((ForStatement) start).getBody();
	} else if (start instanceof DoStatement) {
		stmt = ((DoStatement) start).getBody();
	} else if (start instanceof WhileStatement) {
		stmt = ((WhileStatement) start).getBody();
	} else if (start instanceof EnhancedForStatement) {
		stmt = ((EnhancedForStatement) start).getBody();
	}
	if (start != null && start.getParent() instanceof LabeledStatement) {
		LabeledStatement labeledStatement = (LabeledStatement) start.getParent();
		fEnclosingLoopLabel = labeledStatement.getLabel();
	}
	return stmt;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private static void addEnhancedForWithoutTypeProposals(ICompilationUnit cu, ASTNode selectedNode,
		Collection<CUCorrectionProposal> proposals) {
	if (selectedNode instanceof SimpleName && (selectedNode.getLocationInParent() == SimpleType.NAME_PROPERTY || selectedNode.getLocationInParent() == NameQualifiedType.NAME_PROPERTY)) {
		ASTNode type= selectedNode.getParent();
		if (type.getLocationInParent() == SingleVariableDeclaration.TYPE_PROPERTY) {
			SingleVariableDeclaration svd= (SingleVariableDeclaration) type.getParent();
			if (svd.getLocationInParent() == EnhancedForStatement.PARAMETER_PROPERTY) {
				if (svd.getName().getLength() == 0) {
					SimpleName simpleName= (SimpleName) selectedNode;
					String name= simpleName.getIdentifier();
					int relevance= StubUtility.hasLocalVariableName(cu.getJavaProject(), name) ? 10 : 7;
					String label= Messages.format(CorrectionMessages.UnresolvedElementsSubProcessor_create_loop_variable_description, BasicElementLabels.getJavaElementName(name));

					proposals.add(new NewVariableCorrectionProposal(label, cu, NewVariableCorrectionProposal.LOCAL,
							simpleName, null, relevance));
				}
			}
		}
	}
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
  if (locationInParent instanceof ChildListPropertyDescriptor
      && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
    // e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation
    // ...
    return false;
  }
  if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
      || locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
      || locationInParent == ReturnStatement.EXPRESSION_PROPERTY
      || locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
      || locationInParent == ForStatement.EXPRESSION_PROPERTY
      || locationInParent == WhileStatement.EXPRESSION_PROPERTY
      || locationInParent == DoStatement.EXPRESSION_PROPERTY
      || locationInParent == AssertStatement.EXPRESSION_PROPERTY
      || locationInParent == AssertStatement.MESSAGE_PROPERTY
      || locationInParent == IfStatement.EXPRESSION_PROPERTY
      || locationInParent == SwitchStatement.EXPRESSION_PROPERTY
      || locationInParent == SwitchCase.EXPRESSION_PROPERTY
      || locationInParent == ArrayAccess.INDEX_PROPERTY
      || locationInParent == ThrowStatement.EXPRESSION_PROPERTY
      || locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY
      || locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
    return false;
  }
  return true;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@Override
public void endVisit(EnhancedForStatement node) {
  if (skipNode(node)) return;
  FlowInfo paramInfo = getFlowInfo(node.getParameter());
  FlowInfo expressionInfo = getFlowInfo(node.getExpression());
  FlowInfo actionInfo = getFlowInfo(node.getBody());
  EnhancedForFlowInfo forInfo = createEnhancedFor();
  setFlowInfo(node, forInfo);
  // If the for statement is the outermost loop then we only have to consider
  // the action. The parameter and expression are only evaluated once.
  if (node == fLoopNode) {
    forInfo.mergeAction(actionInfo, fFlowContext);
  } else {
    // Inner for loops are evaluated in the sequence expression, parameter,
    // action.
    forInfo.mergeExpression(expressionInfo, fFlowContext);
    forInfo.mergeParameter(paramInfo, fFlowContext);
    forInfo.mergeAction(actionInfo, fFlowContext);
  }
  forInfo.removeLabel(null);
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private Statement getParentLoopBody(ASTNode node) {
  Statement stmt = null;
  ASTNode start = node;
  while (start != null
      && !(start instanceof ForStatement)
      && !(start instanceof DoStatement)
      && !(start instanceof WhileStatement)
      && !(start instanceof EnhancedForStatement)
      && !(start instanceof SwitchStatement)) {
    start = start.getParent();
  }
  if (start instanceof ForStatement) {
    stmt = ((ForStatement) start).getBody();
  } else if (start instanceof DoStatement) {
    stmt = ((DoStatement) start).getBody();
  } else if (start instanceof WhileStatement) {
    stmt = ((WhileStatement) start).getBody();
  } else if (start instanceof EnhancedForStatement) {
    stmt = ((EnhancedForStatement) start).getBody();
  }
  if (start != null && start.getParent() instanceof LabeledStatement) {
    LabeledStatement labeledStatement = (LabeledStatement) start.getParent();
    fEnclosingLoopLabel = labeledStatement.getLabel();
  }
  return stmt;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@Override
public RefactoringStatus checkFinalConditions(IProgressMonitor pm)
		throws CoreException, OperationCanceledException {
	try {
		final RefactoringStatus status = new RefactoringStatus();
		for (IMethod method : methods) {
			Set<EnhancedForStatement> statements = getEnhancedForStatements(method, new SubProgressMonitor(pm, 1));

			IProgressMonitor subMonitor = new SubProgressMonitor(pm, statements.size());

			// check preconditions on each.
			statements.stream().forEach(s -> status.merge(checkEnhancedForStatement(s, method, subMonitor)));
			pm.worked(1);
		}
		return status;
	} finally {
		pm.done();
	}
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@Override
public boolean preNext(Statement curElement) {
	switch (curElement.getNodeType()) {
	case ASTNode.WHILE_STATEMENT:
		exportWhile((WhileStatement) curElement);
		break;
	case ASTNode.FOR_STATEMENT:
		exportFor((ForStatement) curElement);
		break;
	case ASTNode.ENHANCED_FOR_STATEMENT:
		exportForEach((EnhancedForStatement) curElement);
		break;
	case ASTNode.DO_STATEMENT:
		exportDoWhileStatement((DoStatement) curElement);
		break;
	}

	return true;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@Override
public void endVisit(EnhancedForStatement node) {
	if (skipNode(node))
		return;
	FlowInfo paramInfo= getFlowInfo(node.getParameter());
	FlowInfo expressionInfo= getFlowInfo(node.getExpression());
	FlowInfo actionInfo= getFlowInfo(node.getBody());
	EnhancedForFlowInfo forInfo= createEnhancedFor();
	setFlowInfo(node, forInfo);
	// If the for statement is the outermost loop then we only have to consider
	// the action. The parameter and expression are only evaluated once.
	if (node == fLoopNode) {
		forInfo.mergeAction(actionInfo, fFlowContext);
	} else {
		// Inner for loops are evaluated in the sequence expression, parameter,
		// action.
		forInfo.mergeExpression(expressionInfo, fFlowContext);
		forInfo.mergeParameter(paramInfo, fFlowContext);
		forInfo.mergeAction(actionInfo, fFlowContext);
	}
	forInfo.removeLabel(null);
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private Statement getParentLoopBody(ASTNode node) {
	Statement stmt= null;
	ASTNode start= node;
	while (start != null
			&& !(start instanceof ForStatement)
			&& !(start instanceof DoStatement)
			&& !(start instanceof WhileStatement)
			&& !(start instanceof EnhancedForStatement)
			&& !(start instanceof SwitchStatement)) {
		start= start.getParent();
	}
	if (start instanceof ForStatement) {
		stmt= ((ForStatement)start).getBody();
	} else if (start instanceof DoStatement) {
		stmt= ((DoStatement)start).getBody();
	} else if (start instanceof WhileStatement) {
		stmt= ((WhileStatement)start).getBody();
	} else if (start instanceof EnhancedForStatement) {
		stmt= ((EnhancedForStatement)start).getBody();
	}
	if (start != null && start.getParent() instanceof LabeledStatement) {
		LabeledStatement labeledStatement= (LabeledStatement)start.getParent();
		fEnclosingLoopLabel= labeledStatement.getLabel();
	}
	return stmt;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private static void addEnhancedForWithoutTypeProposals(ICompilationUnit cu, ASTNode selectedNode, Collection<ICommandAccess> proposals) {
	if (selectedNode instanceof SimpleName && (selectedNode.getLocationInParent() == SimpleType.NAME_PROPERTY || selectedNode.getLocationInParent() == NameQualifiedType.NAME_PROPERTY)) {
		ASTNode type= selectedNode.getParent();
		if (type.getLocationInParent() == SingleVariableDeclaration.TYPE_PROPERTY) {
			SingleVariableDeclaration svd= (SingleVariableDeclaration) type.getParent();
			if (svd.getLocationInParent() == EnhancedForStatement.PARAMETER_PROPERTY) {
				if (svd.getName().getLength() == 0) {
					SimpleName simpleName= (SimpleName) selectedNode;
					String name= simpleName.getIdentifier();
					int relevance= StubUtility.hasLocalVariableName(cu.getJavaProject(), name) ? 10 : 7;
					String label= Messages.format(CorrectionMessages.UnresolvedElementsSubProcessor_create_loop_variable_description, BasicElementLabels.getJavaElementName(name));
					Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_LOCAL);
					
					proposals.add(new NewVariableCorrectionProposal(label, cu, NewVariableCorrectionProposal.LOCAL, simpleName, null, relevance, image));
				}
			}
		}
	}
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private static boolean isLastStatementInEnclosingMethodOrLambda(Statement statement) {
	ASTNode currentStructure= statement;
	ASTNode currentParent= statement.getParent();
	while (!(currentParent instanceof MethodDeclaration || currentParent instanceof LambdaExpression)) {
		// should not be in a loop
		if (currentParent instanceof ForStatement || currentParent instanceof EnhancedForStatement
				|| currentParent instanceof WhileStatement || currentParent instanceof DoStatement) {
			return false;
		}
		if (currentParent instanceof Block) {
			Block parentBlock= (Block) currentParent;
			if (parentBlock.statements().indexOf(currentStructure) != parentBlock.statements().size() - 1) { // not last statement in the block
				return false;
			}
		}
		currentStructure= currentParent;
		currentParent= currentParent.getParent();
	}
	return true;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
/**
 * 'for(' parameter ':' expression ') {' body '}'
 */
@Override
public boolean visit(final EnhancedForStatement node)
{
  final int lineNo = lineStart(node);
  // new dependence
  final IResolvedLine rd = createDependence(LK_ENHANCED_FOR, lineNo, mdg.parent());
  // add this definition
  rd.definitions().add(
      factory.resolveExpression(node.getParameter().getName(), node, null, false, true));
  // collect uses for this control predicate
  appendDependences(rd, node.getExpression(), null, false);
  // recursively append dependences
  appendRecursive(lineNo, rd, node.getBody());
  // do not visit children
  return false;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@Override
protected void repairBug(ASTRewrite rewrite, CompilationUnit workingUnit, BugInstance bug) throws BugResolutionException {
    ASTNode node = getASTNode(workingUnit, bug.getPrimarySourceLineAnnotation());
    this.typeSource = ImportRewrite.create(workingUnit, true); // these imports won't get added automatically
    this.rewrite = rewrite;
    this.ast = rewrite.getAST();
    EntrySetResolutionVisitor visitor = new EntrySetResolutionVisitor();
    node.accept(visitor);

    EnhancedForStatement replacement = makeReplacementForLoop(visitor);

    rewrite.replace(visitor.ancestorForLoop, replacement, null);

    addImports(rewrite, workingUnit, ImportUtil.filterOutJavaLangImports(typeSource.getAddedImports()));
    addImports(rewrite, workingUnit, "java.util.Map"); // shouldn't be necessary. Allows us to use Map.entry
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private EnhancedForStatement makeReplacementForLoop(EntrySetResolutionVisitor visitor) {
    // this would be map.keySet().
    // We need this to get the type of map and get the variable name of map
    MethodInvocation oldLoopExpression = (MethodInvocation) visitor.ancestorForLoop.getExpression();

    // for(Parameter : Expression)
    EnhancedForStatement replacement = ast.newEnhancedForStatement();
    replacement.setParameter(makeEntrySetParameter(oldLoopExpression));
    replacement.setExpression(makeCallToEntrySet(oldLoopExpression));

    List<Statement> replacementBlockStatements = ((Block) replacement.getBody()).statements();
    // create new statement to replace the key object (e.g. the String s that used to be in the for each)
    replacementBlockStatements.add(makeNewKeyStatement(visitor));
    // replace the call to map.get() with a call to entry.getValue()
    replacementBlockStatements.add(makeNewValueStatement(visitor));
    // transfer the rest of the statements in the old block
    copyRestOfBlock(replacementBlockStatements, visitor);
    return replacement;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
@Override
public boolean visit(MethodInvocation node) {
    if (ancestorForLoop != null) {
        return false;
    }
    if (!"get".equals(node.getName().getIdentifier())) {
        return true; // there may be a nested method invocation
    }
    valueTypeName = node.resolveTypeBinding().getName(); // for description message
    this.ancestorForLoop = TraversalUtil.findClosestAncestor(node, EnhancedForStatement.class);
    this.badMapGetStatement = TraversalUtil.findClosestAncestor(node, Statement.class);
    // if this is null, it was an anonymous use
    this.badMapGetVariableFragment = TraversalUtil.findClosestAncestor(node, VariableDeclarationFragment.class);

    if (badMapGetVariableFragment == null) {
        this.badMapGetMethodInvocation = node; // this is an anonymous usage, and will need to be replaced
    }
    return false;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
private boolean isLoopStatement(Block block) {
	ASTNode parent = block.getParent();
	return
			parent instanceof WhileStatement ||
			parent instanceof ForStatement ||
			parent instanceof DoStatement ||
			parent instanceof EnhancedForStatement ||
			parent instanceof IfStatement;
}
 

import org.eclipse.jdt.core.dom.EnhancedForStatement; //导入依赖的package包/类
/**
 * Returns true if a node at a given location is a body of a control statement. Such body nodes are
 * interesting as when replacing them, it has to be evaluates if a Block is needed instead.
 * E.g. <code> if (x) do(); -> if (x) { do1(); do2() } </code>
 *
 * @param locationInParent Location of the body node
 * @return Returns true if the location is a body node location of a control statement.
 */
public static boolean isControlStatementBody(StructuralPropertyDescriptor locationInParent) {
	return locationInParent == IfStatement.THEN_STATEMENT_PROPERTY
			|| locationInParent == IfStatement.ELSE_STATEMENT_PROPERTY
			|| locationInParent == ForStatement.BODY_PROPERTY
			|| locationInParent == EnhancedForStatement.BODY_PROPERTY
			|| locationInParent == WhileStatement.BODY_PROPERTY
			|| locationInParent == DoStatement.BODY_PROPERTY;
}