Java 类org.eclipse.jdt.core.dom.ConstructorInvocation 实例源码

public static ChildListPropertyDescriptor getArgumentsProperty(ASTNode invocation) {
  switch (invocation.getNodeType()) {
    case ASTNode.METHOD_INVOCATION:
      return MethodInvocation.ARGUMENTS_PROPERTY;
    case ASTNode.SUPER_METHOD_INVOCATION:
      return SuperMethodInvocation.ARGUMENTS_PROPERTY;

    case ASTNode.CONSTRUCTOR_INVOCATION:
      return ConstructorInvocation.ARGUMENTS_PROPERTY;
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
      return SuperConstructorInvocation.ARGUMENTS_PROPERTY;

    case ASTNode.CLASS_INSTANCE_CREATION:
      return ClassInstanceCreation.ARGUMENTS_PROPERTY;
    case ASTNode.ENUM_CONSTANT_DECLARATION:
      return EnumConstantDeclaration.ARGUMENTS_PROPERTY;

    default:
      throw new IllegalArgumentException(invocation.toString());
  }
}

public boolean visit(ConstructorInvocation 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 constructor invocation in \""
                + "\"");
    }
    return true;
}

public boolean visit(ConstructorInvocation 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 constructor invocation in \"\"");
  }
  return true;
}

public boolean visit(ConstructorInvocation 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 constructor invocation in \""
                + "\"");
    }
    return true;
}

public boolean visit(ConstructorInvocation 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 constructor invocation in \"\"");
  }
  return true;
}

public static List<Expression> getArguments(ASTNode invocation) {
  switch (invocation.getNodeType()) {
    case ASTNode.METHOD_INVOCATION:
      return ((MethodInvocation) invocation).arguments();
    case ASTNode.SUPER_METHOD_INVOCATION:
      return ((SuperMethodInvocation) invocation).arguments();

    case ASTNode.CONSTRUCTOR_INVOCATION:
      return ((ConstructorInvocation) invocation).arguments();
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
      return ((SuperConstructorInvocation) invocation).arguments();

    case ASTNode.CLASS_INSTANCE_CREATION:
      return ((ClassInstanceCreation) invocation).arguments();
    case ASTNode.ENUM_CONSTANT_DECLARATION:
      return ((EnumConstantDeclaration) invocation).arguments();

    default:
      throw new IllegalArgumentException(invocation.toString());
  }
}

public static IMethodBinding resolveBinding(ASTNode invocation) {
  switch (invocation.getNodeType()) {
    case ASTNode.METHOD_INVOCATION:
      return ((MethodInvocation) invocation).resolveMethodBinding();
    case ASTNode.SUPER_METHOD_INVOCATION:
      return ((SuperMethodInvocation) invocation).resolveMethodBinding();

    case ASTNode.CONSTRUCTOR_INVOCATION:
      return ((ConstructorInvocation) invocation).resolveConstructorBinding();
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
      return ((SuperConstructorInvocation) invocation).resolveConstructorBinding();

    case ASTNode.CLASS_INSTANCE_CREATION:
      return ((ClassInstanceCreation) invocation).resolveConstructorBinding();
    case ASTNode.ENUM_CONSTANT_DECLARATION:
      return ((EnumConstantDeclaration) invocation).resolveConstructorBinding();

    default:
      throw new IllegalArgumentException(invocation.toString());
  }
}

/**
 * Creates a new inline method refactoring
 *
 * @param unit the compilation unit or class file
 * @param node the compilation unit node
 * @param selectionStart start
 * @param selectionLength length
 * @return returns the refactoring
 */
