@Override public void visitField(FieldNode node) { addNode(fields, node.getName(), node); super.visitField(node); }
private static List<FieldNode> filterFields(List<FieldNode> fieldNodes, List<String> includes, List<String> excludes, boolean allNames) { List<FieldNode> fields = new ArrayList<FieldNode>(); for (FieldNode fNode : fieldNodes) { if (AbstractASTTransformation.shouldSkipUndefinedAware(fNode.getName(), excludes, includes, allNames)) continue; fields.add(fNode); } return fields; }
public static List<String> getInstanceNonPropertyFieldNames(ClassNode cNode) { List<FieldNode> fList = getInstanceNonPropertyFields(cNode); List<String> result = new ArrayList<String>(fList.size()); for (FieldNode fNode : fList) { result.add(fNode.getName()); } return result; }
public Field(Spec parent, FieldNode ast, int ordinal) { super(parent, ast); setName(ast.getName()); this.ordinal = ordinal; this.hasInitialExpression = ast.hasInitialExpression(); }
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; }
public static List<FieldNode> getInstanceNonPropertyFields(ClassNode cNode) { final List<FieldNode> result = new ArrayList<FieldNode>(); for (FieldNode fNode : cNode.getFields()) { if (!fNode.isStatic() && cNode.getProperty(fNode.getName()) == null) { result.add(fNode); } } return result; }
private static void ensureNotPublic(AbstractASTTransformation xform, String cNode, FieldNode fNode) { String fName = fNode.getName(); // TODO: do we need to lock down things like: $ownClass if (fNode.isPublic() && !fName.contains("$") && !(fNode.isStatic() && fNode.isFinal())) { xform.addError("Public field '" + fName + "' not allowed for " + MY_TYPE_NAME + " class '" + cNode + "'.", fNode); } }
public void visitProperty(PropertyNode statement) { // the verifier created the field and the setter/getter methods, so here is // not really something to do onLineNumber(statement, "visitProperty:" + statement.getField().getName()); controller.setMethodNode(null); }
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); }
private static ConstructorNode createInitializerConstructor(ClassNode buildee, ClassNode builder, List<FieldNode> fields) { ClassNode paramType = makeClassSafeWithGenerics(builder, setGenTypes(fields.size())); List<Expression> argsList = new ArrayList<Expression>(); Parameter initParam = param(paramType, "initializer"); for (FieldNode fieldNode : fields) { argsList.add(propX(varX(initParam), fieldNode.getName())); } return buildee.addConstructor(ACC_PUBLIC, params(param(paramType, "initializer")), NO_EXCEPTIONS, block(ctorThisS(args(argsList)))); }
@Override public void visitField(FieldNode gField) { PropertyNode owner = spec.getAst().getProperty(gField.getName()); if (gField.isStatic()) return; Field field = new Field(spec, gField, fieldCount++); field.setShared(AstUtil.hasAnnotation(gField, Shared.class)); field.setOwner(owner); spec.getFields().add(field); }
private static void addMethod(FieldNode fieldNode, BlockStatement body, ClassNode type) { int visibility = ACC_PUBLIC; if (fieldNode.isStatic()) visibility |= ACC_STATIC; String propName = MetaClassHelper.capitalize(fieldNode.getName().substring(1)); ClassNode declaringClass = fieldNode.getDeclaringClass(); addGeneratedMethod(declaringClass, "get" + propName, visibility, type, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); if (ClassHelper.boolean_TYPE.equals(type)) { addGeneratedMethod(declaringClass, "is" + propName, visibility, type, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, stmt(callThisX("get" + propName))); } }
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 static BinaryExpression bothSelfRecursiveFieldX(FieldNode fNode, Expression other) { final Expression fieldExpr = varX(fNode); final Expression otherExpr = propX(other, fNode.getName()); return andX( sameX(fieldExpr, varX("this")), sameX(otherExpr, other) ); } }
public void visitField(FieldNode node) { // Do not visit fields which are manually added due to optimization if (!node.getName().startsWith("$")) { visitType(node.getOriginType()); visitNode(node); super.visitField(node); } }
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 createBuildeeMethods(ClassNode buildee, MethodNode mNode, ClassNode builder, List<FieldNode> fields) { ClassNode paramType = makeClassSafeWithGenerics(builder, setGenTypes(fields.size())); List<Expression> argsList = new ArrayList<Expression>(); Parameter initParam = param(paramType, "initializer"); for (FieldNode fieldNode : fields) { argsList.add(propX(varX(initParam), fieldNode.getName())); } String newName = "$" + mNode.getName(); // can't have private and public methods of the same name, so rename original buildee.addMethod(mNode.getName(), PUBLIC_STATIC, mNode.getReturnType(), params(param(paramType, "initializer")), NO_EXCEPTIONS, block(stmt(callX(buildee, newName, args(argsList))))); renameMethod(buildee, mNode, newName); }
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 BinaryExpression differentSelfRecursiveFieldX(FieldNode fNode, Expression other) { final Expression fieldExpr = varX(fNode); final Expression otherExpr = propX(other, fNode.getName()); return orX( andX(sameX(fieldExpr, varX("this")), notX(sameX(otherExpr, other))), andX(notX(sameX(fieldExpr, varX("this"))), sameX(otherExpr, other)) ); }