static final IMethod[] hierarchyDeclaresMethodName(
     IProgressMonitor pm, ITypeHierarchy hierarchy, IMethod method, String newName)
     throws CoreException {
   try {
     Set<IMethod> result = new HashSet<>();
     IType type = method.getDeclaringType();
     IMethod foundMethod =
         Checks.findMethod(newName, method.getParameterTypes().length, false, type);
     if (foundMethod != null) result.add(foundMethod);
     IMethod[] foundInHierarchyClasses =
         classesDeclareMethodName(
             hierarchy, Arrays.asList(hierarchy.getAllClasses()), method, newName);
     if (foundInHierarchyClasses != null) result.addAll(Arrays.asList(foundInHierarchyClasses));
     IType[] implementingClasses = hierarchy.getImplementingClasses(type);
     IMethod[] foundInImplementingClasses =
         classesDeclareMethodName(hierarchy, Arrays.asList(implementingClasses), method, newName);
     if (foundInImplementingClasses != null)
       result.addAll(Arrays.asList(foundInImplementingClasses));
     return result.toArray(new IMethod[result.size()]);
   } finally {
     if (pm != null) {
       pm.done();
     }
   }
 }
 /*
  * @see TypeHierarchyContentProvider.getTypesInHierarchy
  */
 @Override
 protected final void getTypesInHierarchy(IType type, List<IType> res) {
   ITypeHierarchy hierarchy = getHierarchy();
   if (hierarchy != null) {
     IType[] types = hierarchy.getSubtypes(type);
     if (isObject(type)) {
       for (int i = 0; i < types.length; i++) {
         IType curr = types[i];
         if (!isAnonymousFromInterface(
             curr)) { // no anonymous classes on 'Object' -> will be children of interface
           res.add(curr);
         }
       }
     } else {
       boolean isHierarchyOnType = (hierarchy.getType() != null);
       boolean isClass = !Flags.isInterface(hierarchy.getCachedFlags(type));
       if (isClass || isHierarchyOnType) {
         for (int i = 0; i < types.length; i++) {
           res.add(types[i]);
         }
       } else {
         for (int i = 0; i < types.length; i++) {
           IType curr = types[i];
           // no classes implementing interfaces, only if anonymous
           if (Flags.isInterface(hierarchy.getCachedFlags(curr)) || isAnonymous(curr)) {
             res.add(curr);
           }
         }
       }
     }
   }
 }
Beispiel #3
0
  /**
   * Returns all activities found in the given project (including those in libraries, except for
   * android.jar itself)
   *
   * @param project the project
   * @return a list of activity classes as fully qualified class names
   */
  @SuppressWarnings("restriction") // BinaryType
  @NonNull
  public static List<String> getProjectActivities(IProject project) {
    final List<String> activities = new ArrayList<String>();
    try {
      final IJavaProject javaProject = BaseProjectHelper.getJavaProject(project);
      if (javaProject != null) {
        IType[] activityTypes = new IType[0];
        IType activityType = javaProject.findType(SdkConstants.CLASS_ACTIVITY);
        if (activityType != null) {
          ITypeHierarchy hierarchy =
              activityType.newTypeHierarchy(javaProject, new NullProgressMonitor());
          activityTypes = hierarchy.getAllSubtypes(activityType);
          for (IType type : activityTypes) {
            if (type instanceof BinaryType
                && (type.getClassFile() == null || type.getClassFile().getResource() == null)) {
              continue;
            }
            activities.add(type.getFullyQualifiedName());
          }
        }
      }
    } catch (CoreException e) {
      AdtPlugin.log(e, null);
    }

    return activities;
  }
    /** {@inheritDoc} */
    public Object[] getChildren(Object element) {
      // AspectJ Change begin
      if (element instanceof ICompilationUnit) {
        element = AJCompilationUnitManager.mapToAJCompilationUnit((ICompilationUnit) element);
      }
      // AspectJ Change end

      if (fShowOnlyMainType) {
        if (element instanceof ICompilationUnit) {
          element = getMainType((ICompilationUnit) element);
        } else if (element instanceof IClassFile) {
          element = getMainType((IClassFile) element);
        }

        if (element == null) return NO_CHILDREN;
      }

      if (fShowInheritedMembers && element instanceof IType) {
        IType type = (IType) element;
        if (type.getDeclaringType() == null) {
          ITypeHierarchy th = getSuperTypeHierarchy(type);
          if (th != null) {
            List children = new ArrayList();
            IType[] superClasses = th.getAllSupertypes(type);
            children.addAll(Arrays.asList(super.getChildren(type)));
            for (int i = 0, scLength = superClasses.length; i < scLength; i++)
              children.addAll(Arrays.asList(super.getChildren(superClasses[i])));
            return children.toArray();
          }
        }
      }
      return super.getChildren(element);
    }