public static InlineMethodRefactoring create(
    ITypeRoot unit, CompilationUnit node, int selectionStart, int selectionLength) {
  ASTNode target =
      RefactoringAvailabilityTester.getInlineableMethodNode(
          unit, node, selectionStart, selectionLength);
  if (target == null) return null;
  if (target.getNodeType() == ASTNode.METHOD_DECLARATION) {

    return new InlineMethodRefactoring(
        unit, (MethodDeclaration) target, selectionStart, selectionLength);
  } else {
    ICompilationUnit cu = (ICompilationUnit) unit;
    if (target.getNodeType() == ASTNode.METHOD_INVOCATION) {
      return new InlineMethodRefactoring(
          cu, (MethodInvocation) target, selectionStart, selectionLength);
    } else if (target.getNodeType() == ASTNode.SUPER_METHOD_INVOCATION) {
      return new InlineMethodRefactoring(
          cu, (SuperMethodInvocation) target, selectionStart, selectionLength);
    } else if (target.getNodeType() == ASTNode.CONSTRUCTOR_INVOCATION) {
      return new InlineMethodRefactoring(
          cu, (ConstructorInvocation) target, selectionStart, selectionLength);
    }
  }
  return null;
}

public RefactoringStatus setCurrentMode(Mode mode) throws JavaModelException {
  if (fCurrentMode == mode) return new RefactoringStatus();
  Assert.isTrue(getInitialMode() == Mode.INLINE_SINGLE);
  fCurrentMode = mode;
  if (mode == Mode.INLINE_SINGLE) {
    if (fInitialNode instanceof MethodInvocation)
      fTargetProvider =
          TargetProvider.create(
              (ICompilationUnit) fInitialTypeRoot, (MethodInvocation) fInitialNode);
    else if (fInitialNode instanceof SuperMethodInvocation)
      fTargetProvider =
          TargetProvider.create(
              (ICompilationUnit) fInitialTypeRoot, (SuperMethodInvocation) fInitialNode);
    else if (fInitialNode instanceof ConstructorInvocation)
      fTargetProvider =
          TargetProvider.create(
              (ICompilationUnit) fInitialTypeRoot, (ConstructorInvocation) fInitialNode);
    else throw new IllegalStateException(String.valueOf(fInitialNode));
  } else {
    fTargetProvider = TargetProvider.create(fSourceProvider.getDeclaration());
  }
  return fTargetProvider.checkActivation();
}

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;
  }
}

public static List<Expression> getArguments(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return ((MethodInvocation)invocation).arguments();
        case ASTNode.SUPER_METHOD_INVOCATION:
            return ((SuperMethodInvocation)invocation).arguments();

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ((ConstructorInvocation)invocation).arguments();
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return ((SuperConstructorInvocation)invocation).arguments();

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ((ClassInstanceCreation)invocation).arguments();
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return ((EnumConstantDeclaration)invocation).arguments();

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

public static ChildListPropertyDescriptor getArgumentsProperty(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return MethodInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_METHOD_INVOCATION:
            return SuperMethodInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ConstructorInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return SuperConstructorInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ClassInstanceCreation.ARGUMENTS_PROPERTY;
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return EnumConstantDeclaration.ARGUMENTS_PROPERTY;

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

public static IMethodBinding resolveBinding(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return ((MethodInvocation)invocation).resolveMethodBinding();
        case ASTNode.SUPER_METHOD_INVOCATION:
            return ((SuperMethodInvocation)invocation).resolveMethodBinding();

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ((ConstructorInvocation)invocation).resolveConstructorBinding();
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return ((SuperConstructorInvocation)invocation).resolveConstructorBinding();

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ((ClassInstanceCreation)invocation).resolveConstructorBinding();
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return ((EnumConstantDeclaration)invocation).resolveConstructorBinding();

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

/**
 * Creates a new inline method refactoring
 * @param unit the compilation unit or class file
 * @param node the compilation unit node
 * @param selectionStart start
 * @param selectionLength length
 * @return returns the refactoring
 */
public static InlineMethodRefactoring create(ITypeRoot unit, CompilationUnit node, int selectionStart, int selectionLength) {
    ASTNode target= RefactoringAvailabilityTester.getInlineableMethodNode(unit, node, selectionStart, selectionLength);
    if (target == null)
        return null;
    if (target.getNodeType() == ASTNode.METHOD_DECLARATION) {

        return new InlineMethodRefactoring(unit, (MethodDeclaration)target, selectionStart, selectionLength);
    } else {
        ICompilationUnit cu= (ICompilationUnit) unit;
        if (target.getNodeType() == ASTNode.METHOD_INVOCATION) {
            return new InlineMethodRefactoring(cu, (MethodInvocation)target, selectionStart, selectionLength);
        } else if (target.getNodeType() == ASTNode.SUPER_METHOD_INVOCATION) {
            return new InlineMethodRefactoring(cu, (SuperMethodInvocation)target, selectionStart, selectionLength);
        } else if (target.getNodeType() == ASTNode.CONSTRUCTOR_INVOCATION) {
            return new InlineMethodRefactoring(cu, (ConstructorInvocation)target, selectionStart, selectionLength);
        }
    }
    return null;
}

public RefactoringStatus setCurrentMode(Mode mode) throws JavaModelException {
    if (fCurrentMode == mode)
        return new RefactoringStatus();
    Assert.isTrue(getInitialMode() == Mode.INLINE_SINGLE);
    fCurrentMode= mode;
    if (mode == Mode.INLINE_SINGLE) {
        if (fInitialNode instanceof MethodInvocation)
            fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (MethodInvocation)fInitialNode);
        else if (fInitialNode instanceof SuperMethodInvocation)
            fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (SuperMethodInvocation)fInitialNode);
        else if (fInitialNode instanceof ConstructorInvocation)
            fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (ConstructorInvocation)fInitialNode);
        else
            throw new IllegalStateException(String.valueOf(fInitialNode));
    } else {
        fTargetProvider= TargetProvider.create(fSourceProvider.getDeclaration());
    }
    return fTargetProvider.checkActivation();
}

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;
    }
}

