类org.eclipse.jdt.core.dom.Initializer源码实例Demo

下面列出了怎么用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();
}
 
源代码2 项目: eclipse.jdt.ls   文件: ExtractTempRefactoring.java
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;
}
 
源代码3 项目: eclipse.jdt.ls   文件: ExtractFieldRefactoring.java
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;
}
 
源代码4 项目: eclipse.jdt.ls   文件: ExtractMethodRefactoring.java
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));
}
 
源代码10 项目: eclipse.jdt.ls   文件: ASTNodeSearchUtil.java
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;
}
 
源代码11 项目: eclipse.jdt.ls   文件: FlowAnalyzer.java
@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;
	}
}
 
源代码13 项目: compiler   文件: TestQ26.java
@Override
public boolean preVisit2(ASTNode node) {
	if (node instanceof MethodDeclaration || node instanceof Initializer || node instanceof AnnotationTypeMemberDeclaration) {
		classes++;
		tryStack.push(throw2);
		throw2 = 0;
	}
	return true;
}
 
源代码14 项目: compiler   文件: TestQ26.java
@Override
public void endVisit(Initializer node) {
	if (maxThrow < throw2)
		maxThrow = throw2;
	if (minThrow > throw2)
		minThrow = throw2;
	throw2 = tryStack.pop();
}
 
源代码15 项目: compiler   文件: TestQ25.java
@Override
public boolean preVisit2(ASTNode node) {
	if (node instanceof MethodDeclaration || node instanceof Initializer || node instanceof AnnotationTypeMemberDeclaration) {
		classes++;
		tryStack.push(try2);
		try2 = 0;
	}
	return true;
}
 
源代码16 项目: compiler   文件: TestQ25.java
@Override
public void endVisit(Initializer node) {
	if (maxTry < try2)
		maxTry = try2;
	if (minTry > try2)
		minTry = try2;
	try2 = tryStack.pop();
}
 
源代码17 项目: compiler   文件: TestQ28.java
@Override
public boolean preVisit2(ASTNode node) {
	if (node instanceof MethodDeclaration || node instanceof Initializer
			|| node instanceof AnnotationTypeMemberDeclaration) {
		classes++;
		tryStack.push(locals2);
		locals2 = 0;
	}
	return true;
}
 
源代码18 项目: compiler   文件: TestQ28.java
@Override
public void endVisit(Initializer node) {
	if (maxLocals < locals2)
		maxLocals = locals2;
	if (minLocals > locals2)
		minLocals = locals2;
	locals2 = tryStack.pop();
}
 
源代码19 项目: compiler   文件: TestQ23.java
@Override
public boolean preVisit2(ASTNode node) {
	if (node instanceof MethodDeclaration || node instanceof Initializer || node instanceof AnnotationTypeMemberDeclaration) {
		classes++;
		conditionStack.push(condition2);
		condition2 = 0;
	}
	return true;
}
 
源代码20 项目: compiler   文件: TestQ23.java
@Override
public void endVisit(Initializer node) {
	if (maxFields < condition2)
		maxFields = condition2;
	if (minFields > condition2)
		minFields = condition2;
	condition2 = conditionStack.pop();
}
 
源代码21 项目: jdt2famix   文件: AstVisitor.java
@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;
}
 
源代码29 项目: j2cl   文件: CompilationUnitBuilder.java
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;
}
 
 类所在包
 类方法
 同包方法