public ITypeModel getBodyType() { IMethod iMethod = (IMethod) tm; try { String[] parameterTypes = iMethod.getParameterTypes(); for (String s : parameterTypes) { if (s.contains("java")) // $NON-NLS-1$ { continue; } String returnType = s; if (returnType.startsWith("Q") && returnType.endsWith(";")) { // $NON-NLS-1$ //$NON-NLS-2$ IType ownerType = (IType) iMethod.getAncestor(IJavaElement.TYPE); String[][] resolveType = ownerType.resolveType(returnType.substring(1, returnType.length() - 1)); if (resolveType.length == 1) { IType findType = ownerType.getJavaProject().findType(resolveType[0][0] + '.' + resolveType[0][1]); if (findType != null && findType instanceof SourceType) { return new JDTType(findType); } } } } } catch (Exception e) { throw new IllegalStateException(e); } return null; }
/** Create & return a new configuration based on the specified <code>IType</code>. */ protected ILaunchConfiguration createConfiguration(IType type) { String launcherName = MainLauncher.this.getLauncherName(); ILaunchConfigurationType configType = MainLauncher.this.getLaunchConfigurationType(); ILaunchConfigurationWorkingCopy wc = null; try { wc = configType.newInstance(null, launcherName); } catch (CoreException exception) { JDIDebugUIPlugin.log(exception); return null; } wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, type.getFullyQualifiedName()); wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, type.getJavaProject().getElementName()); MainLauncher.this.setAdditionalAttributes(wc); ILaunchConfiguration config = null; try { config = wc.doSave(); } catch (CoreException exception) { JDIDebugUIPlugin.log(exception); } return config; }
private StringBuffer composeTypeReference(IType type) { StringBuffer buffer = new StringBuffer(); buffer.append(type.getJavaProject().getElementName()); buffer.append(PROJECT_END_CHAR); buffer.append(type.getFullyQualifiedName()); return buffer; }
/* (non-Javadoc) * @see org.eclipse.jdt.debug.ui.launchConfigurations.JavaLaunchShortcut#createConfiguration(org.eclipse.jdt.core.IType) */ @Override protected ILaunchConfiguration createConfiguration(IType type) { ILaunchConfiguration config = null; ILaunchConfigurationWorkingCopy wc = null; try { ILaunchConfigurationType configType = getConfigurationType(); wc = configType.newInstance( null, getLaunchManager().generateLaunchConfigurationName(type.getTypeQualifiedName('.'))); // wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, // type.getFullyQualifiedName()); wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, type.getJavaProject().getElementName()); wc.setMappedResources(new IResource[] {type.getUnderlyingResource()}); config = wc.doSave(); } catch (CoreException exception) { MessageDialog.openError( JDIDebugUIPlugin.getActiveWorkbenchShell(), LauncherMessages.JavaLaunchShortcut_3, exception.getStatus().getMessage()); } return config; }
public static boolean isTestCase(ICompilationUnit compilationUnit) { IType primaryType = compilationUnit.findPrimaryType(); if (primaryType == null) { return false; } ProjectPreferences prefs = Preferences.forProject(primaryType.getJavaProject()); return prefs.getTestClassNamePattern().evaluate(primaryType).isTestCase(); }
public IMethod findMethod(IType type, String name) throws JavaModelException { for (IMethod m : type.getMethods()) if (m.getElementName().equals(name)) return m; String superType = type.getSuperclassName(); if (superType != null) for (String[] resolved : type.resolveType(superType)) { IType type2 = TypeUtil.findType(type.getJavaProject(), resolved[0] + "." + resolved[1]); if (type2 != null) return findMethod(type2, name); } return null; }
public void testExtractInterfaceFromInterface2() throws Exception { String className = "A"; String extendingInterfaceName = "I1"; String newInterfaceName = "B"; IType clas = getType(createCUfromTestFile(getPackageP(), getTopLevelTypeName(className)), className); ICompilationUnit cu = clas.getCompilationUnit(); IPackageFragment pack = (IPackageFragment) cu.getParent(); getType( createCUfromTestFile(getPackageP(), getTopLevelTypeName(extendingInterfaceName)), extendingInterfaceName); IPackageFragmentRoot root = RefactoringTestSetup.getDefaultSourceFolder(); assertNotNull(root); IPackageFragment p2 = root.createPackageFragment("p2", true, null); getType(createCUfromTestFile(p2, getTopLevelTypeName("I2")), "I2"); ExtractInterfaceProcessor processor = new ExtractInterfaceProcessor( clas, JavaPreferencesSettings.getCodeGenerationSettings(clas.getJavaProject())); Refactoring ref = new ProcessorBasedRefactoring(processor); processor.setTypeName(newInterfaceName); assertEquals( "interface name should be accepted", RefactoringStatus.OK, processor.checkTypeName(newInterfaceName).getSeverity()); IMember[] extractableMembers = processor.getExtractableMembers(); final IMember[] members = new IMember[extractableMembers.length - 1]; List<IMember> list = new ArrayList<>(); for (IMember iMember : extractableMembers) { if (!(iMember instanceof IField)) { list.add(iMember); } } processor.setExtractedMembers(list.toArray(members)); processor.setReplace(true); processor.setAnnotations(false); RefactoringStatus performRefactoring = performRefactoring(ref); assertEquals("was supposed to pass", null, performRefactoring); assertEqualLines( "incorrect changes in " + className, getFileContents(getOutputTestFileName(className)), cu.getSource()); ICompilationUnit interfaceCu = pack.getCompilationUnit(newInterfaceName + ".java"); assertEqualLines( "incorrect interface created", getFileContents(getOutputTestFileName(newInterfaceName)), interfaceCu.getSource()); }
@Override public IHyperlink[] createHyperlinksByOffset( XtextResource resource, int offset, boolean createMultipleHyperlinks) { IHyperlink[] links = super.createHyperlinksByOffset(resource, offset, createMultipleHyperlinks); EObject eo = eObjectAtOffsetHelper.resolveElementAt(resource, offset); if (eo instanceof ControllerHandledValueProperty) { INode n = NodeModelUtils.getNode(eo); if (n != null) { INode currentNode = NodeModelUtils.findLeafNodeAtOffset(n, offset); List<INode> l = NodeModelUtils.findNodesForFeature( eo, FXGraphPackage.Literals.CONTROLLER_HANDLED_VALUE_PROPERTY__METHODNAME); if (l.contains(currentNode)) { Region region = new Region(currentNode.getOffset(), currentNode.getLength()); Model m = (Model) eo.eResource().getContents().get(0); if (m != null) { ComponentDefinition def = m.getComponentDef(); if (def != null) { if (def.getController() != null && def.getController().getType() != null) { IType t = getJDTType(def.getController().getType()); if (t != null) { IFXCtrlClass fxClass = FXPlugin.getClassmodel().findCtrlClass(t.getJavaProject(), t); if (fxClass != null) { IFXCtrlEventMethod fxp = fxClass.getAllEventMethods().get(currentNode.getText()); if (fxp != null) { HyperlinkImpl h = new HyperlinkImpl(region, fxp.getJavaElement()); if (links == null || links.length == 0) { return new IHyperlink[] {h}; } else { IHyperlink[] rv = new IHyperlink[links.length + 1]; System.arraycopy(links, 0, rv, 0, rv.length); rv[rv.length - 1] = h; return rv; } } } } } } } } } } return links; }
public static IType getJavaTypeFromSignatureClassName(String className, IType contextType) { if (contextType == null || className == null) { return null; } try { return JdtUtils.getJavaType( contextType.getJavaProject().getProject(), JdtUtils.resolveClassNameBySignature(className, contextType)); } catch (IllegalArgumentException e) { // do Nothing } return null; }
@Test public void should_retrieve_template_from_preferences_for_test_case_project() throws Exception { // given when(classUnderTest.getJavaProject()).thenReturn(project); when(preferences.getMockingTemplate(project)).thenReturn("test-template-id"); // when dependencyMocker.mockDependencies(dependencies, classUnderTest, testCase, SOME_TEST_TYPE); // then verify(templateStore).get("test-template-id"); }
/** Invoked when the search button for the agent agent was clocked. */ protected void handleAgentNameSearchButtonSelected() { final IType[] types = searchAgentNames(); // Ask to the user final DebugTypeSelectionDialog mmsd = new DebugTypeSelectionDialog(getShell(), types, ""); // $NON-NLS-1$ if (mmsd.open() == Window.CANCEL) { return; } final IType type = (IType) mmsd.getFirstResult(); if (type != null) { this.agentNameTextField.setText(type.getFullyQualifiedName()); this.fProjText.setText(type.getJavaProject().getElementName()); } }
public static byte[] getClassContent(IJavaProject javaProject, String className) { if (javaProject == null || !javaProject.exists()) return null; String resourceName = className.replace('.', '/') + ".class"; try { IPath outPath = javaProject .getProject() .getLocation() .removeLastSegments(1) .append(javaProject.getOutputLocation()); outPath = outPath.addTrailingSeparator(); { URL url = toURL(outPath.append(resourceName)); if (url != null) { InputStream inputStream = url.openStream(); byte[] content = new byte[inputStream.available()]; inputStream.read(content); return content; } for (IProject project : javaProject.getProject().getReferencedProjects()) { if (!project.isOpen()) { continue; } IJavaProject javaReferencedProject = JavaCore.create(project); if (javaReferencedProject.exists()) { byte[] content = getClassContent(javaReferencedProject, className); if (content != null) { return content; } } } } IType type = javaProject.findType(className); if (type != null && type.exists()) { if (type.isBinary()) { return type.getClassFile().getBytes(); } else { IJavaProject typeProject = type.getJavaProject(); if (!javaProject.equals(typeProject)) { return getClassContent(typeProject, className); } } } } catch (Exception e) { e.printStackTrace(); } return null; }
protected ILaunchConfiguration createConfiguration(IType type) { ILaunchConfiguration config = null; ILaunchConfigurationWorkingCopy wc = null; try { ILaunchConfigurationType configType = getAJConfigurationType(); wc = configType.newInstance( null, getLaunchManager().generateLaunchConfigurationName(type.getElementName())); wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, type.getJavaProject().getElementName()); wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, type.getFullyQualifiedName()); config = wc.doSave(); } catch (CoreException exception) { reportErorr(exception); } return config; }
/** @see IJavaElementRequestor */ public void acceptType(IType type) { try { if (this.unitToSkip != null && this.unitToSkip.equals(type.getCompilationUnit())) { return; } char[] packageName = type.getPackageFragment().getElementName().toCharArray(); boolean isBinary = type instanceof BinaryType; // determine associated access restriction AccessRestriction accessRestriction = null; if (this.checkAccessRestrictions && (isBinary || !type.getJavaProject().equals(this.project))) { PackageFragmentRoot root = (PackageFragmentRoot) type.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT); ClasspathEntry entry = (ClasspathEntry) this.nameLookup.rootToResolvedEntries.get(root); if (entry != null) { // reverse map always contains resolved CP entry AccessRuleSet accessRuleSet = entry.getAccessRuleSet(); if (accessRuleSet != null) { // TODO (philippe) improve char[] <-> String conversions to avoid performing them on the // fly char[][] packageChars = CharOperation.splitOn('.', packageName); char[] fileWithoutExtension = type.getElementName().toCharArray(); accessRestriction = accessRuleSet.getViolatedRestriction( CharOperation.concatWith(packageChars, fileWithoutExtension, '/')); } } } this.requestor.acceptType( packageName, type.getElementName().toCharArray(), null, type.getFlags(), accessRestriction); } catch (JavaModelException jme) { // ignore } }
@Override public Change createChange(IProgressMonitor pm) throws CoreException, OperationCanceledException { String project = null; IJavaProject javaProject = targetClass.getJavaProject(); if (javaProject != null) project = javaProject.getElementName(); int flags = JavaRefactoringDescriptor.JAR_MIGRATION | JavaRefactoringDescriptor.JAR_REFACTORING | RefactoringDescriptor.STRUCTURAL_CHANGE | RefactoringDescriptor.MULTI_CHANGE; try { if (targetClass.isAnonymous() || targetClass.isLocal()) flags |= JavaRefactoringDescriptor.JAR_SOURCE_ATTACHMENT; } catch (JavaModelException exception) { JavaPlugin.log(exception); } // TODO need to properly initialize the arguments so that this refactoring becomes recordable final Map arguments = new HashMap(); String description = "Convert Mutable into Immutable Class"; String comment = "Convert Mutable into Immutable Class"; final JavaRefactoringDescriptor descriptor = new JavaRefactoringDescriptor("fixme", project, description, comment, arguments, flags) {}; // JDTRefactoringDescriptor(IJavaRefactorings.ENCAPSULATE_FIELD, project, description, comment, // arguments, flags); final DynamicValidationRefactoringChange result = new DynamicValidationRefactoringChange(descriptor, getName()); TextChange[] changes = fChangeManager.getAllChanges(); pm.beginTask("ConvertToParallelArray create changes", changes.length); for (int i = 0; i < changes.length; i++) { result.add(changes[i]); pm.worked(1); } pm.done(); return result; }
/** Configure this type hierarchy based on the given potential subtypes. */ private void buildFromPotentialSubtypes( String[] allPotentialSubTypes, HashSet localTypes, IProgressMonitor monitor) { IType focusType = getType(); // substitute compilation units with working copies HashMap wcPaths = new HashMap(); // a map from path to working copies int wcLength; org.eclipse.jdt.core.ICompilationUnit[] workingCopies = this.hierarchy.workingCopies; if (workingCopies != null && (wcLength = workingCopies.length) > 0) { String[] newPaths = new String[wcLength]; for (int i = 0; i < wcLength; i++) { org.eclipse.jdt.core.ICompilationUnit workingCopy = workingCopies[i]; String path = workingCopy.getPath().toString(); wcPaths.put(path, workingCopy); newPaths[i] = path; } int potentialSubtypesLength = allPotentialSubTypes.length; System.arraycopy( allPotentialSubTypes, 0, allPotentialSubTypes = new String[potentialSubtypesLength + wcLength], 0, potentialSubtypesLength); System.arraycopy(newPaths, 0, allPotentialSubTypes, potentialSubtypesLength, wcLength); } int length = allPotentialSubTypes.length; // inject the compilation unit of the focus type (so that types in // this cu have special visibility permission (this is also usefull // when the cu is a working copy) Openable focusCU = (Openable) focusType.getCompilationUnit(); String focusPath = null; if (focusCU != null) { focusPath = focusCU.getPath().toString(); if (length > 0) { System.arraycopy( allPotentialSubTypes, 0, allPotentialSubTypes = new String[length + 1], 0, length); allPotentialSubTypes[length] = focusPath; } else { allPotentialSubTypes = new String[] {focusPath}; } length++; } /* * Sort in alphabetical order so that potential subtypes are grouped per project */ Arrays.sort(allPotentialSubTypes); ArrayList potentialSubtypes = new ArrayList(); try { // create element infos for subtypes HandleFactory factory = new HandleFactory(); IJavaProject currentProject = null; if (monitor != null) monitor.beginTask( "", length * 2 /* 1 for build binding, 1 for connect hierarchy*/); // $NON-NLS-1$ for (int i = 0; i < length; i++) { try { String resourcePath = allPotentialSubTypes[i]; // skip duplicate paths (e.g. if focus path was injected when it was already a potential // subtype) if (i > 0 && resourcePath.equals(allPotentialSubTypes[i - 1])) continue; Openable handle; org.eclipse.jdt.core.ICompilationUnit workingCopy = (org.eclipse.jdt.core.ICompilationUnit) wcPaths.get(resourcePath); if (workingCopy != null) { handle = (Openable) workingCopy; } else { handle = resourcePath.equals(focusPath) ? focusCU : factory.createOpenable(resourcePath, this.scope); if (handle == null) continue; // match is outside classpath } IJavaProject project = handle.getJavaProject(); if (currentProject == null) { currentProject = project; potentialSubtypes = new ArrayList(5); } else if (!currentProject.equals(project)) { // build current project buildForProject( (JavaProject) currentProject, potentialSubtypes, workingCopies, localTypes, monitor); currentProject = project; potentialSubtypes = new ArrayList(5); } potentialSubtypes.add(handle); } catch (JavaModelException e) { continue; } } // build last project try { if (currentProject == null) { // case of no potential subtypes currentProject = focusType.getJavaProject(); if (focusType.isBinary()) { potentialSubtypes.add(focusType.getClassFile()); } else { potentialSubtypes.add(focusType.getCompilationUnit()); } } buildForProject( (JavaProject) currentProject, potentialSubtypes, workingCopies, localTypes, monitor); } catch (JavaModelException e) { // ignore } // Compute hierarchy of focus type if not already done (case of a type with potential subtypes // that are not real subtypes) if (!this.hierarchy.contains(focusType)) { try { currentProject = focusType.getJavaProject(); potentialSubtypes = new ArrayList(); if (focusType.isBinary()) { potentialSubtypes.add(focusType.getClassFile()); } else { potentialSubtypes.add(focusType.getCompilationUnit()); } buildForProject( (JavaProject) currentProject, potentialSubtypes, workingCopies, localTypes, monitor); } catch (JavaModelException e) { // ignore } } // Add focus if not already in (case of a type with no explicit super type) if (!this.hierarchy.contains(focusType)) { this.hierarchy.addRootClass(focusType); } } finally { if (monitor != null) monitor.done(); } }
private void buildForProject( JavaProject project, ArrayList potentialSubtypes, org.eclipse.jdt.core.ICompilationUnit[] workingCopies, HashSet localTypes, IProgressMonitor monitor) throws JavaModelException { // resolve int openablesLength = potentialSubtypes.size(); if (openablesLength > 0) { // copy vectors into arrays Openable[] openables = new Openable[openablesLength]; potentialSubtypes.toArray(openables); // sort in the order of roots and in reverse alphabetical order for .class file // since requesting top level types in the process of caching an enclosing type is // not supported by the lookup environment IPackageFragmentRoot[] roots = project.getPackageFragmentRoots(); int rootsLength = roots.length; final HashtableOfObjectToInt indexes = new HashtableOfObjectToInt(openablesLength); for (int i = 0; i < openablesLength; i++) { IJavaElement root = openables[i].getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT); int index; for (index = 0; index < rootsLength; index++) { if (roots[index].equals(root)) break; } indexes.put(openables[i], index); } Arrays.sort( openables, new Comparator() { public int compare(Object a, Object b) { int aIndex = indexes.get(a); int bIndex = indexes.get(b); if (aIndex != bIndex) return aIndex - bIndex; return ((Openable) b).getElementName().compareTo(((Openable) a).getElementName()); } }); IType focusType = getType(); boolean inProjectOfFocusType = focusType != null && focusType.getJavaProject().equals(project); org.eclipse.jdt.core.ICompilationUnit[] unitsToLookInside = null; if (inProjectOfFocusType) { org.eclipse.jdt.core.ICompilationUnit unitToLookInside = focusType.getCompilationUnit(); if (unitToLookInside != null) { int wcLength = workingCopies == null ? 0 : workingCopies.length; if (wcLength == 0) { unitsToLookInside = new org.eclipse.jdt.core.ICompilationUnit[] {unitToLookInside}; } else { unitsToLookInside = new org.eclipse.jdt.core.ICompilationUnit[wcLength + 1]; unitsToLookInside[0] = unitToLookInside; System.arraycopy(workingCopies, 0, unitsToLookInside, 1, wcLength); } } else { unitsToLookInside = workingCopies; } } SearchableEnvironment searchableEnvironment = project.newSearchableNameEnvironment(unitsToLookInside); this.nameLookup = searchableEnvironment.nameLookup; Map options = project.getOptions(true); // disable task tags to speed up parsing options.put(JavaCore.COMPILER_TASK_TAGS, ""); // $NON-NLS-1$ this.hierarchyResolver = new HierarchyResolver(searchableEnvironment, options, this, new DefaultProblemFactory()); if (focusType != null) { Member declaringMember = ((Member) focusType).getOuterMostLocalContext(); if (declaringMember == null) { // top level or member type if (!inProjectOfFocusType) { char[] typeQualifiedName = focusType.getTypeQualifiedName('.').toCharArray(); String[] packageName = ((PackageFragment) focusType.getPackageFragment()).names; if (searchableEnvironment.findType(typeQualifiedName, Util.toCharArrays(packageName)) == null) { // focus type is not visible in this project: no need to go further return; } } } else { // local or anonymous type Openable openable; if (declaringMember.isBinary()) { openable = (Openable) declaringMember.getClassFile(); } else { openable = (Openable) declaringMember.getCompilationUnit(); } localTypes = new HashSet(); localTypes.add(openable.getPath().toString()); this.hierarchyResolver.resolve(new Openable[] {openable}, localTypes, monitor); return; } } this.hierarchyResolver.resolve(openables, localTypes, monitor); } }
protected void reportDeclaration( MethodBinding methodBinding, MatchLocator locator, SimpleSet knownMethods) throws CoreException { ReferenceBinding declaringClass = methodBinding.declaringClass; IType type = locator.lookupType(declaringClass); if (type == null) return; // case of a secondary type // Report match for binary if (type.isBinary()) { IMethod method = null; TypeBinding[] parameters = methodBinding.original().parameters; int parameterLength = parameters.length; char[][] parameterTypes = new char[parameterLength][]; for (int i = 0; i < parameterLength; i++) { char[] typeName = parameters[i].qualifiedSourceName(); for (int j = 0, dim = parameters[i].dimensions(); j < dim; j++) { typeName = CharOperation.concat(typeName, new char[] {'[', ']'}); } parameterTypes[i] = typeName; } method = locator.createBinaryMethodHandle(type, methodBinding.selector, parameterTypes); if (method == null || knownMethods.addIfNotIncluded(method) == null) return; IResource resource = type.getResource(); if (resource == null) resource = type.getJavaProject().getProject(); IBinaryType info = locator.getBinaryInfo( (org.eclipse.jdt.internal.core.ClassFile) type.getClassFile(), resource); locator.reportBinaryMemberDeclaration( resource, method, methodBinding, info, SearchMatch.A_ACCURATE); return; } // When source is available, report match if method is found in the declaring type IResource resource = type.getResource(); if (declaringClass instanceof ParameterizedTypeBinding) declaringClass = ((ParameterizedTypeBinding) declaringClass).genericType(); ClassScope scope = ((SourceTypeBinding) declaringClass).scope; if (scope != null) { TypeDeclaration typeDecl = scope.referenceContext; AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(methodBinding.original()); if (methodDecl != null) { // Create method handle from method declaration String methodName = new String(methodBinding.selector); Argument[] arguments = methodDecl.arguments; int length = arguments == null ? 0 : arguments.length; String[] parameterTypes = new String[length]; for (int i = 0; i < length; i++) { char[][] typeName = arguments[i].type.getParameterizedTypeName(); parameterTypes[i] = Signature.createTypeSignature(CharOperation.concatWith(typeName, '.'), false); } IMethod method = type.getMethod(methodName, parameterTypes); if (method == null || knownMethods.addIfNotIncluded(method) == null) return; // Create and report corresponding match int offset = methodDecl.sourceStart; this.match = new MethodDeclarationMatch( method, SearchMatch.A_ACCURATE, offset, methodDecl.sourceEnd - offset + 1, locator.getParticipant(), resource); locator.report(this.match); } } }
/** @since 2.4 */ protected boolean isDerived(IType type) { return isDerived(type.getFullyQualifiedName(), type.getJavaProject()); }
/** * Resolves a type name in the context of the declaring type. * * @param refTypeSig the type name in signature notation (for example 'QVector') this can also * be an array type, but dimensions will be ignored. * @param declaringType the context for resolving (type where the reference was made in) * @return returns the fully qualified type name or build-in-type name. if a unresolved type * couldn't be resolved null is returned * @throws JavaModelException thrown when the type can not be accessed */ public IType resolveType(String refTypeSig, IType declaringType) throws JavaModelException { IJavaProject javaProject = declaringType.getJavaProject(); int arrayCount = Signature.getArrayCount(refTypeSig); char type = refTypeSig.charAt(arrayCount); if (type == Signature.C_UNRESOLVED) { String name = ""; // $NON-NLS-1$ int bracket = refTypeSig.indexOf(Signature.C_GENERIC_START, arrayCount + 1); if (bracket > 0) name = refTypeSig.substring(arrayCount + 1, bracket); else { int semi = refTypeSig.indexOf(Signature.C_SEMICOLON, arrayCount + 1); if (semi == -1) { throw new IllegalArgumentException(); } name = refTypeSig.substring(arrayCount + 1, semi); } String dotTypeName = "." + name; String dotBaseTypeName = null; String dotExtensionTypeName = null; int dotIndex = name.indexOf('.'); if (dotIndex != -1) { // We might get a fully qualified type name -- Qcom.apple.jingle.eo.MZProgramNodeType; IType resolvedType = javaProject.findType(name); if (resolvedType != null) { return resolvedType; } // If not, then this might be a nested type reference on another type, so let's split it // to look for that in our imports later dotBaseTypeName = "." + name.substring(0, dotIndex); dotExtensionTypeName = name.substring(dotIndex); } IImportDeclaration[] importDeclarations = declaringType.getCompilationUnit().getImports(); // Loop over the imports and look for the import of our symbol for (IImportDeclaration declaration : importDeclarations) { String importName = declaration.getElementName(); // If it's a .* import, then pop off the package name and lookup the type if (declaration.isOnDemand()) { String packageName = importName.substring(0, importName.lastIndexOf('.')); String possibleTypeName = packageName + dotTypeName; IType onDemandPackageType = javaProject.findType(possibleTypeName); if (onDemandPackageType != null) { return onDemandPackageType; } } // If it's not a .* import, then does the import end with our type name? else if (importName.endsWith(dotTypeName)) { IType importType = javaProject.findType(importName); if (importType != null) { return importType; } } // If it doesn't, check to see if we were a dotted type ("Outer.Inner") and check to see // if Outer is imported else if (dotBaseTypeName != null && importName.endsWith(dotBaseTypeName)) { // ... then look for Outer.Inner IType importNestedType = javaProject.findType(importName + dotExtensionTypeName); if (importNestedType != null) { return importNestedType; } } } // Is this a java.lang.Xxx class that we get for free? String javaLangTypeName = "java.lang" + dotTypeName; IType javaLangType = javaProject.findType(javaLangTypeName); if (javaLangType != null) { return javaLangType; } // What about an inner type of our own class? String innerTypeName = declaringType.getFullyQualifiedName('.') + dotTypeName; IType innerType = javaProject.findType(innerTypeName); if (innerType != null) { return innerType; } // Are we declared in a package? IPackageFragment declaringTypePackageFragment = declaringType.getPackageFragment(); if (declaringTypePackageFragment != null) { // ... if so, is this name in our package, so it didn't need an import? String samePackageTypeName = declaringTypePackageFragment.getElementName() + dotTypeName; IType samePackageType = javaProject.findType(samePackageTypeName); if (samePackageType != null) { return samePackageType; } } else { // If we were in the default package, is that class in the default package too? IType defaultPackageType = javaProject.findType(name); if (defaultPackageType != null) { return defaultPackageType; } } String slowResolvedTypeName = JavaModelUtil.getResolvedTypeName(refTypeSig, _type); if (slowResolvedTypeName != null) { IType slowResolvedType = javaProject.findType(slowResolvedTypeName); if (slowResolvedType != null) { return slowResolvedType; } } return null; } else { // We were given an Lxxx; signature ... just look it up String resolvedTypeName = Signature.toString(refTypeSig.substring(arrayCount)); IType resolvedType = javaProject.findType(resolvedTypeName); return resolvedType; } }
public static String resolveClassName(String className, IType type) { if (className == null || type == null) { return className; } // replace binary $ inner class name syntax with . for source level className = className.replace('$', '.'); String dotClassName = new StringBuilder().append('.').append(className).toString(); IProject project = type.getJavaProject().getProject(); try { // Special handling for some well-know classes if (className.startsWith("java.lang") && getJavaType(project, className) != null) { return className; } // Check if the class is imported if (!type.isBinary()) { // Strip className to first segment to support ReflectionUtils.MethodCallback int ix = className.lastIndexOf('.'); String firstClassNameSegment = className; if (ix > 0) { firstClassNameSegment = className.substring(0, ix); } // Iterate the imports for (IImportDeclaration importDeclaration : type.getCompilationUnit().getImports()) { String importName = importDeclaration.getElementName(); // Wildcard imports -> check if the package + className is a valid type if (importDeclaration.isOnDemand()) { String newClassName = new StringBuilder(importName.substring(0, importName.length() - 1)) .append(className) .toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } } // Concrete import matching .className at the end -> check if type exists else if (importName.endsWith(dotClassName) && getJavaType(project, importName) != null) { return importName; } // Check if className is multi segmented (ReflectionUtils.MethodCallback) // -> check if the first segment else if (!className.equals(firstClassNameSegment)) { if (importName.endsWith(firstClassNameSegment)) { String newClassName = new StringBuilder(importName.substring(0, importName.lastIndexOf('.') + 1)) .append(className) .toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } } } } } // Check if the class is in the same package as the type String packageName = type.getPackageFragment().getElementName(); String newClassName = new StringBuilder(packageName).append(dotClassName).toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } // Check if the className is sufficient (already fully-qualified) if (getJavaType(project, className) != null) { return className; } // Check if the class is coming from the java.lang newClassName = new StringBuilder("java.lang").append(dotClassName).toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } // Fall back to full blown resolution String[][] fullInter = type.resolveType(className); if (fullInter != null && fullInter.length > 0) { return fullInter[0][0] + "." + fullInter[0][1]; } } catch (JavaModelException e) { SpringCore.log(e); } return className; }
/** * Creates a qualified class name from a class name which doesn't contain package name. * * @param parent a full qualified class name of the class which uses this variable * @param type a class name which doesn't contain package name * @return full a created qualified class name */ public static String getFullQName(IType parent, String type) { if (type.indexOf('.') >= 0) { return type; } if (isPrimitive(type)) { return type; } IJavaProject project = parent.getJavaProject(); try { IType javaType = project.findType("java.lang." + type); if (javaType != null && javaType.exists()) { return javaType.getFullyQualifiedName(); } } catch (Exception ex) { ex.printStackTrace(); } while (true) { try { IType javaType = project.findType(parent.getFullyQualifiedName() + "." + type); if (javaType != null && javaType.exists()) { return parent.getFullyQualifiedName() + "." + type; } } catch (Exception ex) { ex.printStackTrace(); } try { IType javaType = project.findType(parent.getPackageFragment().getElementName() + "." + type); if (javaType != null && javaType.exists()) { return javaType.getFullyQualifiedName(); } } catch (Exception ex) { ex.printStackTrace(); } try { IImportDeclaration[] imports = parent.getCompilationUnit().getImports(); for (int i = 0; i < imports.length; i++) { String importName = imports[i].getElementName(); if (importName.endsWith("." + type)) { return importName; } if (importName.endsWith(".*")) { try { IType javaType = project.findType(importName.replaceFirst("\\*$", type)); if (javaType != null && javaType.exists()) { return javaType.getFullyQualifiedName(); } } catch (Exception ex) { } } } } catch (Exception ex) { ex.printStackTrace(); } try { // スーパークラス if (parent.getSuperclassTypeSignature() == null) { break; } String superClass = JavaUtil.getFullQName(parent, Signature.toString(parent.getSuperclassTypeSignature())); if (superClass.startsWith("java.lang.")) { break; } parent = parent.getJavaProject().findType(superClass); } catch (JavaModelException ex) { } } return type; }