How to use

addField

method

in

org.codehaus.groovy.ast.ClassNode

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);
}