public ClassNode getUnresolvedSuperClass() { return getUnresolvedSuperClass(true); }
private static List<ClassNode> getAllUnresolvedSuperClasses(ClassNode actualReceiver) { List<ClassNode> superClassNodeList = new LinkedList<>(); for (ClassNode cn = actualReceiver.getUnresolvedSuperClass(); null != cn && ClassHelper.OBJECT_TYPE != cn; cn = cn.getUnresolvedSuperClass()) { superClassNodeList.add(cn); } return superClassNodeList; }
@Override public ClassNode getUnresolvedSuperClass(boolean useRedirect) { lazyInitSupers(); return super.getUnresolvedSuperClass(useRedirect); }
public ClassNode getUnresolvedSuperClass(boolean useRedirect) { if (!useRedirect) return superClass; if (redirect != null) return redirect().getUnresolvedSuperClass(true); lazyClassInit(); return superClass; }
private boolean checkWildcard(ClassNode cn) { ClassNode sn = cn.getUnresolvedSuperClass(false); if (sn == null) return false; GenericsType[] generics = sn.getGenericsTypes(); if (generics == null) return false; boolean error = false; for (GenericsType generic : generics) { if (generic.isWildcard()) { addError("A supertype may not specify a wildcard type", sn); error = true; } } return error; }
/** * @return the ClassNode of the super class of this type */ public ClassNode getSuperClass() { if (!lazyInitDone && !isResolved()) { throw new GroovyBugError("ClassNode#getSuperClass for "+getName()+" called before class resolving"); } ClassNode sn = redirect().getUnresolvedSuperClass(); if (sn!=null) sn=sn.redirect(); return sn; }
public static String getGenericsSignature(ClassNode node) { if (!usesGenericsInClassSignature(node)) return null; GenericsType[] genericsTypes = node.getGenericsTypes(); StringBuilder ret = new StringBuilder(100); getGenericsTypeSpec(ret, genericsTypes); GenericsType extendsPart = new GenericsType(node.getUnresolvedSuperClass(false)); writeGenericsBounds(ret, extendsPart, true); ClassNode[] interfaces = node.getInterfaces(); for (int i = 0; i < interfaces.length; i++) { GenericsType interfacePart = new GenericsType(interfaces[i]); writeGenericsBounds(ret, interfacePart, false); } return ret.toString(); }
private static boolean usesGenericsInClassSignature(ClassNode node) { if (!node.isUsingGenerics()) return false; if (hasGenerics(node)) return true; ClassNode sclass = node.getUnresolvedSuperClass(false); if (sclass.isUsingGenerics()) return true; ClassNode[] interfaces = node.getInterfaces(); if (interfaces != null) { for (int i = 0; i < interfaces.length; i++) { if (interfaces[i].isUsingGenerics()) return true; } } return false; }
private void replaceExtendsByImplements(final ClassNode cNode) { ClassNode superClass = cNode.getUnresolvedSuperClass(); if (Traits.isTrait(superClass)) { // move from super class to interface; cNode.setSuperClass(ClassHelper.OBJECT_TYPE); cNode.setUnresolvedSuperClass(ClassHelper.OBJECT_TYPE); cNode.addInterface(superClass); resolveScope(cNode); } }
ClassNode superClass = next.getUnresolvedSuperClass(); if (superClass != null) { next = correctToGenericsSpecRecurse(updatedGenericsSpec, superClass);
@Override public void visitClass(ClassNode node) { boolean error = checkWildcard(node); if (error) return; boolean isAnon = node instanceof InnerClassNode && ((InnerClassNode) node).isAnonymous(); checkGenericsUsage(node.getUnresolvedSuperClass(false), node.getSuperClass(), isAnon ? true : null); ClassNode[] interfaces = node.getInterfaces(); for (ClassNode anInterface : interfaces) { checkGenericsUsage(anInterface, anInterface.redirect()); } node.visitContents(this); }
return OBJECT_TYPE; } else { return clazz.getUnresolvedSuperClass(); return clazz.getUnresolvedSuperClass();
private void addCovariantMethods(ClassNode classNode, List declaredMethods, Map abstractMethods, Map methodsToAdd, Map oldGenericsSpec) { ClassNode sn = classNode.getUnresolvedSuperClass(false); if (sn != null) { Map genericsSpec = createGenericsSpec(sn, oldGenericsSpec); List<MethodNode> classMethods = sn.getMethods(); // original class causing bridge methods for methods in super class storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, classMethods); // super class causing bridge methods for abstract methods in original class if (!abstractMethods.isEmpty()) { for (Object classMethod : classMethods) { MethodNode method = (MethodNode) classMethod; if (method.isStatic()) continue; storeMissingCovariantMethods(abstractMethods.values(), method, methodsToAdd, Collections.EMPTY_MAP, true); } } addCovariantMethods(sn.redirect(), declaredMethods, abstractMethods, methodsToAdd, genericsSpec); } ClassNode[] interfaces = classNode.getInterfaces(); for (ClassNode anInterface : interfaces) { List interfacesMethods = anInterface.getMethods(); Map genericsSpec = createGenericsSpec(anInterface, oldGenericsSpec); storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, interfacesMethods); addCovariantMethods(anInterface, declaredMethods, abstractMethods, methodsToAdd, genericsSpec); } }
/** * @param node the node to be tested * @return true if the node is using generics types and one of those types is a gstring or string/gstring lub */ public static boolean isParameterizedWithGStringOrGStringString(ClassNode node) { if (node.isArray()) return isParameterizedWithGStringOrGStringString(node.getComponentType()); if (node.isUsingGenerics()) { GenericsType[] genericsTypes = node.getGenericsTypes(); if (genericsTypes != null) { for (GenericsType genericsType : genericsTypes) { if (isGStringOrGStringStringLUB(genericsType.getType())) return true; } } } return node.getSuperClass() != null && isParameterizedWithGStringOrGStringString(node.getUnresolvedSuperClass()); }
/** * @param node the node to be tested * @return true if the node is using generics types and one of those types is a string */ public static boolean isParameterizedWithString(ClassNode node) { if (node.isArray()) return isParameterizedWithString(node.getComponentType()); if (node.isUsingGenerics()) { GenericsType[] genericsTypes = node.getGenericsTypes(); if (genericsTypes != null) { for (GenericsType genericsType : genericsTypes) { if (STRING_TYPE.equals(genericsType.getType())) return true; } } } return node.getSuperClass() != null && isParameterizedWithString(node.getUnresolvedSuperClass()); }
public void visitClass(ClassNode node) { visitType(node); visitType(node.getUnresolvedSuperClass()); visitTypes(node.getInterfaces()); super.visitClass(node); }
private static Parameter[] selectAccessibleConstructorFromSuper(ConstructorNode node) { ClassNode type = node.getDeclaringClass(); ClassNode superType = type.getUnresolvedSuperClass(); Parameter[] bestMatch = null; for (ConstructorNode c : superType.getDeclaredConstructors()) { // Only look at things we can actually call if (!c.isPublic() && !c.isProtected()) continue; Parameter[] parameters = c.getParameters(); // workaround for GROOVY-5859: remove generic type info Parameter[] copy = new Parameter[parameters.length]; for (int i = 0; i < copy.length; i++) { Parameter orig = parameters[i]; copy[i] = new Parameter(orig.getOriginType().getPlainNodeReference(), orig.getName()); } if (noExceptionToAvoid(node,c)) return copy; if (bestMatch==null) bestMatch = copy; } if (bestMatch!=null) return bestMatch; // fall back for parameterless constructor if (superType.isPrimaryClassNode()) { return Parameter.EMPTY_ARRAY; } return null; }
@Override public void visitClass(ClassNode node) { this.classNode = node; thisField = null; InnerClassNode innerClass = null; if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) { innerClass = (InnerClassNode) node; if (!isStatic(innerClass) && innerClass.getVariableScope() == null) { thisField = innerClass.addField("this$0", PUBLIC_SYNTHETIC, node.getOuterClass().getPlainNodeReference(), null); } } super.visitClass(node); if (node.isEnum() || node.isInterface()) return; if (innerClass == null) return; if (node.getSuperClass().isInterface() || Traits.isAnnotatedWithTrait(node.getSuperClass())) { node.addInterface(node.getUnresolvedSuperClass()); node.setUnresolvedSuperClass(ClassHelper.OBJECT_TYPE); } }
checkCyclicInheritance(originalNode, parentToCompare.getUnresolvedSuperClass(), null); } else { if(interfacesToCompare != null && interfacesToCompare.length > 0) {
public void visitClass(ClassNode node) { ClassNode oldClass = currentClass; currentClass = node; checkImplementsAndExtends(node); if (source != null && !source.getErrorCollector().hasErrors()) { checkClassForIncorrectModifiers(node); checkInterfaceMethodVisibility(node); checkAbstractMethodVisibility(node); checkClassForOverwritingFinal(node); checkMethodsForIncorrectModifiers(node); checkMethodsForIncorrectName(node); checkMethodsForWeakerAccess(node); checkMethodsForOverridingFinal(node); checkNoAbstractMethodsNonabstractClass(node); checkClassExtendsAllSelfTypes(node); checkNoStaticMethodWithSameSignatureAsNonStatic(node); checkGenericsUsage(node, node.getUnresolvedInterfaces()); checkGenericsUsage(node, node.getUnresolvedSuperClass()); } super.visitClass(node); currentClass = oldClass; }