Java ClassInstanceCreation.resolveConstructorBinding方法代码示例

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
public boolean visit(ClassInstanceCreation node) {
	IMethodBinding mmtb = node.resolveConstructorBinding();

	if (mtbStack.isEmpty()) // not part of a method
		return true;

	// make field access fact
	try {
		facts.add(Fact.makeCallsFact(getQualifiedName(mtbStack.peek()),
				getQualifiedName(mmtb)));
	} catch (Exception e) {
		System.err.println("Cannot resolve class instance creation \""
				+ node.getType().toString() + "\"");
	}
	return true;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
public boolean visit(ClassInstanceCreation node)
{
  IMethodBinding mmtb = node.resolveConstructorBinding();
  if (this.mtbStack.isEmpty()) {
    return true;
  }
  try
  {
    this.facts.add(Fact.makeCallsFact(getQualifiedName((IMethodBinding)this.mtbStack.peek()), 
      getQualifiedName(mmtb)));
  }
  catch (Exception e)
  {
    System.err.println("Cannot resolve class instance creation \"" + 
      node.getType().toString() + "\"");
  }
  return true;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
public boolean visit(ClassInstanceCreation node)
{
  IMethodBinding mmtb = node.resolveConstructorBinding();
  if (this.mtbStack.isEmpty()) {
    return true;
  }
  try
  {
    this.facts.add(Fact.makeCallsFact(getQualifiedName((IMethodBinding)this.mtbStack.peek()), 
      getQualifiedName(mmtb)));
  }
  catch (Exception localException)
  {
    System.err.println("Cannot resolve class instance creation \"" + 
      node.getType().toString() + "\"");
  }
  return true;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public void endVisit(ClassInstanceCreation node) {
  Expression receiver = node.getExpression();
  Type createdType = node.getType();

  ConstraintVariable2 typeCv;
  if (node.getAnonymousClassDeclaration() == null) {
    typeCv = getConstraintVariable(createdType);
  } else {
    typeCv = fTCModel.makeImmutableTypeVariable(createdType.resolveBinding(), null);
    setConstraintVariable(createdType, typeCv);
  }
  setConstraintVariable(node, typeCv);

  IMethodBinding methodBinding = node.resolveConstructorBinding();
  Map<String, IndependentTypeVariable2> methodTypeVariables =
      createMethodTypeArguments(methodBinding);
  List<Expression> arguments = node.arguments();
  doVisitMethodInvocationArguments(
      methodBinding, arguments, receiver, methodTypeVariables, createdType);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public ITypeConstraint[] create(ClassInstanceCreation instanceCreation) {
  List<Expression> arguments = instanceCreation.arguments();
  List<ITypeConstraint> result = new ArrayList<ITypeConstraint>(arguments.size());
  IMethodBinding methodBinding = instanceCreation.resolveConstructorBinding();
  result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding)));
  if (instanceCreation.getAnonymousClassDeclaration() == null) {
    ConstraintVariable constructorVar =
        fConstraintVariableFactory.makeExpressionOrTypeVariable(instanceCreation, getContext());
    ConstraintVariable typeVar =
        fConstraintVariableFactory.makeRawBindingVariable(instanceCreation.resolveTypeBinding());
    result.addAll(
        Arrays.asList(fTypeConstraintFactory.createDefinesConstraint(constructorVar, typeVar)));
  }
  return result.toArray(new ITypeConstraint[result.size()]);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
private static IBinding resolveBinding(ASTNode node) {
  if (node instanceof SimpleName) {
    SimpleName simpleName = (SimpleName) node;
    // workaround for https://bugs.eclipse.org/62605 (constructor name resolves to type, not
    // method)
    ASTNode normalized = ASTNodes.getNormalizedNode(simpleName);
    if (normalized.getLocationInParent() == ClassInstanceCreation.TYPE_PROPERTY) {
      ClassInstanceCreation cic = (ClassInstanceCreation) normalized.getParent();
      IMethodBinding constructorBinding = cic.resolveConstructorBinding();
      if (constructorBinding == null) return null;
      ITypeBinding declaringClass = constructorBinding.getDeclaringClass();
      if (!declaringClass.isAnonymous()) return constructorBinding;
      ITypeBinding superTypeDeclaration = declaringClass.getSuperclass().getTypeDeclaration();
      return resolveSuperclassConstructor(superTypeDeclaration, constructorBinding);
    }
    return simpleName.resolveBinding();

  } else if (node instanceof SuperConstructorInvocation) {
    return ((SuperConstructorInvocation) node).resolveConstructorBinding();
  } else if (node instanceof ConstructorInvocation) {
    return ((ConstructorInvocation) node).resolveConstructorBinding();
  } else {
    return null;
  }
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
/**
 * handles
 * 		new Class()
 */
@SuppressWarnings("unchecked")
@Override
public boolean visit(ClassInstanceCreation node) {
	IMethodBinding binding = node.resolveConstructorBinding();
	if (binding != null)
		importer.createInvocationFromMethodBinding(binding, node.toString().trim());
	else {
		String name = node.getType().toString();
		importer.ensureBasicMethod(
				name, 
				name, 
				importer.ensureTypeNamedInUnknownNamespace(name), 
				m -> importer.createInvocationToMethod(m, node.toString().trim()));
	}
	node.arguments().stream().forEach(arg -> importer.createAccessFromExpression((Expression) arg));
	return true;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public void endVisit(ClassInstanceCreation node) {
	Expression receiver= node.getExpression();
	Type createdType= node.getType();

	ConstraintVariable2 typeCv;
	if (node.getAnonymousClassDeclaration() == null) {
		typeCv= getConstraintVariable(createdType);
	} else {
		typeCv= fTCModel.makeImmutableTypeVariable(createdType.resolveBinding(), null);
		setConstraintVariable(createdType, typeCv);
	}
	setConstraintVariable(node, typeCv);

	IMethodBinding methodBinding= node.resolveConstructorBinding();
	Map<String, IndependentTypeVariable2> methodTypeVariables= createMethodTypeArguments(methodBinding);
	List<Expression> arguments= node.arguments();
	doVisitMethodInvocationArguments(methodBinding, arguments, receiver, methodTypeVariables, createdType);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
private static IBinding resolveBinding(ASTNode node) {
	if (node instanceof SimpleName) {
		SimpleName simpleName= (SimpleName) node;
		// workaround for https://bugs.eclipse.org/62605 (constructor name resolves to type, not method)
		ASTNode normalized= ASTNodes.getNormalizedNode(simpleName);
		if (normalized.getLocationInParent() == ClassInstanceCreation.TYPE_PROPERTY) {
			ClassInstanceCreation cic= (ClassInstanceCreation) normalized.getParent();
			IMethodBinding constructorBinding= cic.resolveConstructorBinding();
			if (constructorBinding == null)
				return null;
			ITypeBinding declaringClass= constructorBinding.getDeclaringClass();
			if (!declaringClass.isAnonymous())
				return constructorBinding;
			ITypeBinding superTypeDeclaration= declaringClass.getSuperclass().getTypeDeclaration();
			return resolveSuperclassConstructor(superTypeDeclaration, constructorBinding);
		}
		return simpleName.resolveBinding();
		
	} else if (node instanceof SuperConstructorInvocation) {
		return ((SuperConstructorInvocation) node).resolveConstructorBinding();
	} else if (node instanceof ConstructorInvocation) {
		return ((ConstructorInvocation) node).resolveConstructorBinding();
	} else {
		return null;
	}
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public OOGContext transfer(NewObjectInstruction instr, OOGContext value) {
	ITypeBinding instantiatedType = instr.resolveInstantiatedType();
	ASTNode node = instr.getNode();
	ITypeBinding newExprEnclosingClassBinding = Utils.findEnclosingClassBinding(node);
	IMethodBinding newExprEnclosingMethodBinding = Utils.findEnclosingMethodBinding(node);
	if(node instanceof ClassInstanceCreation){
		ClassInstanceCreation cicNode = (ClassInstanceCreation)node;
		IMethodBinding constructorBinding = cicNode.resolveConstructorBinding();
		final TACNewExpr newExprVar = new TACNewExpr(constructorBinding, newExprEnclosingClassBinding, newExprEnclosingMethodBinding, instantiatedType);
		context.putAllBindingKeyToVariableMap(constructorBinding.getKey(), newExprVar);
		Variable newExprVarInMap = this.tm.getVarBindingMap(constructorBinding);
		
		// Build a mapping from the synthetic new expression variable to its left hand side variable
		Variable lhsVariable = instr.getTarget();
		value.addNewExprVarToLhsVar(newExprVar, lhsVariable);
		
		if(newExprVarInMap==null){
			this.tm.putVarBindingMap(constructorBinding, newExprVar);
		}
		String newExprEncClassName = newExprEnclosingClassBinding.getQualifiedName();
		Set<OType> newExprTypingSet = this.tm.getTypeMapping(newExprVar);
		if(newExprTypingSet==null){
			boolean isMainClass = newExprEncClassName.equals(Config.MAINCLASS);
			newExprTypingSet = this.tm.initTypeMapping(isMainClass,newExprVar, false,true);
			this.tm.putTypeMapping(newExprVar, newExprTypingSet);
		}
	}
	return value;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public boolean visit(ClassInstanceCreation loc) {
	if (currentMethod == null)
		return false;
	if (loc.resolveConstructorBinding() == null)
		return false;
	if (loc.resolveConstructorBinding().getMethodDeclaration() == null || loc.resolveConstructorBinding().getMethodDeclaration().getJavaElement() == null)
		return true;
	if (loc.resolveConstructorBinding().getMethodDeclaration().getJavaElement().isReadOnly())
		return true;
	addCalledMethod(loc.resolveConstructorBinding());
	return true;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public ITypeConstraint[] create(ClassInstanceCreation instanceCreation){
	List<Expression> arguments= instanceCreation.arguments();
	List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size());
	IMethodBinding methodBinding= instanceCreation.resolveConstructorBinding();
	result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding)));
	if (instanceCreation.getAnonymousClassDeclaration() == null){
		ConstraintVariable constructorVar= fConstraintVariableFactory.makeExpressionOrTypeVariable(instanceCreation, getContext());
		ConstraintVariable typeVar= fConstraintVariableFactory.makeRawBindingVariable(instanceCreation.resolveTypeBinding());
		result.addAll(Arrays.asList(fTypeConstraintFactory.createDefinesConstraint(constructorVar, typeVar)));
	}
	return result.toArray(new ITypeConstraint[result.size()]);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
private static IBinding resolveBinding(ASTNode node) {
	if (node instanceof SimpleName) {
		// workaround for https://bugs.eclipse.org/62605 (constructor name resolves to type, not method)
		SimpleName simpleName= (SimpleName) node;
		StructuralPropertyDescriptor loc= simpleName.getLocationInParent();
		while (loc == QualifiedType.NAME_PROPERTY || loc == QualifiedName.NAME_PROPERTY|| loc == SimpleType.NAME_PROPERTY || loc == ParameterizedType.TYPE_PROPERTY) {
			node= node.getParent();
			loc= node.getLocationInParent();
		}
		if (loc == ClassInstanceCreation.TYPE_PROPERTY) {
			ClassInstanceCreation cic= (ClassInstanceCreation) node.getParent();
			IMethodBinding constructorBinding= cic.resolveConstructorBinding();
			if (constructorBinding == null)
				return null;
			ITypeBinding declaringClass= constructorBinding.getDeclaringClass();
			if (!declaringClass.isAnonymous())
				return constructorBinding;
			ITypeBinding superTypeDeclaration= declaringClass.getSuperclass().getTypeDeclaration();
			return resolveSuperclassConstructor(superTypeDeclaration, constructorBinding);
		}
		return simpleName.resolveBinding();
		
	} else if (node instanceof SuperConstructorInvocation) {
		return ((SuperConstructorInvocation) node).resolveConstructorBinding();
	} else if (node instanceof ConstructorInvocation) {
		return ((ConstructorInvocation) node).resolveConstructorBinding();
	} else {
		return null;
	}
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
public static QMethodAndArgs make(ClassInstanceCreation node) {
    String qtype = node.getType().resolveBinding().getQualifiedName();
    String method = CONSTRUCTOR_METHOD;
    // can't use node.arguments() because those are the concrete types, not necessarily
    // the types of the methods
    IMethodBinding constructor = node.resolveConstructorBinding();
    return new QMethodAndArgs(qtype, method, expressionsToTypeStrings(constructor.getParameterTypes()));
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
/**
 * Determines what kind of AST node was selected, and returns an error status if the kind of node
 * is inappropriate for this refactoring.
 *
 * @param pm
 * @return a RefactoringStatus indicating whether the selection is valid
 * @throws JavaModelException
 */
private RefactoringStatus checkSelection(IProgressMonitor pm) throws JavaModelException {
  try {
    pm.beginTask(RefactoringCoreMessages.IntroduceFactory_examiningSelection, 2);

    fSelectedNode = getTargetNode(fCUHandle, fSelectionStart, fSelectionLength);

    if (fSelectedNode == null)
      return RefactoringStatus.createFatalErrorStatus(
          RefactoringCoreMessages.IntroduceFactory_notAConstructorInvocation);

    // getTargetNode() must return either a ClassInstanceCreation or a
    // constructor MethodDeclaration; nothing else.
    if (fSelectedNode instanceof ClassInstanceCreation) {
      ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) fSelectedNode;
      fCtorBinding = classInstanceCreation.resolveConstructorBinding();
    } else if (fSelectedNode instanceof MethodDeclaration) {
      MethodDeclaration methodDeclaration = (MethodDeclaration) fSelectedNode;
      fCtorBinding = methodDeclaration.resolveBinding();
    }

    if (fCtorBinding == null)
      return RefactoringStatus.createFatalErrorStatus(
          RefactoringCoreMessages.IntroduceFactory_unableToResolveConstructorBinding);

    // If this constructor is of a generic type, get the generic version,
    // not some instantiation thereof.
    fCtorBinding = fCtorBinding.getMethodDeclaration();

    pm.worked(1);

    // We don't handle constructors of nested types at the moment
    if (fCtorBinding.getDeclaringClass().isNested())
      return RefactoringStatus.createFatalErrorStatus(
          RefactoringCoreMessages.IntroduceFactory_unsupportedNestedTypes);

    ITypeBinding ctorType = fCtorBinding.getDeclaringClass();
    IType ctorOwningType = (IType) ctorType.getJavaElement();

    if (ctorOwningType.isBinary())
      // Can't modify binary CU; don't know what CU to put factory method
      return RefactoringStatus.createFatalErrorStatus(
          RefactoringCoreMessages.IntroduceFactory_constructorInBinaryClass);
    if (ctorOwningType.isEnum())
      // Doesn't make sense to encapsulate enum constructors
      return RefactoringStatus.createFatalErrorStatus(
          RefactoringCoreMessages.IntroduceFactory_constructorInEnum);

    // Put the generated factory method inside the type that owns the constructor
    fFactoryUnitHandle = ctorOwningType.getCompilationUnit();
    fFactoryCU = getASTFor(fFactoryUnitHandle);

    Name ctorOwnerName = (Name) NodeFinder.perform(fFactoryCU, ctorOwningType.getNameRange());

    fCtorOwningClass =
        (AbstractTypeDeclaration)
            ASTNodes.getParent(ctorOwnerName, AbstractTypeDeclaration.class);
    fFactoryOwningClass = fCtorOwningClass;

    pm.worked(1);

    if (fNewMethodName == null)
      return setNewMethodName("create" + fCtorBinding.getName()); // $NON-NLS-1$
    else return new RefactoringStatus();
  } finally {
    pm.done();
  }
}