Revert to having getters

javaparser-generator-utils/src/main/java/com/github/javaparser/generator/utils/GeneratorUtils.java

@@ -1,10 +1,14 @@
 package com.github.javaparser.generator.utils;
 
 import java.io.File;
+import java.lang.reflect.Field;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
-public class GeneratorUtils {
+public final class GeneratorUtils {
+    private GeneratorUtils() {
+    }
+
     /**
      * Capitalizes the first character in the string.
      */
@@ -25,6 +29,24 @@ public static String decapitalize(String string) {
         return string.substring(0, 1).toLowerCase() + string.substring(1);
     }
 
+    public static String getterName(Field reflectionField) {
+        return getterName(reflectionField.getType(), reflectionField.getName());
+    }
+
+    public static String getterName(Class<?> type, String name) {
+        if (name.startsWith("is")) {
+            return name;
+        } else if (type.equals(Boolean.class)) {
+            return "is" + capitalize(name);
+        }
+        return "get" + capitalize(name);
+    }
+
+    public static String setterName(Field reflectionField) {
+        return "set" + capitalize(reflectionField.getName());
+    }
+
+
     /**
      * A shortcut to String.format.
      */

javaparser-metamodel-generator/src/main/java/com/github/javaparser/generator/metamodel/MetaModelGenerator.java

@@ -253,7 +253,7 @@ private void generateFieldMetaModels(Class<?> c, ClassOrInterfaceDeclaration cla
                     isEnumSet,
                     hasWildcard);
             String fieldSetting = f("%s.%s=%s;", classMetaModelFieldName, propertyMetaModelFieldName, propertyInitializer);
-            String fieldAddition = f("%s.propertyMetaModels.add(%s.%s);", classMetaModelFieldName, classMetaModelFieldName, propertyMetaModelFieldName);
+            String fieldAddition = f("%s.getPropertyMetaModels().add(%s.%s);", classMetaModelFieldName, classMetaModelFieldName, propertyMetaModelFieldName);
 
             initializeFieldMetaModelsStatements.add(parseStatement(fieldSetting));
             initializeFieldMetaModelsStatements.add(parseStatement(fieldAddition));

javaparser-metamodel/pom.xml

@@ -15,7 +15,12 @@
         <dependency>
             <groupId>com.github.javaparser</groupId>
             <artifactId>javaparser-core</artifactId>
-            <version>3.0.2-SNAPSHOT</version>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.javaparser</groupId>
+            <artifactId>javaparser-generator-utils</artifactId>
+            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>junit</groupId>

javaparser-metamodel/src/main/java/com/github/javaparser/metamodel/BaseNodeMetaModel.java

@@ -9,13 +9,13 @@
  * These are all Nodes, except NodeList.
  */
 public class BaseNodeMetaModel {
-    public final Optional<BaseNodeMetaModel> superClassMetaModel;
-    public final JavaParserMetaModel javaParserMetaModel;
-    public final List<PropertyMetaModel> propertyMetaModels = new ArrayList<>();
-    public final Class<?> reflectionClass;
-    public final String name;
-    public final String packageName;
-    public final boolean isAbstract;
+    private final Optional<BaseNodeMetaModel> superClassMetaModel;
+    private final JavaParserMetaModel javaParserMetaModel;
+    private final List<PropertyMetaModel> propertyMetaModels = new ArrayList<>();
+    private final Class<?> reflectionClass;
+    private final String name;
+    private final String packageName;
+    private final boolean isAbstract;
 
     public BaseNodeMetaModel(Optional<BaseNodeMetaModel> superClassMetaModel, JavaParserMetaModel javaParserMetaModel, Class<?> reflectionClass, String name, String packageName, boolean isAbstract) {
         this.superClassMetaModel = superClassMetaModel;
@@ -34,6 +34,34 @@ public String getQualifiedClassName() {
         return packageName + "." + name;
     }
 
+    public Optional<BaseNodeMetaModel> getSuperClassMetaModel() {
+        return superClassMetaModel;
+    }
+
+    public JavaParserMetaModel getJavaParserMetaModel() {
+        return javaParserMetaModel;
+    }
+
+    public List<PropertyMetaModel> getPropertyMetaModels() {
+        return propertyMetaModels;
+    }
+
+    public Class<?> getReflectionClass() {
+        return reflectionClass;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPackageName() {
+        return packageName;
+    }
+
+    public boolean isAbstract() {
+        return isAbstract;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

javaparser-metamodel/src/main/java/com/github/javaparser/metamodel/PropertyMetaModel.java

@@ -2,61 +2,99 @@
 
 import java.lang.reflect.Field;
 
-import static com.github.javaparser.utils.Utils.capitalize;
+import static com.github.javaparser.generator.utils.GeneratorUtils.getterName;
+import static com.github.javaparser.generator.utils.GeneratorUtils.setterName;
 
 /**
  * Meta-data about a property of a node in the AST.
  */
 public class PropertyMetaModel {
-    public final BaseNodeMetaModel classMetaModel;
-    public final String name;
-    public final Class<?> type;
+    private final BaseNodeMetaModel nodeMetaModel;
+    private final String name;
+    private final Class<?> type;
     //    public Optional<CommentMetaModel> typeReference;
 //    public Optional<Class<Integer>> tpe;
-    public final Field reflectionField;
-    public final boolean isNode;
-    public final boolean isOptional;
-    public final boolean isNodeList;
-    public final boolean isSet;
-    public final boolean hasWildcard;
-
-    public PropertyMetaModel(BaseNodeMetaModel classMetaModel, String name, Class<?> type, Field reflectionField, boolean isNode, boolean isOptional, boolean isNodeList, boolean isEnumSet, boolean hasWildcard) {
-        this.classMetaModel = classMetaModel;
+    private final Field reflectionField;
+    private final boolean isNode;
+    private final boolean isOptional;
+    private final boolean isNodeList;
+    private final boolean isEnumSet;
+    private final boolean hasWildcard;
+
+    public PropertyMetaModel(BaseNodeMetaModel nodeMetaModel, String name, Class<?> type, Field reflectionField, boolean isNode, boolean isOptional, boolean isNodeList, boolean isEnumSet, boolean hasWildcard) {
+        this.nodeMetaModel = nodeMetaModel;
         this.name = name;
         this.type = type;
         this.reflectionField = reflectionField;
         this.isNode = isNode;
         this.isOptional = isOptional;
         this.isNodeList = isNodeList;
-        this.isSet = isEnumSet;
+        this.isEnumSet = isEnumSet;
         this.hasWildcard = hasWildcard;
     }
 
     public boolean is(Class<?> c, String fieldName) {
-        return classMetaModel.is(c) && name.equals(fieldName);
+        return nodeMetaModel.is(c) && name.equals(fieldName);
     }
 
     public boolean is(String fieldName) {
         return name.equals(fieldName);
     }
 
+    /**
+     * @return the name used in the AST for the setter
+     */
     public String getSetterMethodName() {
-        return "set" + capitalize(reflectionField.getName());
+        return setterName(reflectionField);
     }
 
+    /**
+     * @return the name used in the AST for the getter
+     */
     public String getGetterMethodName() {
-        String name = reflectionField.getName();
-        if (name.startsWith("is")) {
-            return name;
-        } else if (reflectionField.getType().equals(Boolean.class)) {
-            return "is" + capitalize(name);
-        }
-        return "get" + capitalize(name);
+        return getterName(reflectionField);
+    }
+
+    public BaseNodeMetaModel getNodeMetaModel() {
+        return nodeMetaModel;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Class<?> getType() {
+        return type;
+    }
+
+    public Field getReflectionField() {
+        return reflectionField;
+    }
+
+    @Deprecated
+    public boolean isNode() {
+        return isNode;
+    }
+
+    public boolean isOptional() {
+        return isOptional;
+    }
+
+    public boolean isNodeList() {
+        return isNodeList;
+    }
+
+    public boolean isEnumSet() {
+        return isEnumSet;
+    }
+
+    public boolean hasWildcard() {
+        return hasWildcard;
     }
 
     @Override
     public String toString() {
-        return "(" + type.getSimpleName() + ")\t" + classMetaModel + "#" + name;
+        return "(" + type.getSimpleName() + ")\t" + nodeMetaModel + "#" + name;
     }
 
     @Override
@@ -75,4 +113,32 @@ public boolean equals(Object o) {
 
         return true;
     }
+
+    public String getTypeName() {
+        if (hasWildcard) {
+            return getRawTypeName() + "<?>";
+        }
+        return getRawTypeName();
+    }
+
+    public String getRawTypeName() {
+        return type.getSimpleName();
+    }
+
+    public String getFullTypeNameForGetter() {
+        if (isOptional) {
+            return "Optional<" + getFullTypeNameForSetter() + ">";
+        }
+        return getFullTypeNameForSetter();
+    }
+
+    public String getFullTypeNameForSetter() {
+        if (isNodeList) {
+            return "NodeList<" + getTypeName() + ">";
+        }
+        if (isEnumSet) {
+            return "EnumSet<" + getTypeName() + ">";
+        }
+        return getTypeName();
+    }
 }

javaparser-metamodel/src/test/java/com/github/javaparser/metamodel/JavaParserMetaModelTest.java

@@ -6,9 +6,9 @@ public class JavaParserMetaModelTest {
     @Test
     public void outputEverythingWithoutFailure() {
         JavaParserMetaModel javaParserMetaModel = new JavaParserMetaModel();
-        for (BaseNodeMetaModel classMetaModel : javaParserMetaModel.nodeMetaModels) {
-            for (PropertyMetaModel propertyMetaModel : classMetaModel.propertyMetaModels) {
-                System.out.println(classMetaModel.name + "." + propertyMetaModel.name);
+        for (BaseNodeMetaModel classMetaModel : javaParserMetaModel.getNodeMetaModels()) {
+            for (PropertyMetaModel propertyMetaModel : classMetaModel.getPropertyMetaModels()) {
+                System.out.println(classMetaModel.getName() + "." + propertyMetaModel.getName());
             }
         }
         System.out.println(javaParserMetaModel);

javaparser-metamodel/src/test/java/com/github/javaparser/metamodel/PropertyMetaModelTest.java

@@ -0,0 +1,37 @@
+package com.github.javaparser.metamodel;
+
+import com.github.javaparser.ast.Modifier;
+import com.github.javaparser.ast.body.BodyDeclaration;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class PropertyMetaModelTest {
+    @Test
+    public void whenPropertyIsVerySimpleThenTypeInfoIsCorrect() {
+        PropertyMetaModel bert = new PropertyMetaModel(null, "bert", int.class, null, false, false, false, false, false);
+        assertEquals("int", bert.getRawTypeName());
+        assertEquals("int", bert.getTypeName());
+        assertEquals("int", bert.getFullTypeNameForGetter());
+        assertEquals("int", bert.getFullTypeNameForSetter());
+    }
+
+    @Test
+    public void whenPropertyIsVeryComplexThenTypeInfoIsCorrect() {
+        PropertyMetaModel bert = new PropertyMetaModel(null, "bert", BodyDeclaration.class, null, true, true, true, false, true);
+        assertEquals("BodyDeclaration", bert.getRawTypeName());
+        assertEquals("BodyDeclaration<?>", bert.getTypeName());
+        assertEquals("Optional<NodeList<BodyDeclaration<?>>>", bert.getFullTypeNameForGetter());
+        assertEquals("NodeList<BodyDeclaration<?>>", bert.getFullTypeNameForSetter());
+    }
+
+    @Test
+    public void whenPropertyIsAnEnumThenTypeInfoIsCorrect() {
+        PropertyMetaModel bert = new PropertyMetaModel(null, "bert", Modifier.class, null, false, false, false, true, false);
+        assertEquals("Modifier", bert.getRawTypeName());
+        assertEquals("Modifier", bert.getTypeName());
+        assertEquals("EnumSet<Modifier>", bert.getFullTypeNameForGetter());
+        assertEquals("EnumSet<Modifier>", bert.getFullTypeNameForSetter());
+    }
+
+}

javaparser-visitor-generator/src/main/java/com/github/javaparser/generator/visitor/VisitorGenerator.java

@@ -45,19 +45,19 @@ private static void generateHashcodeVisitor(JavaParser javaParser, SourceRoot so
         ClassOrInterfaceDeclaration voidVisitor = voidVisitorCu.getClassByName("HashCodeVisitor").get();
         voidVisitor.getMethods().forEach(m -> voidVisitor.getMembers().remove(m));
 
-        for (BaseNodeMetaModel node : javaParserMetaModel.nodeMetaModels) {
-            if (!node.isAbstract) {
+        for (BaseNodeMetaModel node : javaParserMetaModel.getNodeMetaModels()) {
+            if (!node.isAbstract()) {
                 MethodDeclaration visitMethod = voidVisitor.addMethod("visit", PUBLIC)
-                        .addParameter(node.name, "n")
+                        .addParameter(node.getName(), "n")
                         .addParameter("Void", "arg")
                         .setType(new ClassOrInterfaceType("Integer"));
                 BlockStmt body = visitMethod.getBody().get();
 
-                List<PropertyMetaModel> allPropertyMetaModels = new ArrayList<>(node.propertyMetaModels);
+                List<PropertyMetaModel> allPropertyMetaModels = new ArrayList<>(node.getPropertyMetaModels());
                 BaseNodeMetaModel walkNode = node;
-                while (walkNode.superClassMetaModel.isPresent()) {
-                    walkNode = walkNode.superClassMetaModel.get();
-                    allPropertyMetaModels.addAll(walkNode.propertyMetaModels);
+                while (walkNode.getSuperClassMetaModel().isPresent()) {
+                    walkNode = walkNode.getSuperClassMetaModel().get();
+                    allPropertyMetaModels.addAll(walkNode.getPropertyMetaModels());
                 }
 
                 if (allPropertyMetaModels.isEmpty()) {
@@ -71,15 +71,15 @@ private static void generateHashcodeVisitor(JavaParser javaParser, SourceRoot so
 
                         final String getter = field.getGetterMethodName() + "()";
                         // Is this field another AST node? Visit it.
-                        if (javaParserMetaModel.getClassMetaModel(field.type).isPresent()) {
-                            if (field.isOptional) {
+                        if (field.isNode()) {
+                            if (field.isOptional()) {
                                 bodyBuilder += f("%s (n.%s.isPresent()? n.%s.get().accept(this, arg):0)", prefix, getter, getter);
                             } else {
                                 bodyBuilder += f("%s (n.%s.accept(this, arg))", prefix, getter);
                             }
-                        } else if (field.type.equals(boolean.class)) {
+                        } else if (field.getType().equals(boolean.class)) {
                             bodyBuilder += f("%s (n.%s?1:0)", prefix, getter);
-                        } else if (field.type.equals(int.class)) {
+                        } else if (field.getType().equals(int.class)) {
                             bodyBuilder += f("%s n.%s", prefix, getter);
                         } else {
                             bodyBuilder += f("%s (n.%s.hashCode())", prefix, getter);
@@ -99,10 +99,10 @@ private static void generateVoidVisitor(JavaParser javaParser, SourceRoot source
         ClassOrInterfaceDeclaration voidVisitor = voidVisitorCu.getInterfaceByName("VoidVisitor").get();
         voidVisitor.getMethods().forEach(m -> voidVisitor.getMembers().remove(m));
 
-        for (BaseNodeMetaModel node : javaParserMetaModel.nodeMetaModels) {
-            if (!node.isAbstract) {
+        for (BaseNodeMetaModel node : javaParserMetaModel.getNodeMetaModels()) {
+            if (!node.isAbstract()) {
                 voidVisitor.addMethod("visit")
-                        .addParameter(node.name, "n")
+                        .addParameter(node.getName(), "n")
                         .addParameter("A", "arg")
                         .setBody(null);
             }