if (exec.isConstructor()) { ref.setSimpleName(CtExecutableReference.CONSTRUCTOR_NAME); ref.setDeclaringType(getTypeReference(exec.declaringClass)); } else { final CtReference declaringType = getDeclaringReferenceFromImports(exec.constantPoolName()); if (declaringType instanceof CtTypeReference) { ref.setDeclaringType((CtTypeReference<?>) declaringType); if (exec.isConstructor()) { if (exec.isConstructor() && !(exec.returnType instanceof VoidTypeBinding)) { ref.setDeclaringType(getTypeReference(exec.returnType)); } else { ref.setDeclaringType(getTypeReference(exec.declaringClass)); ref.setStatic(exec.isStatic()); if (exec.original() != null) { final List<CtTypeReference<?>> parameters = new ArrayList<>(exec.original().parameters.length); for (TypeBinding b : exec.original().parameters) { parameters.add(getTypeReference(b, true));
@Override protected AnnotationBinding[] getAnnotationBindings() { return ((MethodBinding)_binding).getAnnotations(); }
/** * @see IBinding#isSynthetic() */ @Override public boolean isSynthetic() { return this.binding.isSynthetic(); }
@Override public CharSequence extractReturnType(ExecutableElement executableElement) { if (executableElement instanceof ExecutableElementImpl) { Binding binding = ((ExecutableElementImpl) executableElement)._binding; if (binding instanceof MethodBinding) { MethodBinding methodBinding = (MethodBinding) binding; @Nullable AbstractMethodDeclaration sourceMethod = methodBinding.sourceMethod(); if (sourceMethod != null) { CharSequence rawType = getRawType(methodBinding); char[] content = sourceMethod.compilationResult.compilationUnit.getContents(); int sourceEnd = methodBinding.sourceStart();// intentionaly int sourceStart = scanForTheSourceStart(content, sourceEnd); char[] methodTest = Arrays.copyOfRange(content, sourceStart, sourceEnd); Entry<String, List<String>> extracted = SourceTypes.extract(String.valueOf(methodTest)); return SourceTypes.stringify( Maps.immutableEntry(rawType.toString(), extracted.getValue())); } } } return UNABLE_TO_EXTRACT; }
public int literalIndexForMethodHandle(MethodBinding binding) { boolean isInterface = binding.declaringClass.isInterface(); int referenceKind = isInterface ? binding.isStatic() ? MethodHandleRefKindInvokeStatic : binding.isPrivate() ? MethodHandleRefKindInvokeSpecial : MethodHandleRefKindInvokeInterface : binding.isConstructor() ? MethodHandleRefKindNewInvokeSpecial : binding.isStatic() ? MethodHandleRefKindInvokeStatic : binding.isPrivate() ? MethodHandleRefKindInvokeSpecial : MethodHandleRefKindInvokeVirtual; return literalIndexForMethodHandle(referenceKind, binding.declaringClass, binding.selector, binding.signature(), isInterface); }
public void safeVarargsOnFixedArityMethod(MethodBinding method) { String [] arguments = new String[] { new String(method.isConstructor() ? method.declaringClass.shortReadableName() : method.selector)}; this.handle( IProblem.SafeVarargsOnFixedArityMethod, arguments, arguments, method.sourceStart(), method.sourceEnd()); } public void safeVarargsOnNonFinalInstanceMethod(MethodBinding method) {
/** * Returns whether the code gen will use an invoke virtual for * this message send or not. */ protected boolean isVirtualInvoke(MethodBinding method, MessageSend messageSend) { return !method.isStatic() && !method.isPrivate() && !messageSend.isSuperAccess() && !(method.isDefault() && this.pattern.focus != null && !CharOperation.equals(this.pattern.declaringPackageName, method.declaringClass.qualifiedPackageName())); } protected ReferenceBinding checkMethodRef(MethodBinding method, ReferenceExpression referenceExpression) {
public TypeBinding resolveType(BlockScope scope) { TypeBinding type = super.resolveType(scope); if (type == null || type instanceof ProblemReferenceBinding || type instanceof PolyTypeBinding) return type; MethodBinding method = getMethodBinding(); if (method != null && method.isValidBinding() && !method.isSynthetic()) throw new SelectionNodeFound(this.actualMethodBinding); throw new SelectionNodeFound(); } }
public MethodBinding findMethod(ReferenceBinding receiverType, char[] selector, TypeBinding[] argumentTypes, InvocationSite invocationSite, boolean inStaticContext) { MethodBinding method = findMethod0(receiverType, selector, argumentTypes, invocationSite, inStaticContext); if (method != null && method.isValidBinding() && method.isVarargs()) { TypeBinding elementType = method.parameters[method.parameters.length - 1].leafComponentType(); if (elementType instanceof ReferenceBinding) { if (!((ReferenceBinding) elementType).canBeSeenBy(this)) { return new ProblemMethodBinding(method, method.selector, invocationSite.genericTypeArguments(), ProblemReasons.VarargsElementTypeNotVisible); } } } return method; }
public void setDefaultValue(Object defaultValue) { MethodBinding originalMethod = original(); originalMethod.tagBits |= TagBits.DefaultValueResolved; AnnotationHolder holder = this.declaringClass.retrieveAnnotationHolder(this, false); if (holder == null) setAnnotations(null, null, defaultValue, null); else setAnnotations(holder.getAnnotations(), holder.getParameterAnnotations(), defaultValue, null); } public void setParameterAnnotations(AnnotationBinding[][] parameterAnnotations) {
@Override public AnnotationValue getDefaultValue() { MethodBinding binding = (MethodBinding)_binding; Object defaultValue = binding.getDefaultValue(); if (defaultValue != null) return new AnnotationMemberValue(_env, defaultValue, binding); return null; }
@SuppressWarnings("squid:S1168") protected static char[] getParamName(MethodBinding b, int paramIndex) { if (b.parameterNames.length > paramIndex) { return b.parameterNames[paramIndex]; } AbstractMethodDeclaration sourceMethod = b.sourceMethod(); if (sourceMethod != null && sourceMethod.arguments.length > paramIndex) { return sourceMethod.arguments[paramIndex].name; } // if no parameter name info is in the class file return null; }
@Override public boolean isSubsignature(ExecutableType m1, ExecutableType m2) { MethodBinding methodBinding1 = (MethodBinding) ((ExecutableTypeImpl) m1)._binding; MethodBinding methodBinding2 = (MethodBinding) ((ExecutableTypeImpl) m2)._binding; if (!CharOperation.equals(methodBinding1.selector, methodBinding2.selector)) return false; return methodBinding1.areParameterErasuresEqual(methodBinding2) && methodBinding1.areTypeVariableErasuresEqual(methodBinding2); }
/** * @see IMethodBinding#isConstructor() */ @Override public boolean isConstructor() { return this.binding.isConstructor(); }
public boolean doesParameterLengthMatch(int suggestedParameterLength) { int len = this.parameters.length; return len <= suggestedParameterLength || (isVarargs() && len == suggestedParameterLength + 1); } public void updateTypeVariableBinding(TypeVariableBinding previousBinding, TypeVariableBinding updatedBinding) {
protected boolean canOverridingMethodDifferInErasure(MethodBinding overridingMethod, MethodBinding inheritedMethod) { if (overridingMethod.areParameterErasuresEqual(inheritedMethod)) return false; // no further change in signature is possible due to parameterization. if (overridingMethod.declaringClass.isRawType()) return false; // no parameterization is happening anyways. return true; } boolean canSkipInheritedMethods() {
public boolean isStatic() { if (this.binding != null) return this.binding.isStatic(); return (this.modifiers & ClassFileConstants.AccStatic) != 0; }
/** * Returns the original method (as opposed to parameterized instances) */ public MethodBinding original() { return this.originalMethod.original(); }
static boolean areMethodsCompatible(MethodBinding one, MethodBinding two, LookupEnvironment environment) { // use the original methods to test compatibility, but do not check visibility, etc one = one.original(); two = one.findOriginalInheritedMethod(two); if (two == null) return false; // method's declaringClass does not inherit from inheritedMethod's return isParameterSubsignature(one, two, environment); } boolean areReturnTypesCompatible(MethodBinding one, MethodBinding two) {