public void visitClass(ClassNode node) { if (!node.isEnum()) return; completeEnum(node); }
public void visitClass(ClassNode node) { if (!node.isEnum()) return; completeEnum(node); }
public void visitConstructorCallExpression(ConstructorCallExpression call) { ClassNode callType = call.getType(); if (callType.isEnum() && !callType.equals(verifier.getClassNode())) { throw new RuntimeParserException("Enum constructor calls are only allowed inside the enum class", call); } }
protected static boolean shouldHandleImplicitThisForInnerClass(ClassNode cn) { if (cn.isEnum() || cn.isInterface()) return false; if ((cn.getModifiers() & Opcodes.ACC_STATIC) != 0) return false; if (!(cn instanceof InnerClassNode)) return false; InnerClassNode innerClass = (InnerClassNode) cn; // scope != null means aic, we don't handle that here if (innerClass.getVariableScope() != null) return false; // static inner classes don't need this$0 return (innerClass.getModifiers() & Opcodes.ACC_STATIC) == 0; } }
@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; thisField = innerClass.getField("this$0"); if (innerClass.getVariableScope() == null && innerClass.getDeclaredConstructors().isEmpty()) { // add dummy constructor innerClass.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY, null, null); } } if (node.isEnum() || node.isInterface()) return; // use Iterator.hasNext() to check for available inner classes if (node.getInnerClasses().hasNext()) addDispatcherMethods(node); if (innerClass == null) return; super.visitClass(node); addDefaultMethods(innerClass); }
boolean isEnum = classNode.isEnum(); boolean isAnnotationDefinition = classNode.isAnnotationDefinition(); printAnnotations(out, classNode);
public static boolean isKnownImmutableType(ClassNode fieldType, List<String> knownImmutableClasses) { if (builtinOrDeemedType(fieldType, knownImmutableClasses)) return true; if (!fieldType.isResolved()) return false; if ("java.util.Optional".equals(fieldType.getName()) && fieldType.getGenericsTypes() != null && fieldType.getGenericsTypes().length == 1) { GenericsType optionalType = fieldType.getGenericsTypes()[0]; if (optionalType.isResolved() && !optionalType.isPlaceholder() && !optionalType.isWildcard()) { ClassNode valueType = optionalType.getType(); if (builtinOrDeemedType(valueType, knownImmutableClasses)) return true; if (valueType.isEnum()) return true; } } return fieldType.isEnum() || ClassHelper.isPrimitiveType(fieldType) || hasImmutableAnnotation(fieldType); }
final boolean isEnum = node.isEnum(); List<Statement> initStmtsAfterEnumValuesInit = new ArrayList<Statement>(); Set<String> explicitStaticPropsInEnum = new HashSet<String>();
@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); } }
private boolean shouldImplicitlyPassThisPara(ConstructorCallExpression cce) { boolean pass = false; ClassNode superCN = classNode.getSuperClass(); if (cce.isThisCall()) { pass = true; } else if (cce.isSuperCall()) { // if the super class is another non-static inner class in the same outer class hierarchy, implicit this // needs to be passed if (!superCN.isEnum() && !superCN.isInterface() && superCN instanceof InnerClassNode) { InnerClassNode superInnerCN = (InnerClassNode) superCN; if (!isStatic(superInnerCN) && classNode.getOuterClass().isDerivedFrom(superCN.getOuterClass())) { pass = true; } } } return pass; }
private boolean validateEnumConstant(Expression exp) { if (exp instanceof PropertyExpression) { PropertyExpression pe = (PropertyExpression) exp; String name = pe.getPropertyAsString(); if (pe.getObjectExpression() instanceof ClassExpression && name != null) { ClassExpression ce = (ClassExpression) pe.getObjectExpression(); ClassNode type = ce.getType(); if (type.isEnum()) { boolean ok = false; try { FieldNode enumField = type.getDeclaredField(name); ok = enumField != null && enumField.getType().equals(type); } catch(Exception ex) { // ignore } if(!ok) { addError("No enum const " + type.getName() + "." + name, pe); return false; } } } } return true; }
MethodNode directMethodCallCandidate = mn.get(0); ClassNode returnType = getType(directMethodCallCandidate); if (returnType.isUsingGenerics() && !returnType.isEnum()) { visitMethodCallArguments(receiver, argumentList, true, directMethodCallCandidate); ClassNode irtg = inferReturnTypeGenerics(chosenReceiver.getType(), directMethodCallCandidate, callArguments);
ClassExpression ce = (ClassExpression) pe.getObjectExpression(); ClassNode type = ce.getType(); if (type.isEnum() || !(type.isResolved() || type.isPrimaryClassNode())) return exp;
if (currentClass.isEnum() && starImports.containsKey(currentClass.getName())) { ImportNode importNode = starImports.get(currentClass.getName()); starImportType = importNode == null ? null : importNode.getType();
ClassNode argType = staticCompilationTransformer.getTypeChooser().resolveType(indexExpr, staticCompilationTransformer.getClassNode()); ClassNode indexType = ClassHelper.getWrapper(argType); if (componentType.isEnum() && ClassHelper.Number_TYPE == indexType) {
} else if (lType.isUsingGenerics() && !lType.isEnum() && hasRHSIncompleteGenericTypeInfo(resultType)) {
ClassNode type = ce.getType(); FieldNode field = ClassNodeUtils.getField(type, pe.getPropertyAsString()); if (type.isEnum() && field != null && field.isEnum()) return exp; Expression constant = findConstant(field); if (constant != null) return constant;
private boolean getField(PropertyExpression expression, Expression receiver, ClassNode receiverType, String name) { ClassNode classNode = controller.getClassNode(); boolean safe = expression.isSafe(); boolean implicitThis = expression.isImplicitThis(); if (makeGetField(receiver, receiverType, name, safe, implicitThis, samePackages(receiverType.getPackageName(), classNode.getPackageName()))) return true; if (receiver instanceof ClassExpression) { if (makeGetField(receiver, receiver.getType(), name, safe, implicitThis, samePackages(receiver.getType().getPackageName(), classNode.getPackageName()))) return true; if (makeGetPrivateFieldWithBridgeMethod(receiver, receiver.getType(), name, safe, implicitThis)) return true; } if (makeGetPrivateFieldWithBridgeMethod(receiver, receiverType, name, safe, implicitThis)) return true; boolean isClassReceiver = false; if (isClassClassNodeWrappingConcreteType(receiverType)) { isClassReceiver = true; receiverType = receiverType.getGenericsTypes()[0].getType(); } if (isClassReceiver && makeGetField(receiver, CLASS_Type, name, safe, false, true)) return true; if (receiverType.isEnum()) { controller.getMethodVisitor().visitFieldInsn(GETSTATIC, BytecodeHelper.getClassInternalName(receiverType), name, BytecodeHelper.getTypeDescription(receiverType)); controller.getOperandStack().push(receiverType); return true; } return false; } }
if (makeGetField(receiver, CLASS_Type, methodName, safe, false, true)) return; if (receiverType.isEnum()) { mv.visitFieldInsn(GETSTATIC, BytecodeHelper.getClassInternalName(receiverType), methodName, BytecodeHelper.getTypeDescription(receiverType)); controller.getOperandStack().push(receiverType);