public static List<Expression> getArguments(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return ((MethodInvocation)invocation).arguments();
        case ASTNode.SUPER_METHOD_INVOCATION:
            return ((SuperMethodInvocation)invocation).arguments();

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ((ConstructorInvocation)invocation).arguments();
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return ((SuperConstructorInvocation)invocation).arguments();

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ((ClassInstanceCreation)invocation).arguments();
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return ((EnumConstantDeclaration)invocation).arguments();

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

public static ChildListPropertyDescriptor getArgumentsProperty(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return MethodInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_METHOD_INVOCATION:
            return SuperMethodInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ConstructorInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return SuperConstructorInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ClassInstanceCreation.ARGUMENTS_PROPERTY;
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return EnumConstantDeclaration.ARGUMENTS_PROPERTY;

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

public static IMethodBinding resolveBinding(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return ((MethodInvocation)invocation).resolveMethodBinding();
        case ASTNode.SUPER_METHOD_INVOCATION:
            return ((SuperMethodInvocation)invocation).resolveMethodBinding();

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ((ConstructorInvocation)invocation).resolveConstructorBinding();
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return ((SuperConstructorInvocation)invocation).resolveConstructorBinding();

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ((ClassInstanceCreation)invocation).resolveConstructorBinding();
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return ((EnumConstantDeclaration)invocation).resolveConstructorBinding();

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

/**
 * Creates a new inline method refactoring
 * @param unit the compilation unit or class file
 * @param node the compilation unit node
 * @param selectionStart start
 * @param selectionLength length
 * @return returns the refactoring
 */
public static InlineMethodRefactoring create(ITypeRoot unit, CompilationUnit node, int selectionStart, int selectionLength) {
    ASTNode target= RefactoringAvailabilityTester.getInlineableMethodNode(unit, node, selectionStart, selectionLength);
    if (target == null)
        return null;
    if (target.getNodeType() == ASTNode.METHOD_DECLARATION) {

        return new InlineMethodRefactoring(unit, (MethodDeclaration)target, selectionStart, selectionLength);
    } else {
        ICompilationUnit cu= (ICompilationUnit) unit;
        if (target.getNodeType() == ASTNode.METHOD_INVOCATION) {
            return new InlineMethodRefactoring(cu, (MethodInvocation)target, selectionStart, selectionLength);
        } else if (target.getNodeType() == ASTNode.SUPER_METHOD_INVOCATION) {
            return new InlineMethodRefactoring(cu, (SuperMethodInvocation)target, selectionStart, selectionLength);
        } else if (target.getNodeType() == ASTNode.CONSTRUCTOR_INVOCATION) {
            return new InlineMethodRefactoring(cu, (ConstructorInvocation)target, selectionStart, selectionLength);
        }
    }
    return null;
}

public RefactoringStatus setCurrentMode(Mode mode) throws JavaModelException {
    if (fCurrentMode == mode)
        return new RefactoringStatus();
    Assert.isTrue(getInitialMode() == Mode.INLINE_SINGLE);
    fCurrentMode= mode;
    if (mode == Mode.INLINE_SINGLE) {
        if (fInitialNode instanceof MethodInvocation)
            fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (MethodInvocation)fInitialNode);
        else if (fInitialNode instanceof SuperMethodInvocation)
            fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (SuperMethodInvocation)fInitialNode);
        else if (fInitialNode instanceof ConstructorInvocation)
            fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (ConstructorInvocation)fInitialNode);
        else
            throw new IllegalStateException(String.valueOf(fInitialNode));
    } else {
        fTargetProvider= TargetProvider.create(fSourceProvider.getDeclaration());
    }
    return fTargetProvider.checkActivation();
}