Beispiel #5
0
 public List<IType> getSupertypes() throws JavaModelException {
   ITypeHierarchy typeHierarchy = SuperTypeHierarchyCache.getTypeHierarchy(_type);
   List<IType> types = new LinkedList<IType>();
   types.add(_type);
   for (IType type : typeHierarchy.getAllSupertypes(_type)) {
     types.add(type);
   }
   return types;
 }
 @Override
 protected IType getParentType(IType type) {
   ITypeHierarchy hierarchy = getHierarchy();
   if (hierarchy != null) {
     return hierarchy.getSuperclass(type);
     // don't handle interfaces
   }
   return null;
 }
 private int getDepth(ITypeHierarchy hierarchy, IType input) {
   int count = 0;
   IType superType = hierarchy.getSuperclass(input);
   while (superType != null) {
     count++;
     superType = hierarchy.getSuperclass(superType);
   }
   return count;
 }
 public int getExpandLevel() {
   ITypeHierarchy hierarchy = getHierarchy();
   if (hierarchy != null) {
     IType input = hierarchy.getType();
     if (input != null) {
       return getDepth(hierarchy, input) + 2;
     } else {
       return 5;
     }
   }
   return 2;
 }
Beispiel #9
0
 public List<IType> getSubtypesInProject(IJavaProject project) throws JavaModelException {
   // System.out.println("TypeCache.getSubtypesOf: " + type.getFullyQualifiedName() + " (hits=" +
   // SubTypeHierarchyCache.getCacheHits() + ",misses=" + SubTypeHierarchyCache.getCacheMisses()
   // + ")");
   ITypeHierarchy typeHierarchy =
       SubTypeHierarchyCache.getTypeHierarchyInProject(_type, project);
   List<IType> types = new LinkedList<IType>();
   IType[] subtypes = typeHierarchy.getAllSubtypes(_type);
   for (int subtypeNum = subtypes.length - 1; subtypeNum >= 0; subtypeNum--) {
     types.add(subtypes[subtypeNum]);
   }
   types.add(_type);
   return types;
 }
 /*
  * Ensure that the hierarchy using a working copy owner doesn't have primary working copy owner type
  * that are hidden by a type of the working copy owner
  * (regression test for bug 133372 [hierarchy] Type hierarchy returns type twice if executed on working copy layer)
  */
 public void testHierarchy() throws CoreException {
   try {
     createFile("/P/Y.java", "public class Y extends X {\n" + "}");
     WorkingCopyOwner owner = new TestWorkingCopyOwner();
     this.workingCopy =
         getCompilationUnit("/P/Y.java").getWorkingCopy(owner, null /*no progress*/);
     IType focus = getCompilationUnit("/P/X.java").getType("X");
     ITypeHierarchy hierarchy = focus.newTypeHierarchy(owner, null /*no progress*/);
     IType[] subtypes = hierarchy.getSubtypes(focus);
     assertTypesEqual("Unexpected types", "Y\n", subtypes);
   } finally {
     deleteFile("/P/Y.java");
   }
 }
