public boolean processDeclarations(
     @NotNull PsiScopeProcessor processor,
     @NotNull ResolveState state,
     PsiElement lastParent,
     @NotNull PsiElement place) {
   return GrClassImplUtil.processDeclarations(this, processor, state, lastParent, place);
 }
 @Override
 public PsiType fun(GrSuperReferenceExpressionImpl ref) {
   final GrReferenceExpression qualifier = ref.getQualifier();
   if (qualifier == null) {
     GroovyPsiElement context =
         PsiTreeUtil.getParentOfType(ref, GrTypeDefinition.class, GroovyFileBase.class);
     if (context instanceof GrTypeDefinition) {
       final PsiClass superClass = ((GrTypeDefinition) context).getSuperClass();
       if (superClass != null) {
         return JavaPsiFacade.getInstance(ref.getProject())
             .getElementFactory()
             .createType(superClass);
       }
     } else if (context instanceof GroovyFileBase) {
       PsiClass scriptClass = ((GroovyFileBase) context).getScriptClass();
       if (scriptClass != null) {
         PsiClass superClass = scriptClass.getSuperClass();
         if (superClass != null) {
           return JavaPsiFacade.getInstance(ref.getProject())
               .getElementFactory()
               .createType(superClass);
         }
       }
       return GrClassImplUtil.getGroovyObjectType(ref);
     }
   } else {
     final PsiElement resolved = qualifier.resolve();
     if (resolved instanceof PsiClass) {
       return ref.getSuperType((PsiClass) resolved);
     }
   }
   return null;
 }
  private static void collectMethods(
      PsiClass currentClass,
      PsiSubstitutor currentClassSubstitutor,
      boolean shouldProcessDeprecated,
      GrTypeDefinition classToDelegateTo,
      Collection<PsiMethod> collector,
      boolean keepParameterAnnotations) {
    final List<PsiMethod> methods;
    if (currentClass instanceof GrTypeDefinition) {
      methods = new ArrayList<PsiMethod>();
      GrClassImplUtil.collectMethodsFromBody((GrTypeDefinition) currentClass, methods);
    } else {
      methods = Arrays.asList(currentClass.getMethods());
    }

    for (PsiMethod method : methods) {
      if (method.isConstructor() || method.hasModifierProperty(PsiModifier.STATIC)) continue;
      if (overridesObjectOrGroovyObject(method)) continue;
      if (!shouldProcessDeprecated
          && PsiImplUtil.getAnnotation(method, CommonClassNames.JAVA_LANG_DEPRECATED) != null)
        continue;
      collector.add(
          generateDelegateMethod(
              method, classToDelegateTo, currentClassSubstitutor, keepParameterAnnotations));
    }
  }
  /**
   * Adds all code methods of clazz add its super classes to signatures. Doesn't walk into
   * interfaces because all methods from them will be overloaded in any case. Besides Some of
   * interfaces came from delegates and they should be visited during the following processing.
   *
   * @param clazz current class
   * @param substitutor super class substitutor of clazz
   * @param signatures map to initialize
   * @param classes already visited classes
   */
  private static void initializeSignatures(
      PsiClass clazz,
      PsiSubstitutor substitutor,
      Map<MethodSignature, PsiMethod> signatures,
      Set<PsiClass> classes) {
    if (clazz.isInterface()) return;

    if (classes.add(clazz)) {
      final List<PsiMethod> methods;
      if (clazz instanceof GrTypeDefinition) {
        methods = new ArrayList<PsiMethod>();
        GrClassImplUtil.collectMethodsFromBody((GrTypeDefinition) clazz, methods);
      } else {
        methods = Arrays.asList(clazz.getMethods());
      }

      for (PsiMethod method : methods) {
        addMethodChecked(signatures, method, substitutor, null);
      }

      for (PsiClassType type : getSuperTypes(clazz)) {
        final PsiClassType.ClassResolveResult result = type.resolveGenerics();
        final PsiClass superClass = result.getElement();
        if (superClass == null) continue;
        final PsiSubstitutor superClassSubstitutor =
            TypeConversionUtil.getSuperClassSubstitutor(superClass, clazz, substitutor);
        initializeSignatures(superClass, superClassSubstitutor, signatures, classes);
      }
    }
  }
 @NotNull
 public List<Pair<PsiMethod, PsiSubstitutor>> getAllMethodsAndTheirSubstitutors() {
   return GrClassImplUtil.getAllMethodsAndTheirSubstitutors(this);
 }
 @NotNull
 public List<Pair<PsiMethod, PsiSubstitutor>> findMethodsAndTheirSubstitutorsByName(
     @NonNls String name, boolean checkBases) {
   return GrClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases);
 }
 @NotNull
 public PsiMethod[] findMethodsByName(@NonNls String name, boolean checkBases) {
   return GrClassImplUtil.findCodeMethodsByName(this, name, checkBases);
 }
 @NotNull
 public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean checkBases) {
   return GrClassImplUtil.findCodeMethodsBySignature(this, patternMethod, checkBases);
 }
 @Nullable
 public PsiMethod findMethodBySignature(PsiMethod patternMethod, boolean checkBases) {
   return GrClassImplUtil.findMethodBySignature(this, patternMethod, checkBases);
 }
 @Nullable
 public PsiField findFieldByName(@NonNls String name, boolean checkBases) {
   return GrClassImplUtil.findFieldByName(this, name, checkBases, true);
 }
 @NotNull
 public PsiMethod[] getAllMethods() {
   return GrClassImplUtil.getAllMethods(this);
 }
 @NotNull
 public PsiField[] getAllFields() {
   return GrClassImplUtil.getAllFields(this);
 }
 @NotNull
 public PsiClassType[] getSuperTypes() {
   return GrClassImplUtil.getSuperTypes(this);
 }
 @Nullable
 public PsiClass getSuperClass() {
   return GrClassImplUtil.getSuperClass(this);
 }