private static String suffixForField(FieldNode fNode) { // use primitives for efficiency if (fNode.getType() == ClassHelper.int_TYPE) return "Int"; if (fNode.getType() == ClassHelper.boolean_TYPE) return "Boolean"; // currently char isn't found due to a bug, so go with Object // if (fNode.getType() == ClassHelper.char_TYPE) return "Char"; if (fNode.getType() == ClassHelper.long_TYPE) return "Long"; if (fNode.getType() == ClassHelper.short_TYPE) return "Short"; if (fNode.getType() == ClassHelper.byte_TYPE) return "Byte"; if (fNode.getType() == ClassHelper.float_TYPE) return "Float"; if (fNode.getType() == ClassHelper.double_TYPE) return "Double"; return "Object"; } }
@Override public void visitField(final FieldNode field) { result.set(field.getType()); } }
public void visitField(FieldNode node) { ClassNode t = node.getType(); if(!fieldTypesChecked.contains(node)) { resolveOrFail(t, node); } super.visitField(node); }
@Override public void visitField(FieldNode node) { super.visitField(node); addToCache(node.getType()); } @Override
private static void addArrayGetter(FieldNode fNode) { addGetter(fNode, fNode.getType().getComponentType()); }
private static Parameter[] getParams(List<FieldNode> fields, ClassNode cNode) { Parameter[] parameters = new Parameter[fields.size()]; for (int i = 0; i < parameters.length; i++) { FieldNode fNode = fields.get(i); Map<String,ClassNode> genericsSpec = createGenericsSpec(fNode.getDeclaringClass()); extractSuperClassGenerics(fNode.getType(), cNode, genericsSpec); ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, fNode.getType()); parameters[i] = new Parameter(correctedType, fNode.getName()); } return parameters; }
private Statement createGetterBodyArrayOrCloneable(FieldNode fNode) { final Expression fieldExpr = varX(fNode); final Expression expression = cloneArrayOrCloneableExpr(fieldExpr, fNode.getType()); return safeExpression(fieldExpr, expression); }
@Override public void visitField(FieldNode node) { ClassNode type = node.getType(); checkGenericsUsage(type, type.redirect()); super.visitField(node); }
protected static List<PropertyInfo> getPropertyInfoFromClassNode(ClassNode cNode, List<String> includes, List<String> excludes, boolean allNames) { List<PropertyInfo> props = new ArrayList<PropertyInfo>(); for (FieldNode fNode : getInstancePropertyFields(cNode)) { if (shouldSkip(fNode.getName(), excludes, includes, allNames)) continue; props.add(new PropertyInfo(fNode.getName(), fNode.getType())); } return props; }
private static void createSoft(FieldNode fieldNode, Expression initExpr) { final ClassNode type = fieldNode.getType(); fieldNode.setType(SOFT_REF); createSoftGetter(fieldNode, initExpr, type); createSoftSetter(fieldNode, type); }
public void visit(MethodVisitor mv) { if (field.isStatic()) { BytecodeHelper.load(mv, field.getType(), 0); mv.visitFieldInsn(PUTSTATIC, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } else { mv.visitVarInsn(ALOAD, 0); BytecodeHelper.load(mv, field.getType(), 1); mv.visitFieldInsn(PUTFIELD, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } mv.visitInsn(RETURN); } });
private static FieldNode createFieldCopy(ClassNode buildee, FieldNode fNode) { Map<String,ClassNode> genericsSpec = createGenericsSpec(fNode.getDeclaringClass()); extractSuperClassGenerics(fNode.getType(), buildee, genericsSpec); ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, fNode.getType()); return new FieldNode(fNode.getName(), fNode.getModifiers(), correctedType, buildee, DEFAULT_INITIAL_VALUE); }
private static Expression providedOrDefaultInitialValue(FieldNode fNode) { Expression initialExp = fNode.getInitialExpression() != null ? fNode.getInitialExpression() : ConstantExpression.NULL; final ClassNode paramType = fNode.getType(); if (ClassHelper.isPrimitiveType(paramType) && initialExp.equals(ConstantExpression.NULL)) { initialExp = primitivesInitialValues.get(paramType.getTypeClass()); } return initialExp; }
public void visit(MethodVisitor mv) { if (field.isStatic()) { mv.visitFieldInsn(GETSTATIC, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } else { mv.visitVarInsn(ALOAD, 0); mv.visitFieldInsn(GETFIELD, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } BytecodeHelper.doReturn(mv, field.getType()); } });
public void visitField(FieldNode fieldNode) { cv.visitField( fieldNode.getModifiers(), fieldNode.getName(), BytecodeHelper.getTypeDescription(fieldNode.getType()), null, //fieldValue, //br all the sudden that one cannot init the field here. init is done in static initializer and instance initializer. null); }
public void visitField(FieldNode node) { if (currentClass.getDeclaredField(node.getName()) != node) { addError("The " + getDescription(node) + " is declared multiple times.", node); } checkInterfaceFieldModifiers(node); checkGenericsUsage(node, node.getType()); if (node.getType().equals(VOID_TYPE)) { addError("The " + getDescription(node) + " has invalid type void", node); } super.visitField(node); }
private static Parameter createParam(FieldNode fNode, String name, boolean defaults, AbstractASTTransformation xform, boolean makeImmutable) { Parameter param = new Parameter(fNode.getType(), name); if (defaults) { param.setInitialExpression(providedOrDefaultInitialValue(fNode)); } else if (!makeImmutable) { // TODO we could support some default vals provided they were listed last if (fNode.getInitialExpression() != null) { xform.addError("Error during " + MY_TYPE_NAME + " processing, default value processing disabled but default value found for '" + fNode.getName() + "'", fNode); } } return param; }
private void getThis(MethodVisitor mv, String classInternalName, String outerClassDescriptor, String innerClassInternalName) { mv.visitVarInsn(ALOAD, 0); if (CLOSURE_TYPE.equals(thisField.getType())) { mv.visitFieldInsn(GETFIELD, classInternalName, "this$0", CLOSURE_DESCRIPTOR); mv.visitMethodInsn(INVOKEVIRTUAL, CLOSURE_INTERNAL_NAME, "getThisObject", "()Ljava/lang/Object;", false); mv.visitTypeInsn(CHECKCAST, innerClassInternalName); } else { mv.visitFieldInsn(GETFIELD, classInternalName, "this$0", outerClassDescriptor); } }
private static void initializeFields(List<FieldNode> fields, BlockStatement body, boolean useSetters) { for (FieldNode field : fields) { String name = field.getName(); body.addStatement( stmt(useSetters && !field.isFinal() ? callThisX(getSetterName(name), varX(param(field.getType(), name))) : assignX(propX(varX("this"), field.getName()), varX(param(field.getType(), name))) ) ); } }
private static void create(FieldNode fieldNode, final Expression initExpr) { final BlockStatement body = new BlockStatement(); if (fieldNode.isStatic()) { addHolderClassIdiomBody(body, fieldNode, initExpr); } else if (fieldNode.isVolatile()) { addDoubleCheckedLockingBody(body, fieldNode, initExpr); } else { addNonThreadSafeBody(body, fieldNode, initExpr); } addMethod(fieldNode, body, fieldNode.getType()); }