public int match(MemberValuePair node, MatchingNodeSet nodeSet) {
    if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;

    if (!matchesName(this.pattern.selector, node.name)) return IMPOSSIBLE_MATCH;

    return nodeSet.addMatch(node, this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
  }
  public int match(MessageSend node, MatchingNodeSet nodeSet) {
    if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;

    if (!matchesName(this.pattern.selector, node.selector)) return IMPOSSIBLE_MATCH;
    if (this.pattern.parameterSimpleNames != null
        && (!this.pattern.varargs || ((node.bits & ASTNode.InsideJavadoc) != 0))) {
      int length = this.pattern.parameterSimpleNames.length;
      ASTNode[] args = node.arguments;
      int argsLength = args == null ? 0 : args.length;
      if (length != argsLength) return IMPOSSIBLE_MATCH;
    }

    return nodeSet.addMatch(node, this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
  }
  // public int match(Reference node, MatchingNodeSet nodeSet) - SKIP IT
  public int match(Annotation node, MatchingNodeSet nodeSet) {
    if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;
    MemberValuePair[] pairs = node.memberValuePairs();
    if (pairs == null || pairs.length == 0) return IMPOSSIBLE_MATCH;

    int length = pairs.length;
    MemberValuePair pair = null;
    for (int i = 0; i < length; i++) {
      pair = node.memberValuePairs()[i];
      if (matchesName(this.pattern.selector, pair.name)) {
        ASTNode possibleNode = (node instanceof SingleMemberAnnotation) ? (ASTNode) node : pair;
        return nodeSet.addMatch(
            possibleNode, this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
      }
    }
    return IMPOSSIBLE_MATCH;
  }
  // public int match(ConstructorDeclaration node, MatchingNodeSet nodeSet) - SKIP IT
  // public int match(Expression node, MatchingNodeSet nodeSet) - SKIP IT
  // public int match(FieldDeclaration node, MatchingNodeSet nodeSet) - SKIP IT
  public int match(MethodDeclaration node, MatchingNodeSet nodeSet) {
    if (!this.pattern.findDeclarations) return IMPOSSIBLE_MATCH;

    // Verify method name
    if (!matchesName(this.pattern.selector, node.selector)) return IMPOSSIBLE_MATCH;

    // Verify parameters types
    boolean resolve = this.pattern.mustResolve;
    if (this.pattern.parameterSimpleNames != null) {
      int length = this.pattern.parameterSimpleNames.length;
      ASTNode[] args = node.arguments;
      int argsLength = args == null ? 0 : args.length;
      if (length != argsLength) return IMPOSSIBLE_MATCH;
      for (int i = 0; i < argsLength; i++) {
        if (args != null
            && !matchesTypeReference(
                this.pattern.parameterSimpleNames[i], ((Argument) args[i]).type)) {
          // Do not return as impossible when source level is at least 1.5
          if (this.mayBeGeneric) {
            if (!this.pattern.mustResolve) {
              // Set resolution flag on node set in case of types was inferred in parameterized
              // types from generic ones...
              // (see  bugs https://bugs.eclipse.org/bugs/show_bug.cgi?id=79990, 96761, 96763)
              nodeSet.mustResolve = true;
              resolve = true;
            }
            this.methodDeclarationsWithInvalidParam.put(node, null);
          } else {
            return IMPOSSIBLE_MATCH;
          }
        }
      }
    }

    // Verify type arguments (do not reject if pattern has no argument as it can be an erasure
    // match)
    if (this.pattern.hasMethodArguments()) {
      if (node.typeParameters == null
          || node.typeParameters.length != this.pattern.methodArguments.length)
        return IMPOSSIBLE_MATCH;
    }

    // Method declaration may match pattern
    return nodeSet.addMatch(node, resolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
  }
 public int match(ASTNode node, MatchingNodeSet nodeSet) {
   int declarationsLevel = IMPOSSIBLE_MATCH;
   if (this.pattern.findReferences) {
     if (node instanceof ImportReference) {
       // With static import, we can have static method reference in import reference
       ImportReference importRef = (ImportReference) node;
       int length = importRef.tokens.length - 1;
       if (importRef.isStatic()
           && ((importRef.bits & ASTNode.OnDemand) == 0)
           && matchesName(this.pattern.selector, importRef.tokens[length])) {
         char[][] compoundName = new char[length][];
         System.arraycopy(importRef.tokens, 0, compoundName, 0, length);
         char[] declaringType =
             CharOperation.concat(
                 this.pattern.declaringQualification, this.pattern.declaringSimpleName, '.');
         if (matchesName(declaringType, CharOperation.concatWith(compoundName, '.'))) {
           declarationsLevel = this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH;
         }
       }
     }
   }
   return nodeSet.addMatch(node, declarationsLevel);
 }