private boolean hasAddedStaticImport(SimpleName name) { IBinding binding= name.resolveBinding(); if (binding instanceof IVariableBinding) { IVariableBinding variable= (IVariableBinding) binding; return hasAddedStaticImport(variable.getDeclaringClass().getQualifiedName(), variable.getName(), true); } else if (binding instanceof IMethodBinding) { IMethodBinding method= (IMethodBinding) binding; return hasAddedStaticImport(method.getDeclaringClass().getQualifiedName(), method.getName(), false); } return false; }
private boolean isSpecialCloneInvocation(IMethodBinding methodBinding, Expression receiver) { return fAssumeCloneReturnsSameType && "clone".equals(methodBinding.getName()) //$NON-NLS-1$ && methodBinding.getParameterTypes().length == 0 && receiver != null && receiver.resolveTypeBinding() != methodBinding.getMethodDeclaration().getReturnType(); }
private boolean needsNoSuperCall(ITypeBinding typeBinding, String name, ITypeBinding[] parameters) { Assert.isNotNull(typeBinding); IMethodBinding binding= Bindings.findMethodInHierarchy(typeBinding.getSuperclass(), name, parameters); if (binding != null && !Modifier.isAbstract(binding.getModifiers())) { ITypeBinding declaring= binding.getDeclaringClass(); return declaring.getQualifiedName().equals(JAVA_LANG_OBJECT); } return true; }
private boolean matches(IBinding binding) { if (!(binding instanceof IMethodBinding)) return false; return fBinding.isEqualTo(((IMethodBinding)binding).getMethodDeclaration()); } }
private String getMethodName(IMethodBinding binding) { String argumentList = ""; ITypeBinding[] args = binding.getParameterTypes(); for(ITypeBinding arg : args) { argumentList += arg.getName(); } String method = binding.getDeclaringClass().getQualifiedName() + "." + binding.getName() + "/" + binding.getTypeArguments().length + "[" + argumentList + "]"; return method; }
public static ITypeBinding getParameterTypeBinding(IMethodBinding methodBinding, int argumentIndex) { ITypeBinding[] paramTypes= methodBinding.getParameterTypes(); if (methodBinding.isVarargs() && argumentIndex >= paramTypes.length - 1) { return paramTypes[paramTypes.length - 1].getComponentType(); } if (argumentIndex >= 0 && argumentIndex < paramTypes.length) { return paramTypes[argumentIndex]; } return null; }
@Override public boolean visit(MethodDeclaration node) { final String simpleName = node.getName().getIdentifier(); final IMethodBinding methodBinding = node.resolveBinding(); if (methodBinding != null) { final QName qname = QName.valueOf(methodBinding.getDeclaringClass().getQualifiedName(), simpleName); methods.addName(FQN.fromMember(qname)); } else { // We cannot determine the FQN, so we cannot safely replace it methods.cannotReplaceSimpleName(simpleName); } return VISIT_SUBTREE; }
private static IMethodBinding findGetter(ProposalParameter context) { ITypeBinding returnType= context.variableBinding.getType(); String getterName= GetterSetterUtil.getGetterName(context.variableBinding, context.compilationUnit.getJavaProject(), null, isBoolean(context)); ITypeBinding declaringType= context.variableBinding.getDeclaringClass(); IMethodBinding getter= Bindings.findMethodInHierarchy(declaringType, getterName, new ITypeBinding[0]); if (getter != null && getter.getReturnType().isAssignmentCompatible(returnType) && Modifier.isStatic(getter.getModifiers()) == Modifier.isStatic(context.variableBinding.getModifiers())) return getter; return null; }
@Override public boolean visit(MethodDeclaration node) { IMethodBinding binding= node.resolveBinding(); if (binding != null && !Modifier.isStatic(binding.getModifiers())) { IMethodBinding method= Bindings.findOverriddenMethodInHierarchy(fSelectedType, binding); if (method != null) { SimpleName name= node.getName(); fResult.add(new OccurrenceLocation(name.getStartPosition(), name.getLength(), 0, fDescription)); } } return super.visit(node); }
ParameterAnnotationRewriteOperation(CompilationUnit unit, MethodDeclaration method, String annotationToAdd, String annotationToRemove, int paramIdx, boolean allowRemove, String message) { fUnit= unit; fKey= method.resolveBinding().getKey(); fAnnotationToAdd= annotationToAdd; fAnnotationToRemove= annotationToRemove; fAllowRemove= allowRemove; fArgument= (SingleVariableDeclaration) method.parameters().get(paramIdx); fKey+= fArgument.getName().getIdentifier(); fMessage= message; }
private static ITypeBinding getDeclaringClassBinding(SimpleName memberName) { IBinding binding= memberName.resolveBinding(); if (binding instanceof IMethodBinding) return ((IMethodBinding) binding).getDeclaringClass(); if (binding instanceof IVariableBinding) return ((IVariableBinding) binding).getDeclaringClass(); if (binding instanceof ITypeBinding) return ((ITypeBinding) binding).getDeclaringClass(); Assert.isTrue(false); return null; }
private static boolean isInterfaceOrAnnotationMember(IBinding binding) { ITypeBinding declaringType= null; if (binding instanceof IVariableBinding) { declaringType= ((IVariableBinding) binding).getDeclaringClass(); } else if (binding instanceof IMethodBinding) { declaringType= ((IMethodBinding) binding).getDeclaringClass(); } else if (binding instanceof ITypeBinding) { declaringType= ((ITypeBinding) binding).getDeclaringClass(); } return declaringType != null && (declaringType.isInterface() || declaringType.isAnnotation()); }
private void createMethodComment(MethodDeclaration newDeclaration, IMethodBinding copyFrom) throws CoreException { if (fSettings.createComments) { String string= CodeGeneration.getMethodComment(fRewrite.getCu(), fType.getQualifiedName(), newDeclaration, copyFrom, StubUtility.getLineDelimiterUsed(fRewrite.getCu())); if (string != null) { Javadoc javadoc= (Javadoc) fRewrite.getASTRewrite().createStringPlaceholder(string, ASTNode.JAVADOC); newDeclaration.setJavadoc(javadoc); } } IJavaProject project= fUnit.getJavaElement().getJavaProject(); StubUtility2Core.addOverrideAnnotation(fSettings, project, fRewrite.getASTRewrite(), fRewrite.getImportRewrite(), newDeclaration, copyFrom.getDeclaringClass().isInterface(), null); }
private void createSignature(final IMethodBinding constructor, StringBuilder buffer, Object[] selection) { ITypeBinding types[]= constructor.getParameterTypes(); for (int index= 0; index < types.length; index++) buffer.append(types[index].getName()); if (selection != null) { for (int index= 0; index < selection.length; index++) if (selection[index] instanceof IVariableBinding) buffer.append(((IVariableBinding) selection[index]).getType().getErasure().getName()); } }
private void setUpMethodFromMethodBinding(Method method, IMethodBinding binding) { if (binding.isConstructor()) method.setKind(CONSTRUCTOR_KIND); ITypeBinding returnType = binding.getReturnType(); if ((returnType != null) && !(returnType.isPrimitive() && returnType.getName().equals("void"))) // we do not want to set void as a return type method.setDeclaredType(ensureTypeFromTypeBinding(returnType)); extractBasicModifiersFromBinding(binding.getModifiers(), method); if (Modifier.isStatic(binding.getModifiers())) method.setHasClassScope(true); }
private static IBinding getDeclaration(IBinding binding) { if (binding instanceof ITypeBinding) { return ((ITypeBinding) binding).getTypeDeclaration(); } else if (binding instanceof IMethodBinding) { return ((IMethodBinding) binding).getMethodDeclaration(); } else if (binding instanceof IVariableBinding) { return ((IVariableBinding) binding).getVariableDeclaration(); } return binding; } }
public static String getMethodSignature(IMethodBinding binding, boolean inOtherCU) { StringBuffer buf= new StringBuffer(); if (inOtherCU && !binding.isConstructor()) { buf.append(binding.getDeclaringClass().getTypeDeclaration().getName()).append('.'); // simple type name } return BindingLabelProvider.getBindingLabel(binding, BindingLabelProvider.DEFAULT_TEXTFLAGS); }
private String getSignature(IMethodBinding binding) { StringBuilder buf= new StringBuilder(binding.getName()).append('('); ITypeBinding[] parameterTypes= binding.getParameterTypes(); for (int i= 0; i < parameterTypes.length; i++) { buf.append(parameterTypes[i].getTypeDeclaration().getName()); } buf.append(')'); return buf.toString(); }
public ToStringInfo(ITypeBinding typeBinding) { IMethodBinding[] declaredMethods= typeBinding.getDeclaredMethods(); for (int i= 0; i < declaredMethods.length; i++) { if (declaredMethods[i].getName().equals(METHODNAME_TO_STRING) && declaredMethods[i].getParameterTypes().length == 0) { this.foundToString= true; if (Modifier.isFinal(declaredMethods[i].getModifiers())) this.foundFinalToString= true; } } } }
private boolean matchStaticImport(Name node, List result, IMethodBinding binding) { if (binding == null || node == null || !(fTarget instanceof IMethodBinding) || !Modifier.isStatic(binding.getModifiers())) return false; IMethodBinding targetMethodBinding= (IMethodBinding)fTarget; if ((fTargetIsStaticMethodImport || Modifier.isStatic(targetMethodBinding.getModifiers())) && (targetMethodBinding.getDeclaringClass().getTypeDeclaration() == binding.getDeclaringClass().getTypeDeclaration())) { if (node.getFullyQualifiedName().equals(targetMethodBinding.getName())) { result.add(node); return true; } } return false; }