下面列出了怎么用org.eclipse.jdt.core.dom.Initializer的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
initAST();
if (fTempDeclarationNode == null || fTempDeclarationNode.resolveBinding() == null) {
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.RenameTempRefactoring_must_select_local);
}
if (!Checks.isDeclaredIn(fTempDeclarationNode, MethodDeclaration.class)
&& !Checks.isDeclaredIn(fTempDeclarationNode, Initializer.class)
&& !Checks.isDeclaredIn(fTempDeclarationNode, LambdaExpression.class)) {
if (JavaModelUtil.is18OrHigher(fCu.getJavaProject())) {
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.RenameTempRefactoring_only_in_methods_initializers_and_lambda);
}
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.RenameTempRefactoring_only_in_methods_and_initializers);
}
initNames();
return new RefactoringStatus();
}
private ASTNode getEnclosingBodyNode() throws JavaModelException {
ASTNode node = getSelectedExpression().getAssociatedNode();
// expression must be in a method, lambda or initializer body
// make sure it is not in method or parameter annotation
StructuralPropertyDescriptor location = null;
while (node != null && !(node instanceof BodyDeclaration)) {
location = node.getLocationInParent();
node = node.getParent();
if (node instanceof LambdaExpression) {
break;
}
}
if (location == MethodDeclaration.BODY_PROPERTY || location == Initializer.BODY_PROPERTY || (location == LambdaExpression.BODY_PROPERTY && ((LambdaExpression) node).resolveMethodBinding() != null)) {
return (ASTNode) node.getStructuralProperty(location);
}
return null;
}
private ASTNode getEnclosingBodyNode() throws JavaModelException {
ASTNode node = getSelectedExpression().getAssociatedNode();
// expression must be in a method, lambda or initializer body.
// make sure it is not in method or parameter annotation
StructuralPropertyDescriptor location = null;
while (node != null && !(node instanceof BodyDeclaration)) {
location = node.getLocationInParent();
node = node.getParent();
if (node instanceof LambdaExpression) {
break;
}
}
if (location == MethodDeclaration.BODY_PROPERTY || location == Initializer.BODY_PROPERTY || (location == LambdaExpression.BODY_PROPERTY && ((LambdaExpression) node).resolveMethodBinding() != null)) {
return (ASTNode) node.getStructuralProperty(location);
}
return null;
}
private void initializeDestinations() {
List<ASTNode> result = new ArrayList<>();
BodyDeclaration decl = fAnalyzer.getEnclosingBodyDeclaration();
ASTNode current = ASTResolving.findParentType(decl.getParent());
if (fAnalyzer.isValidDestination(current)) {
result.add(current);
}
if (current != null && (decl instanceof MethodDeclaration || decl instanceof Initializer || decl instanceof FieldDeclaration)) {
ITypeBinding binding = ASTNodes.getEnclosingType(current);
ASTNode next = ASTResolving.findParentType(current.getParent());
while (next != null && binding != null && binding.isNested()) {
if (fAnalyzer.isValidDestination(next)) {
result.add(next);
}
current = next;
binding = ASTNodes.getEnclosingType(current);
next = ASTResolving.findParentType(next.getParent());
}
}
fDestinations = result.toArray(new ASTNode[result.size()]);
fDestination = fDestinations[fDestinationIndex];
}
private static boolean isStaticFieldOrStaticInitializer(BodyDeclaration node) {
if (node instanceof MethodDeclaration || node instanceof AbstractTypeDeclaration) {
return false;
}
int modifiers;
if (node instanceof FieldDeclaration) {
modifiers = ((FieldDeclaration) node).getModifiers();
} else if (node instanceof Initializer) {
modifiers = ((Initializer) node).getModifiers();
} else {
Assert.isTrue(false);
return false;
}
if (!Modifier.isStatic(modifiers)) {
return false;
}
return true;
}
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
initAST();
if (fTempDeclarationNode == null || fTempDeclarationNode.resolveBinding() == null)
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.RenameTempRefactoring_must_select_local);
if (!Checks.isDeclaredIn(fTempDeclarationNode, MethodDeclaration.class)
&& !Checks.isDeclaredIn(fTempDeclarationNode, Initializer.class)
&& !Checks.isDeclaredIn(fTempDeclarationNode, LambdaExpression.class)) {
if (JavaModelUtil.is18OrHigher(fCu.getJavaProject()))
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.RenameTempRefactoring_only_in_methods_initializers_and_lambda);
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.RenameTempRefactoring_only_in_methods_and_initializers);
}
initNames();
return new RefactoringStatus();
}
private void initializeDestinations() {
List<ASTNode> result= new ArrayList<ASTNode>();
BodyDeclaration decl= fAnalyzer.getEnclosingBodyDeclaration();
ASTNode current= ASTResolving.findParentType(decl.getParent());
if (fAnalyzer.isValidDestination(current)) {
result.add(current);
}
if (current != null && (decl instanceof MethodDeclaration || decl instanceof Initializer || decl instanceof FieldDeclaration)) {
ITypeBinding binding= ASTNodes.getEnclosingType(current);
ASTNode next= ASTResolving.findParentType(current.getParent());
while (next != null && binding != null && binding.isNested()) {
if (fAnalyzer.isValidDestination(next)) {
result.add(next);
}
current= next;
binding= ASTNodes.getEnclosingType(current);
next= ASTResolving.findParentType(next.getParent());
}
}
fDestinations= result.toArray(new ASTNode[result.size()]);
fDestination= fDestinations[fDestinationIndex];
}
private static boolean isStaticFieldOrStaticInitializer(BodyDeclaration node) {
if(node instanceof MethodDeclaration || node instanceof AbstractTypeDeclaration)
return false;
int modifiers;
if(node instanceof FieldDeclaration) {
modifiers = ((FieldDeclaration) node).getModifiers();
} else if(node instanceof Initializer) {
modifiers = ((Initializer) node).getModifiers();
} else {
Assert.isTrue(false);
return false;
}
if(!Modifier.isStatic(modifiers))
return false;
return true;
}
/**
* Fix for {@link IProblem#NullableFieldReference}
* @param context context
* @param problem problem to be fixed
* @param proposals accumulator for computed proposals
*/
public static void addExtractCheckedLocalProposal(IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
CompilationUnit compilationUnit = context.getASTRoot();
ICompilationUnit cu= (ICompilationUnit) compilationUnit.getJavaElement();
ASTNode selectedNode= problem.getCoveringNode(compilationUnit);
SimpleName name= findProblemFieldName(selectedNode, problem.getProblemId());
if (name == null)
return;
ASTNode method= ASTNodes.getParent(selectedNode, MethodDeclaration.class);
if (method == null)
method= ASTNodes.getParent(selectedNode, Initializer.class);
if (method == null)
return;
proposals.add(new ExtractToNullCheckedLocalProposal(cu, compilationUnit, name, method));
}
public static Initializer getInitializerNode(IInitializer initializer, CompilationUnit cuNode) throws JavaModelException {
ASTNode node= findNode(initializer.getSourceRange(), cuNode);
if (node instanceof Initializer) {
return (Initializer) node;
}
if (node instanceof Block && node.getParent() instanceof Initializer) {
return (Initializer) node.getParent();
}
return null;
}
@Override
public void endVisit(Initializer node) {
if (skipNode(node)) {
return;
}
assignFlowInfo(node, node.getBody());
}
private void computeConstantDeclarationLocation() throws JavaModelException {
if (isDeclarationLocationComputed()) {
return;
}
BodyDeclaration lastStaticDependency = null;
Iterator<BodyDeclaration> decls = getContainingTypeDeclarationNode().bodyDeclarations().iterator();
while (decls.hasNext()) {
BodyDeclaration decl = decls.next();
int modifiers;
if (decl instanceof FieldDeclaration) {
modifiers = ((FieldDeclaration) decl).getModifiers();
} else if (decl instanceof Initializer) {
modifiers = ((Initializer) decl).getModifiers();
} else {
continue; /* this declaration is not a field declaration
or initializer, so the placement of the constant
declaration relative to it does not matter */
}
if (Modifier.isStatic(modifiers) && depends(getSelectedExpression(), decl)) {
lastStaticDependency = decl;
}
}
if (lastStaticDependency == null) {
fInsertFirst = true;
} else {
fToInsertAfter = lastStaticDependency;
}
}
@Override
public boolean preVisit2(ASTNode node) {
if (node instanceof MethodDeclaration || node instanceof Initializer || node instanceof AnnotationTypeMemberDeclaration) {
classes++;
tryStack.push(throw2);
throw2 = 0;
}
return true;
}
@Override
public void endVisit(Initializer node) {
if (maxThrow < throw2)
maxThrow = throw2;
if (minThrow > throw2)
minThrow = throw2;
throw2 = tryStack.pop();
}
@Override
public boolean preVisit2(ASTNode node) {
if (node instanceof MethodDeclaration || node instanceof Initializer || node instanceof AnnotationTypeMemberDeclaration) {
classes++;
tryStack.push(try2);
try2 = 0;
}
return true;
}
@Override
public void endVisit(Initializer node) {
if (maxTry < try2)
maxTry = try2;
if (minTry > try2)
minTry = try2;
try2 = tryStack.pop();
}
@Override
public boolean preVisit2(ASTNode node) {
if (node instanceof MethodDeclaration || node instanceof Initializer
|| node instanceof AnnotationTypeMemberDeclaration) {
classes++;
tryStack.push(locals2);
locals2 = 0;
}
return true;
}
@Override
public void endVisit(Initializer node) {
if (maxLocals < locals2)
maxLocals = locals2;
if (minLocals > locals2)
minLocals = locals2;
locals2 = tryStack.pop();
}
@Override
public boolean preVisit2(ASTNode node) {
if (node instanceof MethodDeclaration || node instanceof Initializer || node instanceof AnnotationTypeMemberDeclaration) {
classes++;
conditionStack.push(condition2);
condition2 = 0;
}
return true;
}
@Override
public void endVisit(Initializer node) {
if (maxFields < condition2)
maxFields = condition2;
if (minFields > condition2)
minFields = condition2;
condition2 = conditionStack.pop();
}
@Override
public boolean visit(Initializer node) {
if (importer.topOfContainerStack() instanceof Type) {
Method method = importer.ensureInitializerMethod();
importer.pushOnContainerStack(method);
importer.createSourceAnchor(method, node);
importer.ensureCommentFromBodyDeclaration(method, node);
}
return true;
}
public static Initializer getInitializerNode(IInitializer initializer, CompilationUnit cuNode) throws JavaModelException {
ASTNode node= findNode(initializer.getSourceRange(), cuNode);
if (node instanceof Initializer)
return (Initializer) node;
if (node instanceof Block && node.getParent() instanceof Initializer)
return (Initializer) node.getParent();
return null;
}
@Override
public void endVisit(Initializer node) {
if (fCurrent.hasInvocations()) {
result.put(node, fCurrent);
}
endVisitBodyDeclaration();
}
private Block getEnclosingBodyNode() throws JavaModelException {
ASTNode node= getSelectedExpression().getAssociatedNode();
// expression must be in a method or initializer body
// make sure it is not in method or parameter annotation
StructuralPropertyDescriptor location= null;
while (node != null && !(node instanceof BodyDeclaration)) {
location= node.getLocationInParent();
node= node.getParent();
}
if (location == MethodDeclaration.BODY_PROPERTY || location == Initializer.BODY_PROPERTY) {
return (Block) node.getStructuralProperty(location);
}
return null;
}
private void computeConstantDeclarationLocation() throws JavaModelException {
if (isDeclarationLocationComputed())
return;
BodyDeclaration lastStaticDependency= null;
Iterator<BodyDeclaration> decls= getContainingTypeDeclarationNode().bodyDeclarations().iterator();
while (decls.hasNext()) {
BodyDeclaration decl= decls.next();
int modifiers;
if (decl instanceof FieldDeclaration)
modifiers= ((FieldDeclaration) decl).getModifiers();
else if (decl instanceof Initializer)
modifiers= ((Initializer) decl).getModifiers();
else {
continue; /* this declaration is not a field declaration
or initializer, so the placement of the constant
declaration relative to it does not matter */
}
if (Modifier.isStatic(modifiers) && depends(getSelectedExpression(), decl))
lastStaticDependency= decl;
}
if(lastStaticDependency == null)
fInsertFirst= true;
else
fToInsertAfter= lastStaticDependency;
}
private boolean addLocalDeclarations(ASTNode node, int offset, int flags, IBindingRequestor requestor) {
if (hasFlag(VARIABLES, flags) || hasFlag(TYPES, flags)) {
BodyDeclaration declaration= ASTResolving.findParentBodyDeclaration(node);
if (declaration instanceof MethodDeclaration || declaration instanceof Initializer || declaration instanceof FieldDeclaration) {
ScopeAnalyzerVisitor visitor= new ScopeAnalyzerVisitor(offset, flags, requestor);
declaration.accept(visitor);
return visitor.fBreak;
}
}
return false;
}
private void handleVariable(SimpleName node, IVariableBinding varbinding) {
if (!varbinding.isField())
return;
if (varbinding.isEnumConstant())
return;
ITypeBinding declaringClass= varbinding.getDeclaringClass();
if (Modifier.isStatic(varbinding.getModifiers())) {
if (fFindUnqualifiedStaticAccesses) {
Initializer initializer= (Initializer) ASTNodes.getParent(node, Initializer.class);
//Do not qualify assignments to static final fields in static initializers (would result in compile error)
StructuralPropertyDescriptor parentDescription= node.getLocationInParent();
if (initializer != null && Modifier.isStatic(initializer.getModifiers())
&& Modifier.isFinal(varbinding.getModifiers()) && parentDescription == Assignment.LEFT_HAND_SIDE_PROPERTY)
return;
//Do not qualify static fields if defined inside an anonymous class
if (declaringClass.isAnonymous())
return;
fResult.add(new AddStaticQualifierOperation(declaringClass, node));
}
} else if (fFindUnqualifiedAccesses){
String qualifier= getThisExpressionQualifier(declaringClass, fImportRewrite, node);
if (qualifier == null)
return;
if (qualifier.length() == 0)
qualifier= null;
fResult.add(new AddThisQualifierOperation(qualifier, node));
}
}
public static boolean isInStaticContext(ASTNode selectedNode) {
BodyDeclaration decl= ASTResolving.findParentBodyDeclaration(selectedNode);
if (decl instanceof MethodDeclaration) {
if (isInsideConstructorInvocation((MethodDeclaration) decl, selectedNode)) {
return true;
}
return Modifier.isStatic(decl.getModifiers());
} else if (decl instanceof Initializer) {
return Modifier.isStatic(((Initializer)decl).getModifiers());
} else if (decl instanceof FieldDeclaration) {
return Modifier.isStatic(((FieldDeclaration)decl).getModifiers());
}
return false;
}
private void convertTypeBody(Type type, List<BodyDeclaration> bodyDeclarations) {
TypeDeclaration currentTypeDeclaration = type.getDeclaration();
propagateCapturesFromSupertype(currentTypeDeclaration);
for (BodyDeclaration bodyDeclaration : bodyDeclarations) {
if (bodyDeclaration instanceof FieldDeclaration) {
FieldDeclaration fieldDeclaration = (FieldDeclaration) bodyDeclaration;
type.addFields(convert(fieldDeclaration));
} else if (bodyDeclaration instanceof MethodDeclaration) {
MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration;
type.addMethod(convert(methodDeclaration));
} else if (bodyDeclaration instanceof AnnotationTypeMemberDeclaration) {
AnnotationTypeMemberDeclaration memberDeclaration =
(AnnotationTypeMemberDeclaration) bodyDeclaration;
type.addMethod(convert(memberDeclaration));
} else if (bodyDeclaration instanceof Initializer) {
Initializer initializer = (Initializer) bodyDeclaration;
Block block = convert(initializer.getBody());
if (JdtUtils.isStatic(initializer)) {
type.addStaticInitializerBlock(block);
} else {
type.addInstanceInitializerBlock(block);
}
} else if (bodyDeclaration instanceof AbstractTypeDeclaration) {
// Nested class
AbstractTypeDeclaration nestedTypeDeclaration = (AbstractTypeDeclaration) bodyDeclaration;
convert(nestedTypeDeclaration);
} else {
throw internalCompilerError(
"Unexpected type for BodyDeclaration: %s, in type: %s",
bodyDeclaration.getClass().getName(), type.getDeclaration().getQualifiedSourceName());
}
}
for (Variable capturedVariable : getCapturedVariables(currentTypeDeclaration)) {
FieldDescriptor fieldDescriptor =
AstUtils.getFieldDescriptorForCapture(type.getTypeDescriptor(), capturedVariable);
type.addField(
Field.Builder.from(fieldDescriptor)
.setCapturedVariable(capturedVariable)
.setSourcePosition(type.getSourcePosition())
.setNameSourcePosition(capturedVariable.getSourcePosition())
.build());
}
if (type.getDeclaration().isCapturingEnclosingInstance()) {
// add field for enclosing instance.
type.addField(
0,
Field.Builder.from(
AstUtils.getFieldDescriptorForEnclosingInstance(
type.getTypeDescriptor(),
type.getEnclosingTypeDeclaration().toUnparameterizedTypeDescriptor()))
.setSourcePosition(type.getSourcePosition())
.build());
}
}
private ASTRewrite doAddField(ASTRewrite rewrite, ASTNode nodeToAssign, ITypeBinding typeBinding, int index) {
boolean isParamToField= nodeToAssign.getNodeType() == ASTNode.SINGLE_VARIABLE_DECLARATION;
ASTNode newTypeDecl= ASTResolving.findParentType(nodeToAssign);
if (newTypeDecl == null) {
return null;
}
Expression expression= isParamToField ? ((SingleVariableDeclaration) nodeToAssign).getName() : ((ExpressionStatement) nodeToAssign).getExpression();
AST ast= newTypeDecl.getAST();
createImportRewrite((CompilationUnit) nodeToAssign.getRoot());
BodyDeclaration bodyDecl= ASTResolving.findParentBodyDeclaration(nodeToAssign);
Block body;
if (bodyDecl instanceof MethodDeclaration) {
body= ((MethodDeclaration) bodyDecl).getBody();
} else if (bodyDecl instanceof Initializer) {
body= ((Initializer) bodyDecl).getBody();
} else {
return null;
}
IJavaProject project= getCompilationUnit().getJavaProject();
boolean isAnonymous= newTypeDecl.getNodeType() == ASTNode.ANONYMOUS_CLASS_DECLARATION;
boolean isStatic= Modifier.isStatic(bodyDecl.getModifiers()) && !isAnonymous;
int modifiers= Modifier.PRIVATE;
if (isStatic) {
modifiers |= Modifier.STATIC;
}
VariableDeclarationFragment newDeclFrag= addFieldDeclaration(rewrite, newTypeDecl, modifiers, expression, nodeToAssign, typeBinding, index);
String varName= newDeclFrag.getName().getIdentifier();
Assignment assignment= ast.newAssignment();
assignment.setRightHandSide((Expression) rewrite.createCopyTarget(expression));
boolean needsThis= StubUtility.useThisForFieldAccess(project);
if (isParamToField) {
needsThis |= varName.equals(((SimpleName) expression).getIdentifier());
}
SimpleName accessName= ast.newSimpleName(varName);
if (needsThis) {
FieldAccess fieldAccess= ast.newFieldAccess();
fieldAccess.setName(accessName);
if (isStatic) {
String typeName= ((AbstractTypeDeclaration) newTypeDecl).getName().getIdentifier();
fieldAccess.setExpression(ast.newSimpleName(typeName));
} else {
fieldAccess.setExpression(ast.newThisExpression());
}
assignment.setLeftHandSide(fieldAccess);
} else {
assignment.setLeftHandSide(accessName);
}
ASTNode selectionNode;
if (isParamToField) {
// assign parameter to field
ExpressionStatement statement= ast.newExpressionStatement(assignment);
int insertIdx= findAssignmentInsertIndex(body.statements(), nodeToAssign) + index;
rewrite.getListRewrite(body, Block.STATEMENTS_PROPERTY).insertAt(statement, insertIdx, null);
selectionNode= statement;
} else {
if (needsSemicolon(expression)) {
rewrite.replace(expression, ast.newExpressionStatement(assignment), null);
} else {
rewrite.replace(expression, assignment, null);
}
selectionNode= nodeToAssign;
}
addLinkedPosition(rewrite.track(newDeclFrag.getName()), false, KEY_NAME + index);
if (!isParamToField) {
FieldDeclaration fieldDeclaration= (FieldDeclaration) newDeclFrag.getParent();
addLinkedPosition(rewrite.track(fieldDeclaration.getType()), false, KEY_TYPE);
}
addLinkedPosition(rewrite.track(accessName), true, KEY_NAME + index);
IVariableBinding variableBinding= newDeclFrag.resolveBinding();
if (variableBinding != null) {
SimpleName[] linkedNodes= LinkedNodeFinder.findByBinding(nodeToAssign.getRoot(), variableBinding);
for (int i= 0; i < linkedNodes.length; i++) {
addLinkedPosition(rewrite.track(linkedNodes[i]), false, KEY_NAME + index);
}
}
setEndPosition(rewrite.track(selectionNode));
return rewrite;
}