private List<String> initTypeParameterNames() { if (fMethod != null) { try { ArrayList<String> typeParameterNames = new ArrayList<>(); for (ITypeParameter typeParameter : fMethod.getTypeParameters()) { typeParameterNames.add(typeParameter.getElementName()); } return typeParameterNames; } catch (JavaModelException e) { } } return Collections.emptyList(); }
private List<String> initTypeParameterNames() { if (fMethod != null) { try { ArrayList<String> typeParameterNames= new ArrayList<>(); for (ITypeParameter typeParameter : fMethod.getTypeParameters()) { typeParameterNames.add(typeParameter.getElementName()); } return typeParameterNames; } catch (JavaModelException e) { JavaPlugin.log(e); } } return Collections.emptyList(); }
private List<String> initTypeParameterNames() { if (fMethod != null) { try { ArrayList<String> typeParameterNames= new ArrayList<>(); for (ITypeParameter typeParameter : fMethod.getTypeParameters()) { typeParameterNames.add(typeParameter.getElementName()); } return typeParameterNames; } catch (JavaModelException e) { JavaPlugin.log(e); } } return Collections.emptyList(); }
private int appendMethodDeclaration(StringBuffer cuString, String[] types, int parameterCount) throws JavaModelException { if (Flags.isStatic(fMethod.getFlags())) cuString.append("static "); //$NON-NLS-1$ ITypeParameter[] methodTypeParameters= fMethod.getTypeParameters(); if (methodTypeParameters.length != 0) { cuString.append('<'); for (int i= 0; i < methodTypeParameters.length; i++) { ITypeParameter typeParameter= methodTypeParameters[i]; if (i > 0) cuString.append(','); cuString.append(typeParameter.getElementName()); } cuString.append("> "); //$NON-NLS-1$ } cuString.append(types[parameterCount]).append(' '); int offsetBeforeMethodName= cuString.length(); cuString.append(METHOD_NAME).append('('); for (int i= 0; i < parameterCount; i++) { if (i > 0) cuString.append(','); cuString.append(types[i]).append(" p").append(i); //$NON-NLS-1$ } cuString.append(");"); //$NON-NLS-1$ return offsetBeforeMethodName; }
private int appendMethodDeclaration(StringBuffer cuString, String[] types, int parameterCount) throws JavaModelException { int flags= fMethod.getFlags(); if (Flags.isStatic(flags)) { cuString.append("static "); //$NON-NLS-1$ } else if (Flags.isDefaultMethod(flags)) { cuString.append("default "); //$NON-NLS-1$ } ITypeParameter[] methodTypeParameters= fMethod.getTypeParameters(); if (methodTypeParameters.length != 0) { cuString.append('<'); for (int i= 0; i < methodTypeParameters.length; i++) { ITypeParameter typeParameter= methodTypeParameters[i]; if (i > 0) cuString.append(','); cuString.append(typeParameter.getElementName()); } cuString.append("> "); //$NON-NLS-1$ } cuString.append(types[parameterCount]).append(' '); int offsetBeforeMethodName= cuString.length(); cuString.append(METHOD_NAME).append('('); for (int i= 0; i < parameterCount; i++) { if (i > 0) cuString.append(','); cuString.append(types[i]).append(" p").append(i); //$NON-NLS-1$ } cuString.append(");"); //$NON-NLS-1$ return offsetBeforeMethodName; }
private int appendMethodDeclaration(StringBuilder cuString, String[] types, int parameterCount) throws JavaModelException { int flags= fMethod.getFlags(); if (Flags.isStatic(flags)) { cuString.append("static "); //$NON-NLS-1$ } else if (Flags.isDefaultMethod(flags)) { cuString.append("default "); //$NON-NLS-1$ } ITypeParameter[] methodTypeParameters= fMethod.getTypeParameters(); if (methodTypeParameters.length != 0) { cuString.append('<'); for (int i= 0; i < methodTypeParameters.length; i++) { ITypeParameter typeParameter= methodTypeParameters[i]; if (i > 0) cuString.append(','); cuString.append(typeParameter.getElementName()); } cuString.append("> "); //$NON-NLS-1$ } cuString.append(types[parameterCount]).append(' '); int offsetBeforeMethodName= cuString.length(); cuString.append(METHOD_NAME).append('('); for (int i= 0; i < parameterCount; i++) { if (i > 0) cuString.append(','); cuString.append(types[i]).append(" p").append(i); //$NON-NLS-1$ } cuString.append(");"); //$NON-NLS-1$ return offsetBeforeMethodName; }
private static boolean isParameterizedElement(IJavaElement element) { while (element != null) { ITypeParameter[] typeParameters= null; try { if (element instanceof IType) { typeParameters= ((IType)element).getTypeParameters(); } else if (element instanceof IMethod) { typeParameters= ((IMethod)element).getTypeParameters(); } } catch (JavaModelException e) { return false; } if (typeParameters == null) return false; if (typeParameters.length > 0) return true; element= element.getParent(); } return false; } }
private static boolean isParameterizedElement(IJavaElement element) { while (element != null) { ITypeParameter[] typeParameters= null; try { if (element instanceof IType) { typeParameters= ((IType)element).getTypeParameters(); } else if (element instanceof IMethod) { typeParameters= ((IMethod)element).getTypeParameters(); } } catch (JavaModelException e) { return false; } if (typeParameters == null) return false; if (typeParameters.length > 0) return true; element= element.getParent(); } return false; } }
public boolean isApplicable(JavaSearchQuery query) { QuerySpecification spec= query.getSpecification(); if (spec instanceof ElementQuerySpecification) { ElementQuerySpecification elementSpec= (ElementQuerySpecification) spec; Object element= elementSpec.getElement(); ITypeParameter[] typeParameters= null; try { if (element instanceof IType) { typeParameters= ((IType)element).getTypeParameters(); } else if (element instanceof IMethod) { typeParameters= ((IMethod)element).getTypeParameters(); } } catch (JavaModelException e) { return false; } return typeParameters != null && typeParameters.length > 0; } return false; } }
private Substitutions getMethodSubstitions(IMethod method) throws JavaModelException { if (fMethodSubstitutions == null) { fMethodSubstitutions= new LRUMap(3); } Substitutions s= (Substitutions) fMethodSubstitutions.get(method); if (s == null) { ITypeParameter[] typeParameters= method.getTypeParameters(); if (typeParameters.length == 0) { s= Substitutions.EMPTY_SUBST; } else { IType instantiatedType= method.getDeclaringType(); s= new Substitutions(); for (int i= 0; i < typeParameters.length; i++) { ITypeParameter curr= typeParameters[i]; s.addSubstitution(curr.getElementName(), '+' + String.valueOf(i), getTypeParameterErasure(curr, instantiatedType)); } } fMethodSubstitutions.put(method, s); } return s; }
private Substitutions getMethodSubstitions(IMethod method) throws JavaModelException { if (fMethodSubstitutions == null) { fMethodSubstitutions= new LRUMap<>(3); } Substitutions s= fMethodSubstitutions.get(method); if (s == null) { ITypeParameter[] typeParameters= method.getTypeParameters(); if (typeParameters.length == 0) { s= Substitutions.EMPTY_SUBST; } else { IType instantiatedType= method.getDeclaringType(); s= new Substitutions(); for (int i= 0; i < typeParameters.length; i++) { ITypeParameter curr= typeParameters[i]; s.addSubstitution(curr.getElementName(), '+' + String.valueOf(i), getTypeParameterErasure(curr, instantiatedType)); } } fMethodSubstitutions.put(method, s); } return s; }
/** * Generate the binary signature for the provided method. This is the * type-erased signature written out to the .class file. * * @param method the method * @return the method signature as would be encoded in a .class file * @throws JavaModelException */ private static String generateBinarySignature(IMethod method) throws JavaModelException { ITypeParameter[] typeTPs = method.getDeclaringType().getTypeParameters(); ITypeParameter[] methodTPs = method.getTypeParameters(); if (typeTPs.length == 0 && methodTPs.length == 0) { return method.getSignature(); } Map<String, String> lookup = new HashMap<>(); Stream.concat(Stream.of(typeTPs), Stream.of(methodTPs)).forEach(tp -> { try { String sigs[] = tp.getBoundsSignatures(); lookup.put(tp.getElementName(), sigs.length == 1 ? sigs[0] : "Ljava.lang.Object;"); //$NON-NLS-1$ } catch (JavaModelException e) { /* ignore */ } }); String[] parameterTypes = Stream.of(method.getParameterTypes()).map(p -> expandParameterType(p, lookup)).toArray(String[]::new); return Signature.createMethodSignature(parameterTypes, expandParameterType(method.getReturnType(), lookup)); }
private Substitutions getMethodSubstitions(IMethod method) throws JavaModelException { if (fMethodSubstitutions == null) { fMethodSubstitutions= new LRUMap<>(3); } Substitutions s= fMethodSubstitutions.get(method); if (s == null) { ITypeParameter[] typeParameters= method.getTypeParameters(); if (typeParameters.length == 0) { s= Substitutions.EMPTY_SUBST; } else { IType instantiatedType= method.getDeclaringType(); s= new Substitutions(); for (int i= 0; i < typeParameters.length; i++) { ITypeParameter curr= typeParameters[i]; s.addSubstitution(curr.getElementName(), '+' + String.valueOf(i), getTypeParameterErasure(curr, instantiatedType)); } } fMethodSubstitutions.put(method, s); } return s; }
private boolean hasCompatibleTypeParameters(IMethod overriding, IMethod overridden) throws JavaModelException { ITypeParameter[] overriddenTypeParameters= overridden.getTypeParameters(); ITypeParameter[] overridingTypeParameters= overriding.getTypeParameters(); int nOverridingTypeParameters= overridingTypeParameters.length; if (overriddenTypeParameters.length != nOverridingTypeParameters) { return nOverridingTypeParameters == 0; } Substitutions overriddenSubst= getMethodSubstitions(overridden); Substitutions overridingSubst= getMethodSubstitions(overriding); for (int i= 0; i < nOverridingTypeParameters; i++) { String erasure1= overriddenSubst.getErasure(overriddenTypeParameters[i].getElementName()); String erasure2= overridingSubst.getErasure(overridingTypeParameters[i].getElementName()); if (erasure1 == null || !erasure1.equals(erasure2)) { return false; } // comparing only the erasure is not really correct: Need to compare all bounds, that can be in different order int nBounds= overriddenTypeParameters[i].getBounds().length; if (nBounds > 1 && nBounds != overridingTypeParameters[i].getBounds().length) { return false; } } return true; }
private boolean hasCompatibleTypeParameters(IMethod overriding, IMethod overridden) throws JavaModelException { ITypeParameter[] overriddenTypeParameters= overridden.getTypeParameters(); ITypeParameter[] overridingTypeParameters= overriding.getTypeParameters(); int nOverridingTypeParameters= overridingTypeParameters.length; if (overriddenTypeParameters.length != nOverridingTypeParameters) { return nOverridingTypeParameters == 0; } Substitutions overriddenSubst= getMethodSubstitions(overridden); Substitutions overridingSubst= getMethodSubstitions(overriding); for (int i= 0; i < nOverridingTypeParameters; i++) { String erasure1= overriddenSubst.getErasure(overriddenTypeParameters[i].getElementName()); String erasure2= overridingSubst.getErasure(overridingTypeParameters[i].getElementName()); if (erasure1 == null || !erasure1.equals(erasure2)) { return false; } // comparing only the erasure is not really correct: Need to compare all bounds, that can be in different order int nBounds= overriddenTypeParameters[i].getBounds().length; if (nBounds > 1 && nBounds != overridingTypeParameters[i].getBounds().length) { return false; } } return true; }
private boolean hasCompatibleTypeParameters(IMethod overriding, IMethod overridden) throws JavaModelException { ITypeParameter[] overriddenTypeParameters= overridden.getTypeParameters(); ITypeParameter[] overridingTypeParameters= overriding.getTypeParameters(); int nOverridingTypeParameters= overridingTypeParameters.length; if (overriddenTypeParameters.length != nOverridingTypeParameters) { return nOverridingTypeParameters == 0; } Substitutions overriddenSubst= getMethodSubstitions(overridden); Substitutions overridingSubst= getMethodSubstitions(overriding); for (int i= 0; i < nOverridingTypeParameters; i++) { String erasure1= overriddenSubst.getErasure(overriddenTypeParameters[i].getElementName()); String erasure2= overridingSubst.getErasure(overridingTypeParameters[i].getElementName()); if (erasure1 == null || !erasure1.equals(erasure2)) { return false; } // comparing only the erasure is not really correct: Need to compare all bounds, that can be in different order int nBounds= overriddenTypeParameters[i].getBounds().length; if (nBounds > 1 && nBounds != overridingTypeParameters[i].getBounds().length) { return false; } } return true; }
private static final boolean resolveTypeParameter(final IMethod method, final String identifier, final StringBuilder result) throws JavaModelException { IType type = method.getDeclaringType(); if (resolveTypeParameter(type, method.getTypeParameters(), identifier, result)) { return true; } while (type != null) { if (resolveTypeParameter(type, type.getTypeParameters(), identifier, result)) { return true; } type = type.getDeclaringType(); } return false; }
/** * Returns the comment for a method or constructor using the comment code templates (constructor / method / overriding method). * <code>null</code> is returned if the template is empty. * <p>The returned string is unformatted and not indented. * * @param method The method to be documented. The method must exist. * @param overridden The method that will be overridden by the created method or * <code>null</code> for non-overriding methods. If not <code>null</code>, the method must exist. * @param lineDelimiter The line delimiter to be used. * @return Returns the constructed comment or <code>null</code> if * the comment code template is empty. The returned string is unformatted and and has no indent (formatting required). * @throws CoreException Thrown when the evaluation of the code template fails. */ public static String getMethodComment(IMethod method, IMethod overridden, String lineDelimiter) throws CoreException { String retType= method.isConstructor() ? null : method.getReturnType(); String[] paramNames= method.getParameterNames(); String[] typeParameterNames= StubUtility.getTypeParameterNames(method.getTypeParameters()); return StubUtility.getMethodComment(method.getCompilationUnit(), method.getDeclaringType().getElementName(), method.getElementName(), paramNames, method.getExceptionTypes(), retType, typeParameterNames, overridden, false, lineDelimiter); }
/** * Returns the comment for a method or constructor using the comment code templates (constructor / method / overriding method). * <code>null</code> is returned if the template is empty. * <p>The returned string is unformatted and not indented. * * @param method The method to be documented. The method must exist. * @param overridden The method that will be overridden by the created method or * <code>null</code> for non-overriding methods. If not <code>null</code>, the method must exist. * @param lineDelimiter The line delimiter to be used. * @return Returns the constructed comment or <code>null</code> if * the comment code template is empty. The returned string is unformatted and and has no indent (formatting required). * @throws CoreException Thrown when the evaluation of the code template fails. */ public static String getMethodComment(IMethod method, IMethod overridden, String lineDelimiter) throws CoreException { String retType= method.isConstructor() ? null : method.getReturnType(); String[] paramNames= method.getParameterNames(); String[] typeParameterNames= StubUtility.shouldGenerateMethodTypeParameterTags(method.getJavaProject()) ? StubUtility.getTypeParameterNames(method.getTypeParameters()) : new String[0]; return StubUtility.getMethodComment(method.getCompilationUnit(), method.getDeclaringType().getElementName(), method.getElementName(), paramNames, method.getExceptionTypes(), retType, typeParameterNames, overridden, false, lineDelimiter); }
/** * Returns the comment for a method or constructor using the comment code templates (constructor / method / overriding method). * <code>null</code> is returned if the template is empty. * <p>The returned string is unformatted and not indented. * * @param method The method to be documented. The method must exist. * @param overridden The method that will be overridden by the created method or * <code>null</code> for non-overriding methods. If not <code>null</code>, the method must exist. * @param lineDelimiter The line delimiter to be used. * @return Returns the constructed comment or <code>null</code> if * the comment code template is empty. The returned string is unformatted and and has no indent (formatting required). * @throws CoreException Thrown when the evaluation of the code template fails. */ public static String getMethodComment(IMethod method, IMethod overridden, String lineDelimiter) throws CoreException { String retType= method.isConstructor() ? null : method.getReturnType(); String[] paramNames= method.getParameterNames(); String[] typeParameterNames= StubUtility.shouldGenerateMethodTypeParameterTags(method.getJavaProject()) ? StubUtility.getTypeParameterNames(method.getTypeParameters()) : new String[0]; return StubUtility.getMethodComment(method.getCompilationUnit(), method.getDeclaringType().getElementName(), method.getElementName(), paramNames, method.getExceptionTypes(), retType, typeParameterNames, overridden, false, lineDelimiter); }