@Override
public boolean visit(ConstructorInvocation node) {
    if (node.getAST().apiLevel() >= JLS3) {
        if (!node.typeArguments().isEmpty()) {
            this.fBuffer.append("<");//$NON-NLS-1$
            for (Iterator<Type> it= node.typeArguments().iterator(); it.hasNext();) {
                Type t= it.next();
                t.accept(this);
                if (it.hasNext()) {
                    this.fBuffer.append(",");//$NON-NLS-1$
                }
            }
            this.fBuffer.append(">");//$NON-NLS-1$
        }
    }
    this.fBuffer.append("this(");//$NON-NLS-1$
    for (Iterator<Expression> it= node.arguments().iterator(); it.hasNext();) {
        Expression e= it.next();
        e.accept(this);
        if (it.hasNext()) {
            this.fBuffer.append(",");//$NON-NLS-1$
        }
    }
    this.fBuffer.append(");");//$NON-NLS-1$
    return false;
}

public boolean visit(ConstructorInvocation node) {
    printIndent();
    if (node.getAST().apiLevel() >= JLS3) {
        if (!node.typeArguments().isEmpty()) {
            this.buffer.append("<");//$NON-NLS-1$
            for (Iterator it = node.typeArguments().iterator(); it.hasNext(); ) {
                Type t = (Type) it.next();
                t.accept(this);
                if (it.hasNext()) {
                    this.buffer.append(",");//$NON-NLS-1$
                }
            }
            this.buffer.append(">");//$NON-NLS-1$
        }
    }
    this.buffer.append("this(");//$NON-NLS-1$
    for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
        Expression e = (Expression) it.next();
        e.accept(this);
        if (it.hasNext()) {
            this.buffer.append(",");//$NON-NLS-1$
        }
    }
    this.buffer.append(");\n");//$NON-NLS-1$
    return false;
}

/**
 * [<type..>] this( arguments )
 */
@Override
public boolean visit(final ConstructorInvocation node)
{
  // method binding for this creation
  final IMethodBinding method = node.resolveConstructorBinding().getMethodDeclaration();
  // create the resolved call
  final IResolvedCall rcall = createResolvedCall(node, node.getStartPosition(), method);
  // process the arguments
  if (rcall != null)
  {
    // actual-ins
    processActualParameters(node, node.getStartPosition(), rcall, node.arguments());
    // append the call after all its arguments
    uses.add(rcall);
  }
  // do not visit children
  return false;
}

@Override
public boolean visit(ConstructorInvocation node) {
    //System.out.println("Found: " + node.getClass());
    // TODO Type arguments
    print("this(");
    int printed = 0;
    for (Object o : node.arguments()) {
        Expression t = (Expression)o;
        if (printed > 0) {
            print(", ");
        }
        t.accept(this);
        printed++;
    }
    println(");");
    return false;
}

