Java SimpleName类代码示例

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
public static SimpleName getLeftMostSimpleName(Name name) {
	if (name instanceof SimpleName) {
		return (SimpleName)name;
	} else {
		final SimpleName[] result= new SimpleName[1];
		ASTVisitor visitor= new ASTVisitor() {
			@Override
			public boolean visit(QualifiedName qualifiedName) {
				Name left= qualifiedName.getQualifier();
				if (left instanceof SimpleName) {
					result[0]= (SimpleName)left;
				} else {
					left.accept(this);
				}
				return false;
			}
		};
		name.accept(visitor);
		return result[0];
	}
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
private VariableDeclarationStatement createDeclaration(IVariableBinding binding, Expression intilizer) {
	VariableDeclaration original = ASTNodes.findVariableDeclaration(binding, fAnalyzer.getEnclosingBodyDeclaration());
	VariableDeclarationFragment fragment = fAST.newVariableDeclarationFragment();
	fragment.setName((SimpleName) ASTNode.copySubtree(fAST, original.getName()));
	fragment.setInitializer(intilizer);
	VariableDeclarationStatement result = fAST.newVariableDeclarationStatement(fragment);
	result.modifiers().addAll(ASTNode.copySubtrees(fAST, ASTNodes.getModifiers(original)));
	result.setType(ASTNodeFactory.newType(fAST, original, fImportRewriter, new ContextSensitiveImportRewriteContext(original, fImportRewriter)));
	return result;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
public boolean visit(SimpleName node) {
	if (mtbStack.isEmpty() && !itbStack.isEmpty()) { // not part of a method
		return false;
		/*
		 * try { return visitName(node.resolveBinding(),
		 * anonClassName.equals("")?getQualifiedName(itb):anonClassName); }
		 * catch (Exception e) {
		 * System.err.println("Cannot resolve simple name \""
		 * +node.getFullyQualifiedName().toString()+"\""); return false; }
		 */
	} else if (!mtbStack.isEmpty()) {
		if (node.getIdentifier().equals("length"))
			return false;
		try {
			return visitName(node.resolveBinding(), mtbStack.peek());
		} catch (Exception e) {
			System.err.println("Cannot resolve simple name \""
					+ node.getFullyQualifiedName().toString() + "\"");
			return false;
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
private void handleVarDeclaration(VariableDeclarationFragment var, boolean isField) {
	String varName = var.getName().getIdentifier();
	VariableInfo varInfo = current.addVar(varName, isField);
	Expression init = var.getInitializer();
	if(init instanceof SimpleName) {
		String initVar = ((SimpleName) init).getIdentifier();
		varInfo.addOperation(new VariableOperation(varName, VariableOperation.Type.INIT, initVar));
	}

}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
@Override
public boolean visit(PostfixExpression exp) {
	if(exp.getOperand() instanceof SimpleName) {
		String varName = exp.getOperand().toString(); 
		VariableOperation op = null;
		if(exp.getOperator() == PostfixExpression.Operator.INCREMENT)
			op = new VariableOperation(varName, VariableOperation.Type.INC);

		else if(exp.getOperator() == PostfixExpression.Operator.DECREMENT)
			op = new VariableOperation(varName, VariableOperation.Type.DEC);

		if(op != null)
			current.addOperation(op);
	}
	return true;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
private Object[] accessExpressions(ArrayAccess node) {
	Object[] exp = new Object[indexDepth(node)+1];
	ArrayAccess a = node;
	int i = exp.length-1;
	do {
		Expression indexExp = a.getIndex();
		if(!(indexExp instanceof SimpleName)) // TODO no modifiers
			return null;

		exp[i] = indexExp.toString();
		Expression temp = a.getArray();
		a = temp instanceof ArrayAccess ? (ArrayAccess) temp : null;
		i--;			
	}
	while(i >= 0);
	return exp;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
private static boolean isAcumulationAssign(Assignment assignment, InfixExpression.Operator op, Predicate<Expression> acceptExpression) {
	if(!(
			assignment.getRightHandSide() instanceof InfixExpression && 
			assignment.getLeftHandSide() instanceof SimpleName &&
			assignment.getOperator() == Assignment.Operator.ASSIGN))
		return false;

	InfixExpression exp = (InfixExpression) assignment.getRightHandSide();
	if(exp.getOperator() != op)
		return false;

	String assignVar = assignment.getLeftHandSide().toString();
	if(	exp.getLeftOperand() instanceof SimpleName &&
			exp.getLeftOperand().toString().equals(assignVar) &&
			acceptExpression.test(exp.getRightOperand()))
		return true;

	if(	exp.getRightOperand() instanceof SimpleName && 
			exp.getRightOperand().toString().equals(assignVar) &&
			acceptExpression.test(exp.getLeftOperand()))
		return true;

	return false;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
/**
 * Method to get the number of methods with indirect connections.
 * @author Mariana Azevedo
 * @since 13/07/2014
 * @param methodsWithDirectConn
 * @param itMethods
 */
private void getNumberOfIndirectConnections(List<MethodDeclaration> methodsWithDirectConn,
		Iterator<MethodDeclaration> itMethods){
	
	int i=0;
	while (itMethods.hasNext()){
	
		MethodDeclaration firstMethod = itMethods.next();
		if (firstMethod != null){
			Block firstMethodBody = firstMethod.getBody();
		
			if (firstMethodBody != null){
				SimpleName methodDeclaration = methodsWithDirectConn.get(i).getName();
				
				if (firstMethodBody.toString().contains(methodDeclaration.toString())){
					numIndirectConnections++;
				}
			}
		}
	}
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
public MethodInvocation createStaticMethodInvocation(AST ast, String className, String methodName) {
    SimpleName typeName = ast.newSimpleName(className);

    MethodInvocation methodInvocation = ast.newMethodInvocation();
    methodInvocation.setName(ast.newSimpleName(methodName));
    methodInvocation.setExpression(typeName);

    return methodInvocation;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
/**
 * Returns the binding of the variable written in an Assignment.
 * @param assignment The assignment
 * @return The binding or <code>null</code> if no bindings are available.
 */
public static IVariableBinding getAssignedVariable(Assignment assignment) {
	Expression leftHand = assignment.getLeftHandSide();
	switch (leftHand.getNodeType()) {
	case ASTNode.SIMPLE_NAME:
		return (IVariableBinding) ((SimpleName) leftHand).resolveBinding();
	case ASTNode.QUALIFIED_NAME:
		return (IVariableBinding) ((QualifiedName) leftHand).getName().resolveBinding();
	case ASTNode.FIELD_ACCESS:
		return ((FieldAccess) leftHand).resolveFieldBinding();
	case ASTNode.SUPER_FIELD_ACCESS:
		return ((SuperFieldAccess) leftHand).resolveFieldBinding();
	default:
		return null;
	}
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
/**
 * for an assignment x = y returns the variable binding of x
 * 
 * @param varBinding
 * @param assignment
 * @return
 */
private static IVariableBinding getLeftHandSideVarBinding(Assignment assignment) {
	Expression leftHnsd = assignment.getLeftHandSide();
	if (leftHnsd instanceof SimpleName) {
		IBinding bind = ((SimpleName) leftHnsd).resolveBinding();
		if (bind instanceof IVariableBinding) {
			return ((IVariableBinding) bind).getVariableDeclaration();
		}
	}
	if (leftHnsd instanceof FieldAccess) {
		FieldAccess fa = (FieldAccess) leftHnsd;
		return fa.resolveFieldBinding();
	}
	// Leave it null - cannot determine actual domains for arrays
	// workaround for bugs related to objects created in complex expression
	// if (leftHnsd instanceof ArrayAccess) {
	// ArrayAccess aa = (ArrayAccess) leftHnsd;
	// return getArrayAccessVarBinding(aa);
	// }
	return null;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
@Override
public boolean visit(MethodInvocation node) {
	Expression receiver = node.getExpression();
	if (receiver == null) {
		SimpleName name = node.getName();
		if (fIgnoreBinding == null || !Bindings.equals(fIgnoreBinding, name.resolveBinding())) {
			node.getName().accept(this);
		}
	} else {
		receiver.accept(this);
	}
	accept(node.arguments());
	return false;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
@Override
public boolean visit(SimpleName node) {
	IBinding binding= node.resolveBinding();
	if (binding == null) {
		return false;
	}
	binding= getDeclaration(binding);

	if (fBinding == binding) {
		fResult.add(node);
	} else if (binding.getKind() != fBinding.getKind()) {
		return false;
	} else if (binding.getKind() == IBinding.METHOD) {
		IMethodBinding curr= (IMethodBinding) binding;
		IMethodBinding methodBinding= (IMethodBinding) fBinding;
		if (methodBinding.overrides(curr) || curr.overrides(methodBinding)) {
			fResult.add(node);
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
private void addStaticImports(
		Collection<SimpleName> staticReferences,
		ImportRewrite importRewrite,
		UnresolvableImportMatcher unresolvableImportMatcher) {
	for (SimpleName name : staticReferences) {
		IBinding binding= name.resolveBinding();
		if (binding != null) {
			importRewrite.addStaticImport(binding);
		} else {
			// This could be an unresolvable reference to a static member.
			String identifier= name.getIdentifier();
			Set<String> unresolvableImports= unresolvableImportMatcher.matchStaticImports(identifier);
			for (String unresolvableImport : unresolvableImports) {
				int lastDotIndex= unresolvableImport.lastIndexOf('.');
				// It's OK to skip invalid imports.
				if (lastDotIndex != -1) {
					String declaringTypeName= unresolvableImport.substring(0, lastDotIndex);
					String simpleName= unresolvableImport.substring(lastDotIndex + 1);
					// Whether name refers to a field or to a method is unknown.
					boolean isField= false;
					importRewrite.addStaticImport(declaringTypeName, simpleName, isField, UNRESOLVABLE_IMPORT_CONTEXT);
				}
			}
		}
	}
}
 

import org.eclipse.jdt.core.dom.SimpleName; //导入依赖的package包/类
@Override
public boolean visit(SimpleName node) {
	if (currentMethod == null)
		return false;
	IBinding binding = node.resolveBinding();
	if (binding == null)
		return false;
	if (node.isDeclaration())
		return true;
	if (node.resolveBinding() instanceof IVariableBinding) {
		IVariableBinding iVariableBinding = (IVariableBinding) node.resolveBinding();
		if (iVariableBinding.isField()) {
			IVariableBinding variableDeclarationBinding = iVariableBinding.getVariableDeclaration();
			if (variableDeclarationBinding.getDeclaringClass() != null) {
				IJavaElement accessedField = variableDeclarationBinding.getJavaElement();
				if (accessedField instanceof IField) {
					if (!((IField) accessedField).isReadOnly())
						methodDetails.addAccess((IField) accessedField);
				}
			}
		}
	}
	return true;
}