@Override public FieldNode getField(final String name) { for (ClassNode delegate : delegates) { FieldNode field = delegate.getField(name); if (field != null) return field; } return null; }
private static void addProperty(ClassNode cNode, PropertyNode pNode) { final FieldNode fn = pNode.getField(); cNode.getFields().remove(fn); cNode.addProperty(pNode.getName(), pNode.getModifiers() | ACC_FINAL, pNode.getType(), pNode.getInitialExpression(), pNode.getGetterBlock(), pNode.getSetterBlock()); final FieldNode newfn = cNode.getField(fn.getName()); cNode.getFields().remove(newfn); cNode.addField(fn); }
public static FieldExpression fieldX(ClassNode owner, String fieldName) { return new FieldExpression(owner.getField(fieldName)); }
private static String buildUniqueName(ClassNode owner, String ident, MethodNode methodNode) { StringBuilder nameBuilder = new StringBuilder("memoizedMethod" + ident + "$").append(methodNode.getName()); if (methodNode.getParameters() != null) { for (Parameter parameter : methodNode.getParameters()) { nameBuilder.append(buildTypeName(parameter.getType())); } } while (owner.getField(nameBuilder.toString()) != null) { nameBuilder.insert(0, "_"); } return nameBuilder.toString(); }
@Override public void visitClass(ClassNode node) { FieldNode logField = node.getField(logFieldName); if (logField != null && logField.getOwner().equals(node)) { addError("Class annotated with Log annotation cannot have log field declared", logField); } else if (logField != null && !Modifier.isPrivate(logField.getModifiers())) { addError("Class annotated with Log annotation cannot have log field declared because the field exists in the parent class: " + logField.getOwner().getName(), logField); } else { logNode = loggingStrategy.addLoggerFieldToClass(node, logFieldName, categoryName); } super.visitClass(node); }
FieldNode fn = type.redirect().getField(pe.getPropertyAsString()); if (fn != null && fn.isStatic() && fn.isFinal()) { Expression ce2 = transformInlineConstants(fn.getInitialValueExpression(), attrType);
helperField = fieldHelperClassNode.getField(String.format("$0x%04x", mod) + fieldName); if (helperField != null) { if ((mod & Opcodes.ACC_STATIC) != 0) isStatic = Opcodes.ACC_STATIC; helperField = fieldHelperClassNode.getField(Traits.FIELD_PREFIX + Traits.PUBLIC_FIELD_PREFIX + fieldName); if (helperField==null) { publicField = false; helperField = fieldHelperClassNode.getField(Traits.FIELD_PREFIX + Traits.PRIVATE_FIELD_PREFIX + fieldName); helperField = fieldHelperClassNode.getField(Traits.STATIC_FIELD_PREFIX+Traits.PUBLIC_FIELD_PREFIX+fieldName); if (helperField==null) { publicField = false; helperField = fieldHelperClassNode.getField(Traits.STATIC_FIELD_PREFIX+Traits.PRIVATE_FIELD_PREFIX +fieldName); Expression fieldExpr = varX(cNode.getField(fieldName)); boolean finalSetter = !getter && (fieldMods & Opcodes.ACC_FINAL) != 0; Statement body =
ClassNode type = staticCompilationTransformer.getTypeChooser().resolveType(objectExpression, staticCompilationTransformer.getClassNode()); if (isCallOnClosure(expr) && staticCompilationTransformer.getClassNode() != null) { FieldNode field = staticCompilationTransformer.getClassNode().getField(expr.getMethodAsString()); if (field != null) { VariableExpression vexp = new VariableExpression(field);
FieldNode thisField = current.getField("this$0"); current = current.getOuterClass(); if (thisField != null) {
ClassNode owner = (ClassNode) vexp.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER); if (owner != null) { FieldNode veFieldNode = owner.getField(vexp.getName()); if (veFieldNode != null) { fieldNode = veFieldNode;
@SuppressWarnings("unchecked") private boolean makeGetPrivateFieldWithBridgeMethod(final Expression receiver, final ClassNode receiverType, final String fieldName, final boolean safe, final boolean implicitThis) { FieldNode field = receiverType.getField(fieldName); ClassNode outerClass = receiverType.getOuterClass(); if (field==null && implicitThis && outerClass !=null && !receiverType.isStaticClass()) {
@SuppressWarnings("unchecked") private boolean makeSetPrivateFieldWithBridgeMethod(final Expression receiver, final ClassNode receiverType, final String fieldName, final Expression arguments, final boolean safe, final boolean spreadSafe, final boolean implicitThis) { WriterController controller = getController(); FieldNode field = receiverType.getField(fieldName); ClassNode outerClass = receiverType.getOuterClass(); if (field == null && implicitThis && outerClass != null && !receiverType.isStaticClass()) {
private void setPropertyOfSuperClass(ClassNode classNode, PropertyExpression expression, MethodVisitor mv) { String fieldName = expression.getPropertyAsString(); FieldNode fieldNode = classNode.getSuperClass().getField(fieldName); if (null == fieldNode) { throw new RuntimeParserException("Failed to find field[" + fieldName + "] of " + classNode.getName() + "'s super class", expression); } if (fieldNode.isFinal()) { throw new RuntimeParserException("Cannot modify final field[" + fieldName + "] of " + classNode.getName() + "'s super class", expression); } MethodNode setter = findSetterOfSuperClass(classNode, fieldNode); MethodNode getter = findGetterOfSuperClass(classNode, fieldNode); if (fieldNode.isPrivate() && !getterAndSetterExists(setter, getter)) { throw new RuntimeParserException("Cannot access private field[" + fieldName + "] of " + classNode.getName() + "'s super class", expression); } OperandStack operandStack = controller.getOperandStack(); operandStack.doAsType(fieldNode.getType()); mv.visitVarInsn(ALOAD, 0); operandStack.push(classNode); operandStack.swap(); String owner = BytecodeHelper.getClassInternalName(classNode.getSuperClass().getName()); String desc = BytecodeHelper.getTypeDescription(fieldNode.getType()); if (fieldNode.isPublic() || fieldNode.isProtected()) { mv.visitFieldInsn(PUTFIELD, owner, fieldName, desc); } else { mv.visitMethodInsn(INVOKESPECIAL, owner, setter.getName(), BytecodeHelper.getMethodDescriptor(setter), false); } }
boolean makeGetField(final Expression receiver, final ClassNode receiverType, final String fieldName, final boolean safe, final boolean implicitThis, final boolean samePackage) { FieldNode field = receiverType.getField(fieldName);
String ownerName = BytecodeHelper.getClassInternalName(iterType); if (iterType.getOuterClass()==null) break; FieldNode thisField = iterType.getField("this$0"); iterType = iterType.getOuterClass(); if (thisField == null) {
private FieldNode getMetaClassField(ClassNode node) { FieldNode ret = node.getField("metaClass"); if (ret!=null) return ret; ClassNode current = node; while (current!=null && current!=ClassHelper.OBJECT_TYPE) { current = current.getSuperClass(); ret = current.getField("metaClass"); if (ret==null) continue; if (Modifier.isPrivate(ret.getModifiers())) continue; return ret; } return null; }
public static void addFieldIfNonExistent(ClassNode classNode, ClassNode fieldType, String fieldName) { if (classNode != null && classNode.getField(fieldName) == null) { classNode.addField(fieldName, Modifier.PRIVATE, fieldType, new ConstructorCallExpression(fieldType, new ArgumentListExpression())); } }
protected void addConstraintsField(final ClassNode classNode) { FieldNode field = classNode.getField(CONSTRAINED_PROPERTIES_PROPERTY_NAME); if (field == null || !field.getDeclaringClass().equals(classNode)) { classNode.addField(CONSTRAINED_PROPERTIES_PROPERTY_NAME, Modifier.STATIC | Modifier.PRIVATE, new ClassNode(Map.class), new ConstantExpression(null)); } }
private Expression findStaticField(ClassNode staticImportType, String fieldName) { if (staticImportType.isPrimaryClassNode() || staticImportType.isResolved()) { FieldNode field = staticImportType.getField(fieldName); if (field != null && field.isStatic()) return new PropertyExpression(new ClassExpression(staticImportType), fieldName); } return null; }