private static String getDescription(MethodNode node) { return "method '" + node.getTypeDescriptor() + "'"; }
private MethodNode doAddMethod(MethodNode method) { String sig = method.getTypeDescriptor(); if (propertyMethodsWithSigs.containsKey(sig)) return method; propertyMethods.add(method); propertyMethodsWithSigs.put(sig, method); return method; }
private void storeMissingCovariantMethods(Collection methods, MethodNode method, Map methodsToAdd, Map genericsSpec, boolean ignoreError) { for (Object next : methods) { MethodNode toOverride = (MethodNode) next; MethodNode bridgeMethod = getCovariantImplementation(toOverride, method, genericsSpec, ignoreError); if (bridgeMethod == null) continue; methodsToAdd.put(bridgeMethod.getTypeDescriptor(), bridgeMethod); return; } }
public IncorrectTypeHintException(final MethodNode mn, final Throwable e, int line, int column) { super("Incorrect type hint in @ClosureParams in class "+mn.getDeclaringClass().getName()+" method "+mn.getTypeDescriptor()+" : "+e.getMessage(), e, line, column); }
public IncorrectTypeHintException(final MethodNode mn, final String msg, final int line, final int column) { super("Incorrect type hint in @ClosureParams in class "+mn.getDeclaringClass().getName()+" method "+mn.getTypeDescriptor()+" : "+msg, line, column); } }
public Map<String, MethodNode> getDeclaredMethodsMap() { Map<String, MethodNode> result = ClassNodeUtils.getDeclaredMethodsFromSuper(this); ClassNodeUtils.addDeclaredMethodsFromInterfaces(this, result); // And add in the methods implemented in this class. for (MethodNode method : getMethods()) { String sig = method.getTypeDescriptor(); result.put(sig, method); } return result; }
private void checkAbstractDeclaration(MethodNode methodNode) { if (!methodNode.isAbstract()) return; if (isAbstract(currentClass.getModifiers())) return; addError("Can't have an abstract method in a non-abstract class." + " The " + getDescription(currentClass) + " must be declared abstract or the method '" + methodNode.getTypeDescriptor() + "' must not be abstract.", methodNode); }
public String toString() { return "MethodNode@" + hashCode() + "[" + getDeclaringClass().getName() + "#" + getTypeDescriptor() + "]"; }
@Deprecated public static boolean shouldSkipOnDescriptor(boolean checkReturn, Map genericsSpec, MethodNode mNode, List<ClassNode> excludeTypes, List<ClassNode> includeTypes) { String descriptor = mNode.getTypeDescriptor(); String descriptorNoReturn = MethodNodeUtils.methodDescriptorWithoutReturnType(mNode); for (ClassNode cn : excludeTypes) { MethodNode correctedMethodNode = GenericsUtils.correctToGenericsSpec(updatedGenericsSpec, mn); if (checkReturn) { String md = correctedMethodNode.getTypeDescriptor(); if (md.equals(descriptor)) return true; } else { MethodNode correctedMethodNode = GenericsUtils.correctToGenericsSpec(updatedGenericsSpec, mn); if (checkReturn) { String md = correctedMethodNode.getTypeDescriptor(); if (md.equals(descriptor)) return false; } else {
abstractMethods.remove(m.getTypeDescriptor()); if (m.isStatic() || !(m.isPublic() || m.isProtected())) { methodsIterator.remove(); MethodNode intfMethod = allInterfaceMethods.get(m.getTypeDescriptor()); if (intfMethod != null && ((m.getModifiers() & ACC_SYNTHETIC) == 0) && !m.isPublic() && !m.isStaticConstructor()) { if (!methodsToAdd.isEmpty()) { for (MethodNode mn : declaredMethods) { declaredMethodsMap.put(mn.getTypeDescriptor(), mn);
public static boolean shouldSkipOnDescriptorUndefinedAware(boolean checkReturn, Map genericsSpec, MethodNode mNode, List<ClassNode> excludeTypes, List<ClassNode> includeTypes) { String descriptor = mNode.getTypeDescriptor(); String descriptorNoReturn = MethodNodeUtils.methodDescriptorWithoutReturnType(mNode); if (excludeTypes != null) { MethodNode correctedMethodNode = GenericsUtils.correctToGenericsSpec(updatedGenericsSpec, mn); if (checkReturn) { String md = correctedMethodNode.getTypeDescriptor(); if (md.equals(descriptor)) return true; } else { MethodNode correctedMethodNode = GenericsUtils.correctToGenericsSpec(updatedGenericsSpec, mn); if (checkReturn) { String md = correctedMethodNode.getTypeDescriptor(); if (md.equals(descriptor)) return false; } else {
private ClassNode popWithMessage(int last) { try { return stack.remove(last); } catch (ArrayIndexOutOfBoundsException ai) { String method = controller.getMethodNode() == null ? controller.getConstructorNode().getTypeDescriptor() : controller.getMethodNode().getTypeDescriptor(); throw new GroovyBugError("Error while popping argument from operand stack tracker in class " + controller.getClassName() + " method " + method + "."); } }
MethodNode mn = result.get(methodNode.getTypeDescriptor()); if (mn != null && (mn.isStatic() ^ methodNode.isStatic()) && !methodNode.isStaticConstructor()) { if (!mn.isAbstract()) continue; result.put(methodNode.getTypeDescriptor(), methodNode);
if (method != null) descriptor = method.getTypeDescriptor(); throw new GroovyBugError( "Declaring class for method call to '" +
outBuffer.append("ASM reporting processing error for "); outBuffer.append(controller.getClassNode().toString()).append("#").append(node.getName()); outBuffer.append(" with signature ").append(node.getTypeDescriptor()); outBuffer.append(" in ").append(sourceFile).append(":").append(node.getLineNumber()); if (writer != null) {
if (mn.getTypeDescriptor().equals(candidate.getTypeDescriptor())) { return; if (mn.getTypeDescriptor().equals(candidate.getTypeDescriptor())) { return; if (mn.getTypeDescriptor().equals(candidate.getTypeDescriptor()) && !mn.isAbstract() && !mn.isStatic()) { existingNode = mn; break;
throw new RuntimeParserException( "The return type of " + overridingMethod.getTypeDescriptor() + " in " + overridingMethod.getDeclaringClass().getName() + " is incompatible with " + testmr.getName() + throw new RuntimeParserException( "Cannot override final method " + oldMethod.getTypeDescriptor() + " in " + oldMethod.getDeclaringClass().getName(), overridingMethod); throw new RuntimeParserException( "Cannot override method " + oldMethod.getTypeDescriptor() + " in " + oldMethod.getDeclaringClass().getName() + " with disparate static modifier", oldMethod.getTypeDescriptor() + " in " + oldMethod.getDeclaringClass().getName() + message,
if (declared) { if (!methodNode.isSynthetic() && (methodNode.isProtected() || methodNode.getModifiers()==0)) { unit.addError(new SyntaxException("Cannot have protected/package private method in a trait (" + cNode.getName() + "#" + methodNode.getTypeDescriptor() + ")", methodNode.getLineNumber(), methodNode.getColumnNumber())); return null;
if (oldMethod != null) { throw new RuntimeParserException( "The method with default parameters \"" + method.getTypeDescriptor() + "\" defines a method \"" + newMethod.getTypeDescriptor() + "\" that is already defined.", method);
MethodNode enumConstMethod = inner.getMethod(methodNode.getName(), methodNode.getParameters()); if (enumConstMethod == null || (enumConstMethod.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) { addError(field, "Can't have an abstract method in enum constant " + field.getName() + ". Implement method '" + methodNode.getTypeDescriptor() + "'.");