private void addMissingFields() { for (FieldNode f : missingFields) { currentClass.addField(f); } }
private static void addFields(ClassNode buildee, List<FieldNode> filteredFields, ClassNode builder) { for (FieldNode filteredField : filteredFields) { builder.addField(createFieldCopy(buildee, filteredField)); } }
protected void setUp() throws Exception { classNode.addField("field", ACC_PUBLIC, ClassHelper.STRING_TYPE, null); }
public FieldNode addField(String name, int modifiers, ClassNode type, Expression initialValue) { FieldNode node = new FieldNode(name, modifiers, type, redirect(), initialValue); addField(node); return node; }
public void addProperty(PropertyNode node) { node.setDeclaringClass(redirect()); FieldNode field = node.getField(); addField(field); final ClassNode r = redirect(); if (r.properties == null) r.properties = new ArrayList<PropertyNode> (); r.properties.add(node); }
public void visit(ASTNode[] nodes, SourceUnit sourceUnit) { ClassNode classNode = (ClassNode) nodes[1]; classNode.addField(new FieldNode("f1", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, classNode, null)); }
private static void addFastPathHelperFieldsAndHelperMethod(ClassNode node, final String classInternalName, boolean knownSpecialCase) { if (node.getNodeMetaData(ClassNodeSkip.class) != null) return; FieldNode stMCB = checkFieldDoesNotExist(node, STATIC_METACLASS_BOOL); if (stMCB == null) { stMCB = node.addField( STATIC_METACLASS_BOOL, ACC_PUBLIC | ACC_STATIC | ACC_SYNTHETIC | ACC_TRANSIENT, ClassHelper.boolean_TYPE, null); stMCB.setSynthetic(true); } }
public void visit(ASTNode[] nodes, SourceUnit sourceUnit) { ClassNode classNode = (ClassNode) nodes[1]; classNode.addField(new FieldNode("f2", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, classNode, null)); }
public void visit(ASTNode[] nodes, SourceUnit sourceUnit) { ClassNode classNode = (ClassNode) nodes[1]; classNode.addField(new FieldNode("f3", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, classNode, null)); }
private static List<FieldNode> convertParamsToFields(ClassNode builder, Parameter[] parameters) { List<FieldNode> fieldNodes = new ArrayList<FieldNode>(); for(Parameter parameter: parameters) { Map<String,ClassNode> genericsSpec = createGenericsSpec(builder); ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, parameter.getType()); FieldNode fieldNode = new FieldNode(parameter.getName(), parameter.getModifiers(), correctedType, builder, DEFAULT_INITIAL_VALUE); fieldNodes.add(fieldNode); builder.addField(fieldNode); } return fieldNodes; }
public static FieldNode addEnumConstant(ClassNode enumClass, String name, Expression init) { int modifiers = PUBLIC_FS | Opcodes.ACC_ENUM; if (init != null && !(init instanceof ListExpression)) { ListExpression list = new ListExpression(); list.addExpression(init); init = list; } FieldNode fn = new FieldNode(name, modifiers, enumClass.getPlainNodeReference(), enumClass, init); enumClass.addField(fn); return fn; } }
public void testFields() throws Exception { ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE); classNode.addField("x", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, null); classNode.addField("y", ACC_PUBLIC, ClassHelper.Integer_TYPE, null); classNode.addField("z", ACC_PRIVATE, ClassHelper.STRING_TYPE, null); Class fooClass = loadClass(classNode); assertTrue("Loaded a new class", fooClass != null); assertField(fooClass, "x", Modifier.PUBLIC, ClassHelper.OBJECT_TYPE); assertField(fooClass, "y", Modifier.PUBLIC, ClassHelper.Integer_TYPE); assertField(fooClass, "z", Modifier.PRIVATE, ClassHelper.STRING_TYPE); }
public FieldNode addLoggerFieldToClass(ClassNode classNode, String logFieldName, String categoryName) { return classNode.addField(logFieldName, Opcodes.ACC_FINAL | Opcodes.ACC_TRANSIENT | Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE, LOGGER_CLASSNODE, new MethodCallExpression( new ClassExpression(LOGGER_CLASSNODE), "getLogger", new ConstantExpression(getCategoryName(classNode, categoryName)))); }
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 FieldNode addLoggerFieldToClass(ClassNode classNode, String logFieldName, String categoryName) { return classNode.addField(logFieldName, Opcodes.ACC_FINAL | Opcodes.ACC_TRANSIENT | Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE, classNode(LOGGER_NAME), new MethodCallExpression( new ClassExpression(classNode(FACTORY_NAME)), "getLogger", new ConstantExpression(getCategoryName(classNode, categoryName)))); }
public FieldNode addLoggerFieldToClass(ClassNode classNode, String logFieldName, String categoryName) { return classNode.addField(logFieldName, Opcodes.ACC_FINAL | Opcodes.ACC_TRANSIENT | Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE, classNode(LOGGER_NAME), new MethodCallExpression( new ClassExpression(classNode(LOGGERFACTORY_NAME)), "getLog", new ConstantExpression(getCategoryName(classNode, categoryName)))); }
public FieldNode addLoggerFieldToClass(ClassNode classNode, String logFieldName, String categoryName) { return classNode.addField(logFieldName, Opcodes.ACC_FINAL | Opcodes.ACC_TRANSIENT | Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE, classNode(LOGGER_NAME), new MethodCallExpression( new ClassExpression(classNode(LOGGER_NAME)), "getLogger", new ConstantExpression(getCategoryName(classNode, categoryName)))); }
public FieldNode addLoggerFieldToClass(ClassNode classNode, String logFieldName, String categoryName) { return classNode.addField(logFieldName, Opcodes.ACC_FINAL | Opcodes.ACC_TRANSIENT | Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE, classNode(LOGGER_NAME), new MethodCallExpression( new ClassExpression(classNode(LOG_MANAGER_NAME)), "getLogger", new ConstantExpression(getCategoryName(classNode, categoryName)))); }
private void createField(ClassNode classNode, String propertyName, boolean isLazy, boolean isStrict) { int modifiers = isLazy ? ACC_PRIVATE | ACC_STATIC | ACC_VOLATILE : ACC_PUBLIC | ACC_FINAL | ACC_STATIC; Expression initialValue = isLazy ? null : ctorX(classNode); final FieldNode fieldNode = classNode.addField(propertyName, modifiers, newClass(classNode), initialValue); createConstructor(classNode, fieldNode, propertyName, isStrict); final BlockStatement body = new BlockStatement(); body.addStatement(isLazy ? lazyBody(classNode, fieldNode) : nonLazyBody(fieldNode)); addGeneratedMethod(classNode, getGetterName(propertyName), ACC_STATIC | ACC_PUBLIC, newClass(classNode), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); }
public void testDetectsIncorrectMemberVisibilityInInterface() throws Exception { ClassNode node = new ClassNode("zzz", ACC_ABSTRACT | ACC_INTERFACE, ClassHelper.OBJECT_TYPE); node.addMethod(new MethodNode("prim", ACC_PRIVATE, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, null)); node.addMethod(new MethodNode("prom", ACC_PROTECTED, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, null)); node.addField("prif", ACC_PRIVATE, ClassHelper.OBJECT_TYPE, null); node.addField("prof", ACC_PROTECTED, ClassHelper.OBJECT_TYPE, null); addDummyConstructor(node); verifier.visitClass(node); checkErrorCount(4); checkErrorMessage(EXPECTED_PROTECTED_FIELD_ERROR_MESSAGE); checkErrorMessage(EXPECTED_PRIVATE_FIELD_ERROR_MESSAGE); checkErrorMessage(EXPECTED_PROTECTED_METHOD_ERROR_MESSAGE); checkErrorMessage(EXPECTED_PRIVATE_METHOD_ERROR_MESSAGE); }