@Override
public void endVisit(ConstructorInvocation node) {
    if (skipNode(node)) {
        return;
    }
    processSequential(node, node.arguments());
}

@Override
public boolean visit(ConstructorInvocation node) {
    if (!isSelected(node)) {
        return false;
    }
    return handleExceptions(node.resolveConstructorBinding(), node);
}

@Override
public void endVisit(ConstructorInvocation node) {
    if (getSelection().getEndVisitSelectionMode(node) == Selection.SELECTED) {
        invalidSelection(RefactoringCoreMessages.SurroundWithTryCatchAnalyzer_cannotHandleThis, JavaStatusContext.create(fCUnit, node));
    }
    super.endVisit(node);
}

@Override
public boolean visit(ConstructorInvocation 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;
    if (loc.resolveConstructorBinding().getJavaElement() != null)
        addCalledMethod(loc.resolveConstructorBinding());
    return true;
}

public boolean visit(ConstructorInvocation node) {
    if (node.getStartPosition() == this.loc) {
        final Expression param = (Expression) node.arguments().get(
                this.paramNumber);
        this.expressions.add(param);
    }

    return true;
}

private void findFormalsForVariable(ConstructorInvocation ctorCall)
        throws JavaModelException, CoreException {
    final IMethod meth = (IMethod) ctorCall.resolveConstructorBinding()
            .getJavaElement();
    final IMethod top = Util.getTopMostSourceMethod(meth, this.monitor);

    if (top == null)
        throw new DefinitelyNotEnumerizableException(Messages.ASTNodeProcessor_SourceNotPresent,
                ctorCall);
    else
        this.findFormalsForVariable(top, getParamNumber(ctorCall
                .arguments(), this.name));
}

private boolean callsWritingConstructor(
    MethodDeclaration methodDeclaration,
    HashSet<IMethodBinding> writingConstructorBindings,
    Set<MethodDeclaration> visitedMethodDeclarations) {
  Block body = methodDeclaration.getBody();
  if (body == null) return false;

  List<Statement> statements = body.statements();
  if (statements.size() == 0) return false;

  Statement statement = statements.get(0);
  if (!(statement instanceof ConstructorInvocation)) return false;

  ConstructorInvocation invocation = (ConstructorInvocation) statement;
  IMethodBinding constructorBinding = invocation.resolveConstructorBinding();
  if (constructorBinding == null) return false;

  if (writingConstructorBindings.contains(constructorBinding)) {
    return true;
  } else {
    ASTNode declaration =
        ASTNodes.findDeclaration(constructorBinding, methodDeclaration.getParent());
    if (!(declaration instanceof MethodDeclaration)) return false;

    if (visitedMethodDeclarations.contains(declaration)) {
      return false;
    }
    visitedMethodDeclarations.add(methodDeclaration);
    return callsWritingConstructor(
        (MethodDeclaration) declaration, writingConstructorBindings, visitedMethodDeclarations);
  }
}

private static boolean containsImplicitCallToSuperConstructor(MethodDeclaration constructor) {
  Assert.isTrue(constructor.isConstructor());
  Block body = constructor.getBody();
  if (body == null) return false;
  if (body.statements().size() == 0) return true;
  if (body.statements().get(0) instanceof ConstructorInvocation) return false;
  if (body.statements().get(0) instanceof SuperConstructorInvocation) return false;
  return true;
}

