public static String bestNameableType(ITypeBinding type) { { String result_ = fqTypeName(type); if (result_ != null) return removeTypeParam(result_); } if (type.isCapture() || type.isWildcardType() || type.isTypeVariable()) { return bestNameableType(type.getErasure()); } // Find an interface or superclass being implemented. // For anonymous class, there can only be one. BUT for // local class, things are super f-ed up... if (type.isAnonymous()) { // any interfaces? if (type.getInterfaces().length > 0) { String result = fqTypeName(type.getInterfaces()[0]); assert (result != null); return removeTypeParam(result); } else { String result = fqTypeName(type.getSuperclass()); assert (result != null); return removeTypeParam(result); } } if (type.isLocal()) { // We can only make sense of this is there is just one // superclass+inferface. if (type.getInterfaces().length == 0) { // EASY! String result = fqTypeName(type.getSuperclass()); assert (result != null); return removeTypeParam(result); } else { // Well, maybe superclass is object? if (type.getSuperclass().getQualifiedName().equals(Object.class.getName())) { String result = fqTypeName(type.getInterfaces()[0]); assert (result != null); return removeTypeParam(result); } else { // Otherwise, return the superclass, I guess, but print a warning: String result = fqTypeName(type.getSuperclass()); assert (result != null); System.err.println("Local class has multiple supertypes..." + type.getBinaryName()); return removeTypeParam(result); } } } return Utilities.impossible(); }
/** * Adds the specified method binding to the search results. * * @param calledMethodBinding * @param node */ protected void addMethodCall(IMethodBinding calledMethodBinding, ASTNode node) { try { if (calledMethodBinding != null) { fProgressMonitor.worked(1); ITypeBinding calledTypeBinding = calledMethodBinding.getDeclaringClass(); IType calledType = null; if (!calledTypeBinding.isAnonymous()) { calledType = (IType) calledTypeBinding.getJavaElement(); } else { if (!"java.lang.Object" .equals(calledTypeBinding.getSuperclass().getQualifiedName())) { // $NON-NLS-1$ calledType = (IType) calledTypeBinding.getSuperclass().getJavaElement(); } else { calledType = (IType) calledTypeBinding.getInterfaces()[0].getJavaElement(); } } IMethod calledMethod = findIncludingSupertypes(calledMethodBinding, calledType, fProgressMonitor); IMember referencedMember = null; if (calledMethod == null) { if (calledMethodBinding.isConstructor() && calledMethodBinding.getParameterTypes().length == 0) { referencedMember = calledType; } } else { if (calledType.isInterface()) { calledMethod = findImplementingMethods(calledMethod); } if (!isIgnoredBySearchScope(calledMethod)) { referencedMember = calledMethod; } } final int position = node.getStartPosition(); final int number = fCompilationUnit.getLineNumber(position); fSearchResults.addMember( fMember, referencedMember, position, position + node.getLength(), number < 1 ? 1 : number); } } catch (JavaModelException jme) { JavaPlugin.log(jme); } }
/** * Ensures that creating a DOM AST and computing the bindings takes the owner's working copies * into account. * * @deprecated using deprecated code */ public void testParseCompilationUnit3() throws CoreException { try { createJavaProject("P1", new String[] {"src"}, new String[] {"JCL_LIB", "lib"}, "bin"); // create X.class in lib folder /* Evaluate the following in a scrapbook: org.eclipse.jdt.core.tests.model.ModifyingResourceTests.generateClassFile( "X", "public class X {\n" + "}") */ byte[] bytes = new byte[] { -54, -2, -70, -66, 0, 3, 0, 45, 0, 13, 1, 0, 1, 88, 7, 0, 1, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 7, 0, 3, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 12, 0, 5, 0, 6, 10, 0, 4, 0, 8, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, 0, 6, 88, 46, 106, 97, 118, 97, 0, 33, 0, 2, 0, 4, 0, 0, 0, 0, 0, 1, 0, 1, 0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 9, -79, 0, 0, 0, 1, 0, 10, 0, 0, 0, 6, 0, 1, 0, 0, 0, 1, 0, 1, 0, 11, 0, 0, 0, 2, 0, 12, }; this.createFile("P1/lib/X.class", bytes); // create libsrc and attach source createFolder("P1/libsrc"); createFile("P1/libsrc/X.java", "public class X extends Y {\n" + "}"); IPackageFragmentRoot lib = getPackageFragmentRoot("P1/lib"); lib.attachSource(new Path("/P1/libsrc"), null, null); // create Y.java in src folder createFile("P1/src/Y.java", ""); // create working copy on Y.java TestWorkingCopyOwner owner = new TestWorkingCopyOwner(); this.workingCopy = getCompilationUnit("P1/src/Y.java").getWorkingCopy(owner, null); this.workingCopy.getBuffer().setContents("public class Y {\n" + "}"); this.workingCopy.makeConsistent(null); // parse and resolve class file IClassFile classFile = getClassFile("P1/lib/X.class"); ASTParser parser = ASTParser.newParser(AST.JLS2); parser.setSource(classFile); parser.setResolveBindings(true); parser.setWorkingCopyOwner(owner); CompilationUnit cu = (CompilationUnit) parser.createAST(null); List types = cu.types(); assertEquals("Unexpected number of types in AST", 1, types.size()); TypeDeclaration type = (TypeDeclaration) types.get(0); ITypeBinding typeBinding = type.resolveBinding(); ITypeBinding superType = typeBinding.getSuperclass(); assertEquals( "Unexpected super type", "Y", superType == null ? "<null>" : superType.getQualifiedName()); } finally { deleteProject("P1"); } }
private boolean initializeAndCollectInhData( IMethodBinding binding, List<MethodPathItem> inhMethods) { if (binding == null) return false; // check if method is abstract if (Modifier.isAbstract(binding.getModifiers())) return false; ITypeBinding declTypeBinding = binding.getDeclaringClass(); // check only for classes if (declTypeBinding == null || !declTypeBinding.isClass()) return false; Set<String> checkedInterfaces = new HashSet<String>(); // (recursively) collects all keys of methods in abstract classes which // belongs to this declaration OverridingRelationUtils.collectSimilarMethodKeysInSuperClasses( binding, declTypeBinding.getSuperclass(), inhMethods, checkedInterfaces); // (recursively) collects all keys of methods in interfaces which // belongs to this declaration OverridingRelationUtils.collectSimilarMethodKeysInInterfaces( binding, declTypeBinding.getInterfaces(), inhMethods, checkedInterfaces); // the set should contain at least one inherited method if (inhMethods.size() == 0) return false; return true; }
private boolean entryMatchesRenamedMethod( File javaFile, Multimap<String, String> invokers, IMethodBinding methodBinding, String entry) { try { String[] columns = entry.split(";"); String classNamespace = columns[1]; String renamedMethod = columns[2]; String methodBindingClassNamespace = (methodBinding.getKey().split("\\."))[0]; if (simplifyMethodSignature(methodBinding).contains(renamedMethod)) { if (classesNamesMatches(methodBindingClassNamespace, classNamespace)) { return true; } else { /*the method belongs to a superclass or interface*/ ITypeBinding declaringClass = methodBinding.getDeclaringClass(); ITypeBinding superClass = declaringClass.getSuperclass(); ITypeBinding[] interfaceBinds = declaringClass.getInterfaces(); // [MISSING:FrameDecoder] if (superClass.toString().contains("MISSING")) { String superClassRelaxed = (superClass.toString().split(":")[1]); superClassRelaxed = superClassRelaxed.substring(0, superClassRelaxed.length() - 1); if (classesNamesMatches(superClassRelaxed, classNamespace)) { return true; } } else { if (classesNamesMatches(superClass.getKey(), classNamespace)) { return true; } else { for (ITypeBinding interfce : interfaceBinds) { if (interfce.toString().contains("MISSING")) { String interfaceRelaxed = (interfce.toString().split(":")[1]); interfaceRelaxed = interfaceRelaxed.substring(0, interfaceRelaxed.length() - 1); if (classesNamesMatches(interfaceRelaxed, classNamespace)) { return true; } } else { if (classesNamesMatches(interfce.getKey(), classNamespace)) { return true; } } } } } return false; } } else { return false; } } catch (NullPointerException e) { return false; } }
public static void collectAllInheritedTypes(ITypeBinding type, Set<ITypeBinding> inheritedTypes) { collectAllInterfaces(type, inheritedTypes); while (true) { type = type.getSuperclass(); if (type == null) { break; } inheritedTypes.add(type); } }
public void checkInput(RefactoringStatus status, String methodName, ASTNode destination) { ITypeBinding[] arguments = getArgumentTypes(); ITypeBinding type = ASTNodes.getEnclosingType(destination); status.merge(Checks.checkMethodInType(type, methodName, arguments)); ITypeBinding superClass = type.getSuperclass(); if (superClass != null) { status.merge(Checks.checkMethodInHierarchy(superClass, methodName, null, arguments)); } for (ITypeBinding superInterface : type.getInterfaces()) { status.merge(Checks.checkMethodInHierarchy(superInterface, methodName, null, arguments)); } }
public static boolean typeIsAssignableFrom(ITypeBinding typeBinding, Class<?> specifiedClass) { String className = specifiedClass.getCanonicalName(); while (typeBinding != null) { if (className.equals(typeBinding.getErasure().getQualifiedName())) { return true; } if (typeImplementsInterfaceDirectly(typeBinding, className)) { return true; } typeBinding = typeBinding.getSuperclass(); } return false; }
public static void collectAllInterfaces(ITypeBinding type, Set<ITypeBinding> interfaces) { Deque<ITypeBinding> typeQueue = Lists.newLinkedList(); while (type != null) { typeQueue.add(type); type = type.getSuperclass(); } while (!typeQueue.isEmpty()) { ITypeBinding nextType = typeQueue.poll(); List<ITypeBinding> newInterfaces = Arrays.asList(nextType.getInterfaces()); interfaces.addAll(newInterfaces); typeQueue.addAll(newInterfaces); } }
public Types(AST ast) { this.ast = ast; // Find core java types. javaObjectType = ast.resolveWellKnownType("java.lang.Object"); javaClassType = ast.resolveWellKnownType("java.lang.Class"); javaCloneableType = ast.resolveWellKnownType("java.lang.Cloneable"); javaStringType = ast.resolveWellKnownType("java.lang.String"); javaThrowableType = ast.resolveWellKnownType("java.lang.Throwable"); javaVoidType = ast.resolveWellKnownType("java.lang.Void"); ITypeBinding binding = ast.resolveWellKnownType("java.lang.Integer"); javaNumberType = binding.getSuperclass(); // Create core IOS types. NSCopying = mapIOSType(IOSTypeBinding.newInterface("NSCopying", javaCloneableType)); NSObject = mapIOSType(IOSTypeBinding.newClass("NSObject", javaObjectType)); NSNumber = mapIOSType(IOSTypeBinding.newClass("NSNumber", javaNumberType, NSObject)); NSString = mapIOSType(IOSTypeBinding.newClass("NSString", javaStringType, NSObject)); NSException = mapIOSType(IOSTypeBinding.newClass("NSException", javaThrowableType, NSObject)); IOSClass = mapIOSType(IOSTypeBinding.newUnmappedClass("IOSClass")); mapIOSType(IOSTypeBinding.newUnmappedClass("NSZone")); idType = mapIOSType(IOSTypeBinding.newUnmappedClass("id")); initializeArrayTypes(); initializeTypeMap(); initializeCommonJavaTypes(); populatePrimitiveAndWrapperTypeMaps(); ITypeBinding voidType = ast.resolveWellKnownType("void"); // Commonly used methods. retainMethod = IOSMethodBinding.newMethod(NameTable.RETAIN_METHOD, Modifier.PUBLIC, idType, NSObject); releaseMethod = IOSMethodBinding.newMethod(NameTable.RELEASE_METHOD, Modifier.PUBLIC, voidType, NSObject); autoreleaseMethod = IOSMethodBinding.newMethod(NameTable.AUTORELEASE_METHOD, Modifier.PUBLIC, idType, NSObject); allocMethod = IOSMethodBinding.newMethod(NameTable.ALLOC_METHOD, Modifier.PUBLIC, idType, NSObject); deallocMethod = IOSMethodBinding.newMethod(NameTable.DEALLOC_METHOD, Modifier.PUBLIC, idType, NSObject); }
/** * Finds the declaration for a given method and receiver in the same way that the ObjC compiler * will search for a declaration. */ private IMethodBinding getFirstDeclaration(String methodSig, ITypeBinding type) { if (type == null) { return null; } type = type.getTypeDeclaration(); for (IMethodBinding declaredMethod : type.getDeclaredMethods()) { if (methodSig.equals(getObjCMethodSignature(declaredMethod))) { return declaredMethod; } } List<ITypeBinding> supertypes = Lists.newArrayList(); supertypes.addAll(Arrays.asList(type.getInterfaces())); supertypes.add(type.isTypeVariable() ? 0 : supertypes.size(), type.getSuperclass()); for (ITypeBinding supertype : supertypes) { IMethodBinding result = getFirstDeclaration(methodSig, supertype); if (result != null) { return result; } } return null; }
private static boolean typeHierarchyHelper( HierarchyCallback callback, ITypeBinding root, boolean start_at_root) { // First, visit the type, then collect super-types if (start_at_root) { boolean result = callback.nextType(root); if (!result) return result; } { // super-class ITypeBinding sup = root.getSuperclass(); if (sup != null) { boolean result = typeHierarchyHelper(callback, sup, true); if (!result) return result; } } // interfaces for (ITypeBinding face : root.getInterfaces()) { boolean result = typeHierarchyHelper(callback, face, true); if (!result) return result; } return true; // if you get this far, return value doesn't matter. }
/** * Ensures that creating a DOM AST and computing the bindings takes the owner's working copies * into account. * * @deprecated using deprecated code */ public void testParseCompilationUnit2() throws CoreException { TestWorkingCopyOwner owner = new TestWorkingCopyOwner(); this.workingCopy = getCompilationUnit("P/Y.java").getWorkingCopy(owner, null); this.workingCopy.getBuffer().setContents("public class Y {\n" + "}"); this.workingCopy.makeConsistent(null); char[] source = ("public class Z extends Y {\n" + "}").toCharArray(); ASTParser parser = ASTParser.newParser(AST.JLS2); parser.setSource(source); parser.setUnitName("Z.java"); parser.setProject(getJavaProject("P")); parser.setWorkingCopyOwner(owner); parser.setResolveBindings(true); CompilationUnit cu = (CompilationUnit) parser.createAST(null); List types = cu.types(); assertEquals("Unexpected number of types in AST", 1, types.size()); TypeDeclaration type = (TypeDeclaration) types.get(0); ITypeBinding typeBinding = type.resolveBinding(); assertNotNull("No binding", typeBinding); assertEquals("Unexpected super type", "Y", typeBinding.getSuperclass().getQualifiedName()); }