Beispiel #11
0
 /**
  * @param progressMonitor
  * @param uriMappings
  * @param resource
  * @param methodsStack
  * @throws CoreException
  */
 private void resolveResourcesUriMappings(
     final Resource resource,
     final String uriTemplateFragment,
     final Map<ResolvedUriMapping, Stack<ResourceMethod>> uriMappings,
     final Stack<ResourceMethod> methodsStack,
     final IProgressMonitor progressMonitor)
     throws CoreException {
   // resource resourceMethods and subresources resourceMethods are treated the same way
   for (ResourceMethod resourceMethod : resource.getAllMethods()) {
     String uriPathTemplate =
         resolveURIPathTemplate(uriTemplateFragment, resource, resourceMethod);
     MediaTypeCapabilities mediaTypeCapabilities =
         resolveMediaTypeCapabilities(resource, resourceMethod);
     UriMapping resourceUriMapping = resourceMethod.getUriMapping();
     ResolvedUriMapping uriMapping =
         new ResolvedUriMapping(
             resourceUriMapping.getHTTPMethod(),
             uriPathTemplate,
             resourceUriMapping.getQueryParams(),
             mediaTypeCapabilities);
     @SuppressWarnings("unchecked")
     Stack<ResourceMethod> stack = (Stack<ResourceMethod>) methodsStack.clone();
     stack.add(resourceMethod);
     uriMappings.put(uriMapping, stack);
   }
   // TODO : verify support chain of subresource locators
   // TODO : stack resourceMethods and detect+prevent cycles
   for (ResourceMethod resourceMethod : resource.getSubresourceLocators()) {
     String uriPathTemplate =
         resolveURIPathTemplate(uriTemplateFragment, resource, resourceMethod);
     IType returnType = resourceMethod.getReturnType();
     if (returnType == null) {
       continue;
     }
     ITypeHierarchy subresourceTypeHierarchy =
         JdtUtils.resolveTypeHierarchy(returnType, false, progressMonitor);
     for (IType subresourceType : subresourceTypeHierarchy.getSubtypes(returnType)) {
       Resource subresource = getByType(subresourceType);
       if (subresource != null && !subresource.isRootResource()) {
         @SuppressWarnings("unchecked")
         Stack<ResourceMethod> stack = (Stack<ResourceMethod>) methodsStack.clone();
         stack.add(resourceMethod);
         resolveResourcesUriMappings(
             subresource, uriPathTemplate, uriMappings, stack, progressMonitor);
       }
     }
   }
 }
 /* (non-Javadoc)
  * @see org.eclipse.jdt.internal.ui.typehierarchy.TypeHierarchyContentProvider#getRootTypes(java.util.List)
  */
 @Override
 protected final void getRootTypes(List<IType> res) {
   ITypeHierarchy hierarchy = getHierarchy();
   if (hierarchy != null) {
     IType input = hierarchy.getType();
     if (input == null) {
       IType[] classes = hierarchy.getRootClasses();
       for (int i = 0; i < classes.length; i++) {
         res.add(classes[i]);
       }
       IType[] interfaces = hierarchy.getRootInterfaces();
       for (int i = 0; i < interfaces.length; i++) {
         res.add(interfaces[i]);
       }
     } else {
       if (Flags.isInterface(hierarchy.getCachedFlags(input))) {
         res.add(input);
       } else if (isAnonymousFromInterface(input)) {
         res.add(hierarchy.getSuperInterfaces(input)[0]);
       } else {
         IType[] roots = hierarchy.getRootClasses();
         for (int i = 0; i < roots.length; i++) {
           if (isObject(roots[i])) {
             res.add(roots[i]);
             return;
           }
         }
         res.addAll(Arrays.asList(roots)); // something wrong with the hierarchy
       }
     }
   }
 }
 /*
  * Create the list of focused jars or projects.
  */
 private static IJavaElement[] getFocusedElementsAndTypes(
     SearchPattern pattern, IJavaElement focusElement, ObjectVector superTypes)
     throws JavaModelException {
   if (pattern instanceof MethodPattern) {
     // For method pattern, it needs to walk along the focus type super hierarchy
     // and add jars/projects of all the encountered types.
     IType type = (IType) pattern.focus.getAncestor(IJavaElement.TYPE);
     MethodPattern methodPattern = (MethodPattern) pattern;
     String selector = new String(methodPattern.selector);
     int parameterCount = methodPattern.parameterCount;
     ITypeHierarchy superHierarchy = type.newSupertypeHierarchy(null);
     IType[] allTypes = superHierarchy.getAllSupertypes(type);
     int length = allTypes.length;
     SimpleSet focusSet = new SimpleSet(length + 1);
     if (focusElement != null) focusSet.add(focusElement);
     for (int i = 0; i < length; i++) {
       IMethod[] methods = allTypes[i].getMethods();
       int mLength = methods.length;
       for (int m = 0; m < mLength; m++) {
         if (parameterCount == methods[m].getNumberOfParameters()
             && methods[m].getElementName().equals(selector)) {
           IPackageFragmentRoot root =
               (IPackageFragmentRoot) allTypes[i].getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
           IJavaElement element = root.isArchive() ? root : root.getParent();
           focusSet.add(element);
           if (superTypes != null) superTypes.add(allTypes[i]);
           break;
         }
       }
     }
     // Rebuilt a contiguous array
     IJavaElement[] focuses = new IJavaElement[focusSet.elementSize];
     Object[] values = focusSet.values;
     int count = 0;
     for (int i = values.length; --i >= 0; ) {
       if (values[i] != null) {
         focuses[count++] = (IJavaElement) values[i];
       }
     }
     return focuses;
   }
   if (focusElement == null) return new IJavaElement[0];
   return new IJavaElement[] {focusElement};
 }
 private void checkOverridden(RefactoringStatus status, IProgressMonitor pm)
     throws JavaModelException {
   pm.beginTask("", 9); // $NON-NLS-1$
   pm.setTaskName(RefactoringCoreMessages.InlineMethodRefactoring_checking_overridden);
   MethodDeclaration decl = fSourceProvider.getDeclaration();
   IMethod method = (IMethod) decl.resolveBinding().getJavaElement();
   if (method == null || Flags.isPrivate(method.getFlags())) {
     pm.worked(8);
     return;
   }
   IType type = method.getDeclaringType();
   ITypeHierarchy hierarchy = type.newTypeHierarchy(new SubProgressMonitor(pm, 6));
   checkSubTypes(status, method, hierarchy.getAllSubtypes(type), new SubProgressMonitor(pm, 1));
   checkSuperClasses(
       status, method, hierarchy.getAllSuperclasses(type), new SubProgressMonitor(pm, 1));
   checkSuperInterfaces(
       status, method, hierarchy.getAllSuperInterfaces(type), new SubProgressMonitor(pm, 1));
   pm.setTaskName(""); // $NON-NLS-1$
 }
  /**
   * Remembers the selection of a right hand side type (proposal type) for a certain left hand side
   * (expected type) in content assist.
   *
   * @param lhs the left hand side / expected type
   * @param rhs the selected right hand side
   */
  public void remember(IType lhs, IType rhs) {
    Assert.isLegal(lhs != null);
    Assert.isLegal(rhs != null);

    try {
      if (!isCacheableRHS(rhs)) return;
      ITypeHierarchy hierarchy = rhs.newSupertypeHierarchy(getProgressMonitor());
      if (hierarchy.contains(lhs)) {
        // TODO remember for every member of the LHS hierarchy or not? Yes for now.
        IType[] allLHSides = hierarchy.getAllSupertypes(lhs);
        String rhsQualifiedName = rhs.getFullyQualifiedName();
        for (int i = 0; i < allLHSides.length; i++)
          rememberInternal(allLHSides[i], rhsQualifiedName);
        rememberInternal(lhs, rhsQualifiedName);
      }
    } catch (JavaModelException x) {
      JavaPlugin.log(x);
    }
  }
 /**
  * Finds a method declaration in a type's hierarchy. The search is top down, so this returns the
  * first declaration of the method in the hierarchy. This searches for a method with a name and
  * signature. Parameter types are only compared by the simple name, no resolving for the fully
  * qualified type name is done. Constructors are only compared by parameters, not the name.
  *
  * @param type Searches in this type's supertypes.
  * @param name The name of the method to find
  * @param paramTypes The type signatures of the parameters e.g. <code>{"QString;","I"}</code>
  * @param isConstructor If the method is a constructor
  * @return The first method found or null, if nothing found
  */
 private static IMethod findMethodDeclarationInHierarchy(
     ITypeHierarchy hierarchy, IType type, String name, String[] paramTypes, boolean isConstructor)
     throws JavaModelException {
   IType[] superTypes = hierarchy.getAllSupertypes(type);
   for (int i = superTypes.length - 1; i >= 0; i--) {
     IMethod first = JavaModelUtil.findMethod(name, paramTypes, isConstructor, superTypes[i]);
     if (first != null && !Flags.isPrivate(first.getFlags())) {
       // the order getAllSupertypes does make assumptions of the order of inner elements -> search
       // recursively
       IMethod res =
           findMethodDeclarationInHierarchy(
               hierarchy, first.getDeclaringType(), name, paramTypes, isConstructor);
       if (res != null) {
         return res;
       }
       return first;
     }
   }
   return null;
 }
  // -------
  private static IMethod[] classesDeclareMethodName(
      ITypeHierarchy hier, List<IType> classes, IMethod method, String newName)
      throws CoreException {
    Set<IMethod> result = new HashSet<>();
    IType type = method.getDeclaringType();
    List<IType> subtypes = Arrays.asList(hier.getAllSubtypes(type));

    int parameterCount = method.getParameterTypes().length;
    boolean isMethodPrivate = JdtFlags.isPrivate(method);

    for (Iterator<IType> iter = classes.iterator(); iter.hasNext(); ) {
      IType clazz = iter.next();
      IMethod[] methods = clazz.getMethods();
      boolean isSubclass = subtypes.contains(clazz);
      for (int j = 0; j < methods.length; j++) {
        IMethod foundMethod =
            Checks.findMethod(newName, parameterCount, false, new IMethod[] {methods[j]});
        if (foundMethod == null) continue;
        if (isSubclass || type.equals(clazz)) result.add(foundMethod);
        else if ((!isMethodPrivate) && (!JdtFlags.isPrivate(methods[j]))) result.add(foundMethod);
      }
    }
    return result.toArray(new IMethod[result.size()]);
  }
 public static XArrayList<IJavaElement> getSuperInterfaces(IJavaElement type) throws Exception {
   ITypeHierarchy h = ((IType) type).newTypeHierarchy(null);
   return IJavaElementAnalyzer.convertArray2XArrayList(h.getSuperInterfaces((IType) type));
 }