private boolean isRecursiveReference() {
  MethodDeclaration enclosingMethodDeclaration =
      (MethodDeclaration) ASTNodes.getParent(fNode, MethodDeclaration.class);
  if (enclosingMethodDeclaration == null) return false;

  IMethodBinding enclosingMethodBinding = enclosingMethodDeclaration.resolveBinding();
  if (enclosingMethodBinding == null) return false;

  if (fNode instanceof MethodInvocation)
    return enclosingMethodBinding == ((MethodInvocation) fNode).resolveMethodBinding();

  if (fNode instanceof SuperMethodInvocation) {
    IMethodBinding methodBinding = ((SuperMethodInvocation) fNode).resolveMethodBinding();
    return isSameMethod(methodBinding, enclosingMethodBinding);
  }

  if (fNode instanceof ClassInstanceCreation)
    return enclosingMethodBinding
        == ((ClassInstanceCreation) fNode).resolveConstructorBinding();

  if (fNode instanceof ConstructorInvocation)
    return enclosingMethodBinding
        == ((ConstructorInvocation) fNode).resolveConstructorBinding();

  if (fNode instanceof SuperConstructorInvocation) {
    return false; // Constructors don't override -> enclosing has not been changed -> no
    // recursion
  }

  if (fNode instanceof EnumConstantDeclaration) {
    return false; // cannot define enum constant inside enum constructor
  }

  Assert.isTrue(false);
  return false;
}

public static ASTNode getAstNode(CompilationUnit cuNode, int start, int length) {
  SelectionAnalyzer analyzer =
      new SelectionAnalyzer(Selection.createFromStartLength(start, length), true);
  cuNode.accept(analyzer);
  // XXX workaround for jdt core feature 23527
  ASTNode node = analyzer.getFirstSelectedNode();
  if (node == null && analyzer.getLastCoveringNode() instanceof SuperConstructorInvocation)
    node = analyzer.getLastCoveringNode().getParent();
  else if (node == null && analyzer.getLastCoveringNode() instanceof ConstructorInvocation)
    node = analyzer.getLastCoveringNode().getParent();

  if (node == null) return null;

  ASTNode parentNode = node.getParent();

  if (parentNode instanceof MethodDeclaration) {
    MethodDeclaration md = (MethodDeclaration) parentNode;
    if (!(node instanceof SimpleName)
        && md.isConstructor()
        && md.getBody() != null
        && md.getBody().statements().size() > 0
        && (md.getBody().statements().get(0) instanceof ConstructorInvocation
            || md.getBody().statements().get(0) instanceof SuperConstructorInvocation)
        && ((ASTNode) md.getBody().statements().get(0)).getLength() == length + 1)
      return (ASTNode) md.getBody().statements().get(0);
  }

  if (parentNode instanceof SuperConstructorInvocation) {
    if (parentNode.getLength() == length + 1) return parentNode;
  }
  if (parentNode instanceof ConstructorInvocation) {
    if (parentNode.getLength() == length + 1) return parentNode;
  }
  return node;
}

private static boolean shouldInsertTempInitialization(MethodDeclaration constructor) {
  Assert.isTrue(constructor.isConstructor());
  if (constructor.getBody() == null) return false;
  List<Statement> statements = constructor.getBody().statements();
  if (statements == null) return false;
  if (statements.size() > 0 && statements.get(0) instanceof ConstructorInvocation) return false;
  return true;
}

@Override
public boolean visit(ConstructorInvocation node) {
  if (matches(node.resolveConstructorBinding()) && fCurrent != null) {
    fCurrent.addInvocation(node);
  }
  return true;
}

private boolean isUsedInExplicitConstructorCall() throws JavaModelException {
  Expression selectedExpression = getSelectedExpression().getAssociatedExpression();
  if (ASTNodes.getParent(selectedExpression, ConstructorInvocation.class) != null) return true;
  if (ASTNodes.getParent(selectedExpression, SuperConstructorInvocation.class) != null)
    return true;
  return false;
}

private InlineMethodRefactoring(
    ICompilationUnit unit, ConstructorInvocation node, int offset, int length) {
  this(unit, (ASTNode) node, offset, length);
  fTargetProvider = TargetProvider.create(unit, node);
  fInitialMode = fCurrentMode = Mode.INLINE_SINGLE;
  fDeleteSource = false;
}

@Override
public ITypeConstraint[] create(ConstructorInvocation invocation) {
  List<Expression> arguments = invocation.arguments();
  List<ITypeConstraint> result = new ArrayList<ITypeConstraint>(arguments.size());
  IMethodBinding methodBinding = invocation.resolveConstructorBinding();
  result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding)));
  return result.toArray(new ITypeConstraint[result.size()]);
}