Add replace method generator and its results

2 files changed, 89 insertions, 0 deletions

diff --git a/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/CoreGenerator.java b/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/CoreGenerator.java
index 3df8b9761..95360d314 100644
--- a/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/CoreGenerator.java
+++ b/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/CoreGenerator.java
@@ -40,6 +40,7 @@ public class CoreGenerator {
         new GetNodeListsGenerator(sourceRoot).generate();
         new PropertyGenerator(sourceRoot).generate();
         new RemoveMethodGenerator(sourceRoot).generate();
+        new ReplaceMethodGenerator(sourceRoot).generate();
         new CloneGenerator(sourceRoot).generate();
         new GetMetaModelGenerator(sourceRoot).generate();
         new MainConstructorGenerator(sourceRoot).generate();
diff --git a/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/node/ReplaceMethodGenerator.java b/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/node/ReplaceMethodGenerator.java
new file mode 100644
index 000000000..9ef9b1d26
--- /dev/null
+++ b/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/node/ReplaceMethodGenerator.java
@@ -0,0 +1,88 @@
+package com.github.javaparser.generator.core.node;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.stmt.BlockStmt;
+import com.github.javaparser.generator.NodeGenerator;
+import com.github.javaparser.metamodel.BaseNodeMetaModel;
+import com.github.javaparser.metamodel.PropertyMetaModel;
+import com.github.javaparser.utils.SourceRoot;
+
+import static com.github.javaparser.JavaParser.parseBodyDeclaration;
+import static com.github.javaparser.utils.CodeGenerationUtils.f;
+import static com.github.javaparser.utils.Utils.capitalize;
+
+public class ReplaceMethodGenerator extends NodeGenerator {
+    public ReplaceMethodGenerator(SourceRoot sourceRoot) {
+        super(sourceRoot);
+    }
+
+    @Override
+    protected void generateNode(BaseNodeMetaModel nodeMetaModel, CompilationUnit nodeCu, ClassOrInterfaceDeclaration nodeCoid) {
+        MethodDeclaration replaceNodeMethod = (MethodDeclaration) parseBodyDeclaration("public boolean replace(Node node, Node replacementNode) {}");
+        nodeCu.addImport(Node.class);
+        nodeMetaModel.getSuperNodeMetaModel().ifPresent(s -> annotateOverridden(replaceNodeMethod));
+
+        final BlockStmt body = replaceNodeMethod.getBody().get();
+
+        body.addStatement("if (node == null) return false;");
+
+        for (PropertyMetaModel property : nodeMetaModel.getDeclaredPropertyMetaModels()) {
+            if (!property.isNode()) {
+                continue;
+            }
+            String check;
+            if (property.isNodeList()) {
+                check = nodeListCheck(property);
+            } else {
+                if (property.isRequired()) {
+                    continue;
+                }
+                String replaceAttributeMethodName = generateReplaceMethodForAttribute(nodeCoid, nodeMetaModel, property);
+                check = attributeCheck(property, replaceAttributeMethodName);
+            }
+            if (property.isOptional()) {
+                check = f("if (%s != null) { %s }", property.getName(), check);
+            }
+            body.addStatement(check);
+        }
+        if (nodeMetaModel.getSuperNodeMetaModel().isPresent()) {
+            body.addStatement("return super.replace(node, replacementNode);");
+        } else {
+            body.addStatement("return false;");
+        }
+        
+        addOrReplaceWhenSameSignature(nodeCoid, replaceNodeMethod);
+        annotateGenerated(replaceNodeMethod);
+    }
+
+    private String attributeCheck(PropertyMetaModel property, String replaceAttributeMethodName) {
+        return f("if (node == %s) {" +
+                "    %s((%s) replacementNode);" +
+                "    return true;\n" +
+                "}", property.getName(), replaceAttributeMethodName, property.getTypeName());
+    }
+
+    private String nodeListCheck(PropertyMetaModel property) {
+        return f("for (int i = 0; i < %s.size(); i++) {" +
+                "  if (%s.get(i) == node) {" +
+                "    %s.set(i, (%s) replacementNode);" +
+                "    return true;" +
+                "  }" +
+                "}", property.getName(), property.getName(), property.getName(), property.getTypeName());
+    }
+
+    private String generateReplaceMethodForAttribute(ClassOrInterfaceDeclaration nodeCoid, BaseNodeMetaModel nodeMetaModel, PropertyMetaModel property) {
+        final String methodName = "replace" + capitalize(property.getName());
+        final MethodDeclaration replaceMethod = (MethodDeclaration) parseBodyDeclaration(f("public %s %s(%s replacement) {}", nodeMetaModel.getTypeName(), methodName, property.getTypeName()));
+
+        final BlockStmt block = replaceMethod.getBody().get();
+        block.addStatement(f("return %s((%s) replacement);", property.getSetterMethodName(), property.getTypeNameForSetter()));
+
+        addOrReplaceWhenSameSignature(nodeCoid, replaceMethod);
+        annotateGenerated(replaceMethod);
+        return methodName;
+    }
+}