diff options
Diffstat (limited to 'javaparser-core/src/main/java/com/github/javaparser/metamodel')
111 files changed, 2971 insertions, 0 deletions
diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationDeclarationMetaModel.java new file mode 100644 index 000000000..e4a7fdc9f --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationDeclarationMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class AnnotationDeclarationMetaModel extends TypeDeclarationMetaModel { + + AnnotationDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.AnnotationDeclaration.class, "AnnotationDeclaration", "com.github.javaparser.ast.body", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationExprMetaModel.java new file mode 100644 index 000000000..f4e892aca --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationExprMetaModel.java @@ -0,0 +1,17 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class AnnotationExprMetaModel extends ExpressionMetaModel { + + AnnotationExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.AnnotationExpr.class, "AnnotationExpr", "com.github.javaparser.ast.expr", true, false); + } + + protected AnnotationExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationMemberDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationMemberDeclarationMetaModel.java new file mode 100644 index 000000000..d15b967c1 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AnnotationMemberDeclarationMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class AnnotationMemberDeclarationMetaModel extends BodyDeclarationMetaModel { + + AnnotationMemberDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.AnnotationMemberDeclaration.class, "AnnotationMemberDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel defaultValuePropertyMetaModel; + + public PropertyMetaModel modifiersPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayAccessExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayAccessExprMetaModel.java new file mode 100644 index 000000000..b6dd15777 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayAccessExprMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ArrayAccessExprMetaModel extends ExpressionMetaModel { + + ArrayAccessExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.ArrayAccessExpr.class, "ArrayAccessExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel indexPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayCreationExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayCreationExprMetaModel.java new file mode 100644 index 000000000..a120f3428 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayCreationExprMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ArrayCreationExprMetaModel extends ExpressionMetaModel { + + ArrayCreationExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.ArrayCreationExpr.class, "ArrayCreationExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel elementTypePropertyMetaModel; + + public PropertyMetaModel initializerPropertyMetaModel; + + public PropertyMetaModel levelsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayCreationLevelMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayCreationLevelMetaModel.java new file mode 100644 index 000000000..b99f92ea5 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayCreationLevelMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ArrayCreationLevelMetaModel extends NodeMetaModel { + + ArrayCreationLevelMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.ArrayCreationLevel.class, "ArrayCreationLevel", "com.github.javaparser.ast", false, false); + } + + public PropertyMetaModel annotationsPropertyMetaModel; + + public PropertyMetaModel dimensionPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayInitializerExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayInitializerExprMetaModel.java new file mode 100644 index 000000000..685910f0c --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayInitializerExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ArrayInitializerExprMetaModel extends ExpressionMetaModel { + + ArrayInitializerExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.ArrayInitializerExpr.class, "ArrayInitializerExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel valuesPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayTypeMetaModel.java new file mode 100644 index 000000000..58f3f621a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ArrayTypeMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ArrayTypeMetaModel extends ReferenceTypeMetaModel { + + ArrayTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.ArrayType.class, "ArrayType", "com.github.javaparser.ast.type", false, false); + } + + public PropertyMetaModel componentTypePropertyMetaModel; + + public PropertyMetaModel originPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/AssertStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AssertStmtMetaModel.java new file mode 100644 index 000000000..c250832f0 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AssertStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class AssertStmtMetaModel extends StatementMetaModel { + + AssertStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.AssertStmt.class, "AssertStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel checkPropertyMetaModel; + + public PropertyMetaModel messagePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/AssignExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AssignExprMetaModel.java new file mode 100644 index 000000000..8a0de9a31 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/AssignExprMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class AssignExprMetaModel extends ExpressionMetaModel { + + AssignExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.AssignExpr.class, "AssignExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel operatorPropertyMetaModel; + + public PropertyMetaModel targetPropertyMetaModel; + + public PropertyMetaModel valuePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/BaseNodeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BaseNodeMetaModel.java new file mode 100644 index 000000000..86e53fdb9 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BaseNodeMetaModel.java @@ -0,0 +1,180 @@ +package com.github.javaparser.metamodel; + +import com.github.javaparser.ast.Node; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.decapitalize; + +/** + * Meta-data about all classes in the AST. These are all Nodes, except NodeList. + */ +public abstract class BaseNodeMetaModel { + private final Optional<BaseNodeMetaModel> superNodeMetaModel; + private final List<PropertyMetaModel> declaredPropertyMetaModels = new ArrayList<>(); + private final List<PropertyMetaModel> derivedPropertyMetaModels = new ArrayList<>(); + private final List<PropertyMetaModel> constructorParameters = new ArrayList<>(); + private final Class<? extends Node> type; + private final String name; + private final String packageName; + private final boolean isAbstract; + private final boolean hasWildcard; + + public BaseNodeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + this.superNodeMetaModel = superNodeMetaModel; + this.type = type; + this.name = name; + this.packageName = packageName; + this.isAbstract = isAbstract; + this.hasWildcard = hasWildcard; + } + + /** + * @return is this the meta model for this node class? + */ + public boolean is(Class<? extends Node> c) { + return type.equals(c); + } + + /** + * @return package name + class name + */ + public String getQualifiedClassName() { + return packageName + "." + name; + } + + /** + * @return the meta model for the node that this node extends. Note that this is to be used to find properties + * defined in superclasses of a Node. + */ + public Optional<BaseNodeMetaModel> getSuperNodeMetaModel() { + return superNodeMetaModel; + } + + /** + * @return a list of all properties declared directly in this node (not its parent nodes.) These are also available + * as fields. + */ + public List<PropertyMetaModel> getDeclaredPropertyMetaModels() { + return declaredPropertyMetaModels; + } + + public List<PropertyMetaModel> getDerivedPropertyMetaModels() { + return derivedPropertyMetaModels; + } + + /** + * @return a list of all properties that describe the parameters to the all-fields (but not "range" and "comment") + * constructor, in the order of appearance in the constructor parameter list. + */ + public List<PropertyMetaModel> getConstructorParameters() { + return constructorParameters; + } + + /** + * @return a list of all properties in this node and its parents. Note that a new list is created every time this + * method is called. + */ + public List<PropertyMetaModel> getAllPropertyMetaModels() { + List<PropertyMetaModel> allPropertyMetaModels = new ArrayList<>(getDeclaredPropertyMetaModels()); + BaseNodeMetaModel walkNode = this; + while (walkNode.getSuperNodeMetaModel().isPresent()) { + walkNode = walkNode.getSuperNodeMetaModel().get(); + allPropertyMetaModels.addAll(walkNode.getDeclaredPropertyMetaModels()); + } + return allPropertyMetaModels; + } + + public boolean isInstanceOfMetaModel(BaseNodeMetaModel baseMetaModel) { + if (this == baseMetaModel) { + return true; + } + if (isRootNode()) { + return false; + } + return getSuperNodeMetaModel().get().isInstanceOfMetaModel(baseMetaModel); + } + + /** + * @return the class for this AST node type. + */ + public Class<? extends Node> getType() { + return type; + } + + /** + * @return the package containing this AST node class. + */ + public String getPackageName() { + return packageName; + } + + /** + * @return whether this AST node is abstract. + */ + public boolean isAbstract() { + return isAbstract; + } + + /** + * @return whether this AST node has a <?> at the end of its type. + */ + public boolean hasWildcard() { + return hasWildcard; + } + + /** + * @return whether this AST node is the root node, meaning that it is the meta model for "Node": "NodeMetaModel". + */ + public boolean isRootNode() { + return !superNodeMetaModel.isPresent(); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + BaseNodeMetaModel classMetaModel = (BaseNodeMetaModel) o; + + if (!type.equals(classMetaModel.type)) return false; + + return true; + } + + @Override + public int hashCode() { + return type.hashCode(); + } + + @Override + public String toString() { + return name; + } + + /** + * @return the type name, with generics. + */ + public String getTypeNameGenerified() { + if (hasWildcard) { + return getTypeName() + "<?>"; + } + return getTypeName(); + } + + /** + * @return the raw type name, so nothing but the name. + */ + public String getTypeName() { + return type.getSimpleName(); + } + + /** + * The name of the field in JavaParserMetaModel for this node meta model. + */ + public String getMetaModelFieldName() { + return decapitalize(getClass().getSimpleName()); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/BinaryExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BinaryExprMetaModel.java new file mode 100644 index 000000000..f160ac867 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BinaryExprMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class BinaryExprMetaModel extends ExpressionMetaModel { + + BinaryExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.BinaryExpr.class, "BinaryExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel leftPropertyMetaModel; + + public PropertyMetaModel operatorPropertyMetaModel; + + public PropertyMetaModel rightPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/BlockCommentMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BlockCommentMetaModel.java new file mode 100644 index 000000000..166397da2 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BlockCommentMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class BlockCommentMetaModel extends CommentMetaModel { + + BlockCommentMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.comments.BlockComment.class, "BlockComment", "com.github.javaparser.ast.comments", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/BlockStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BlockStmtMetaModel.java new file mode 100644 index 000000000..847809d3d --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BlockStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class BlockStmtMetaModel extends StatementMetaModel { + + BlockStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.BlockStmt.class, "BlockStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel statementsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/BodyDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BodyDeclarationMetaModel.java new file mode 100644 index 000000000..c45d595ea --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BodyDeclarationMetaModel.java @@ -0,0 +1,17 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class BodyDeclarationMetaModel extends NodeMetaModel { + + BodyDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.BodyDeclaration.class, "BodyDeclaration", "com.github.javaparser.ast.body", true, true); + } + + protected BodyDeclarationMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel annotationsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/BooleanLiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BooleanLiteralExprMetaModel.java new file mode 100644 index 000000000..eff913d97 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BooleanLiteralExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class BooleanLiteralExprMetaModel extends LiteralExprMetaModel { + + BooleanLiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.BooleanLiteralExpr.class, "BooleanLiteralExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel valuePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/BreakStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BreakStmtMetaModel.java new file mode 100644 index 000000000..39f723259 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/BreakStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class BreakStmtMetaModel extends StatementMetaModel { + + BreakStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.BreakStmt.class, "BreakStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel labelPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/CallableDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CallableDeclarationMetaModel.java new file mode 100644 index 000000000..040762f0e --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CallableDeclarationMetaModel.java @@ -0,0 +1,27 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class CallableDeclarationMetaModel extends BodyDeclarationMetaModel { + + CallableDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.CallableDeclaration.class, "CallableDeclaration", "com.github.javaparser.ast.body", true, true); + } + + protected CallableDeclarationMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel modifiersPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel parametersPropertyMetaModel; + + public PropertyMetaModel receiverParameterPropertyMetaModel; + + public PropertyMetaModel thrownExceptionsPropertyMetaModel; + + public PropertyMetaModel typeParametersPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/CastExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CastExprMetaModel.java new file mode 100644 index 000000000..9671d9b95 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CastExprMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class CastExprMetaModel extends ExpressionMetaModel { + + CastExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.CastExpr.class, "CastExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel expressionPropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/CatchClauseMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CatchClauseMetaModel.java new file mode 100644 index 000000000..34cd102b0 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CatchClauseMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class CatchClauseMetaModel extends NodeMetaModel { + + CatchClauseMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.CatchClause.class, "CatchClause", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel parameterPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/CharLiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CharLiteralExprMetaModel.java new file mode 100644 index 000000000..d88595b6e --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CharLiteralExprMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class CharLiteralExprMetaModel extends LiteralStringValueExprMetaModel { + + CharLiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.CharLiteralExpr.class, "CharLiteralExpr", "com.github.javaparser.ast.expr", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassExprMetaModel.java new file mode 100644 index 000000000..fea3a125f --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ClassExprMetaModel extends ExpressionMetaModel { + + ClassExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.ClassExpr.class, "ClassExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassOrInterfaceDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassOrInterfaceDeclarationMetaModel.java new file mode 100644 index 000000000..7f0eff9bc --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassOrInterfaceDeclarationMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ClassOrInterfaceDeclarationMetaModel extends TypeDeclarationMetaModel { + + ClassOrInterfaceDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.ClassOrInterfaceDeclaration.class, "ClassOrInterfaceDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel extendedTypesPropertyMetaModel; + + public PropertyMetaModel implementedTypesPropertyMetaModel; + + public PropertyMetaModel isInterfacePropertyMetaModel; + + public PropertyMetaModel typeParametersPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassOrInterfaceTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassOrInterfaceTypeMetaModel.java new file mode 100644 index 000000000..b2747ed64 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ClassOrInterfaceTypeMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ClassOrInterfaceTypeMetaModel extends ReferenceTypeMetaModel { + + ClassOrInterfaceTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.ClassOrInterfaceType.class, "ClassOrInterfaceType", "com.github.javaparser.ast.type", false, false); + } + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel scopePropertyMetaModel; + + public PropertyMetaModel typeArgumentsPropertyMetaModel; + + public PropertyMetaModel usingDiamondOperatorPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/CommentMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CommentMetaModel.java new file mode 100644 index 000000000..8cdd7a9ef --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CommentMetaModel.java @@ -0,0 +1,17 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class CommentMetaModel extends NodeMetaModel { + + CommentMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.comments.Comment.class, "Comment", "com.github.javaparser.ast.comments", true, false); + } + + protected CommentMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel contentPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/CompilationUnitMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CompilationUnitMetaModel.java new file mode 100644 index 000000000..34eacb70a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/CompilationUnitMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class CompilationUnitMetaModel extends NodeMetaModel { + + CompilationUnitMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.CompilationUnit.class, "CompilationUnit", "com.github.javaparser.ast", false, false); + } + + public PropertyMetaModel importsPropertyMetaModel; + + public PropertyMetaModel modulePropertyMetaModel; + + public PropertyMetaModel packageDeclarationPropertyMetaModel; + + public PropertyMetaModel typesPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ConditionalExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ConditionalExprMetaModel.java new file mode 100644 index 000000000..dbc91191b --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ConditionalExprMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ConditionalExprMetaModel extends ExpressionMetaModel { + + ConditionalExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.ConditionalExpr.class, "ConditionalExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel conditionPropertyMetaModel; + + public PropertyMetaModel elseExprPropertyMetaModel; + + public PropertyMetaModel thenExprPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ConstructorDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ConstructorDeclarationMetaModel.java new file mode 100644 index 000000000..4d0b9f32d --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ConstructorDeclarationMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ConstructorDeclarationMetaModel extends CallableDeclarationMetaModel { + + ConstructorDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.ConstructorDeclaration.class, "ConstructorDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ContinueStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ContinueStmtMetaModel.java new file mode 100644 index 000000000..d07db7049 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ContinueStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ContinueStmtMetaModel extends StatementMetaModel { + + ContinueStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.ContinueStmt.class, "ContinueStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel labelPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/DerivedProperty.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/DerivedProperty.java new file mode 100644 index 000000000..3a29d7870 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/DerivedProperty.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +/** + * Indicate a derived property of a Node, + * meaning it does supply useful information, + * but it does so by taking information from other properties. + * (Used during generation of the meta model.) + */ +@Retention(RUNTIME) +@Target(METHOD) +public @interface DerivedProperty { +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/DoStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/DoStmtMetaModel.java new file mode 100644 index 000000000..45451c715 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/DoStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class DoStmtMetaModel extends StatementMetaModel { + + DoStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.DoStmt.class, "DoStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel conditionPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/DoubleLiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/DoubleLiteralExprMetaModel.java new file mode 100644 index 000000000..2b772731f --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/DoubleLiteralExprMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class DoubleLiteralExprMetaModel extends LiteralStringValueExprMetaModel { + + DoubleLiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.DoubleLiteralExpr.class, "DoubleLiteralExpr", "com.github.javaparser.ast.expr", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/EmptyStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EmptyStmtMetaModel.java new file mode 100644 index 000000000..0943326ca --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EmptyStmtMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class EmptyStmtMetaModel extends StatementMetaModel { + + EmptyStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.EmptyStmt.class, "EmptyStmt", "com.github.javaparser.ast.stmt", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnclosedExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnclosedExprMetaModel.java new file mode 100644 index 000000000..4dd99b83b --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnclosedExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class EnclosedExprMetaModel extends ExpressionMetaModel { + + EnclosedExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.EnclosedExpr.class, "EnclosedExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel innerPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnumConstantDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnumConstantDeclarationMetaModel.java new file mode 100644 index 000000000..2067e6d58 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnumConstantDeclarationMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class EnumConstantDeclarationMetaModel extends BodyDeclarationMetaModel { + + EnumConstantDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.EnumConstantDeclaration.class, "EnumConstantDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel argumentsPropertyMetaModel; + + public PropertyMetaModel classBodyPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnumDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnumDeclarationMetaModel.java new file mode 100644 index 000000000..d4ed81397 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/EnumDeclarationMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class EnumDeclarationMetaModel extends TypeDeclarationMetaModel { + + EnumDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.EnumDeclaration.class, "EnumDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel entriesPropertyMetaModel; + + public PropertyMetaModel implementedTypesPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExplicitConstructorInvocationStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExplicitConstructorInvocationStmtMetaModel.java new file mode 100644 index 000000000..9d47b430c --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExplicitConstructorInvocationStmtMetaModel.java @@ -0,0 +1,20 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ExplicitConstructorInvocationStmtMetaModel extends StatementMetaModel { + + ExplicitConstructorInvocationStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt.class, "ExplicitConstructorInvocationStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel argumentsPropertyMetaModel; + + public PropertyMetaModel expressionPropertyMetaModel; + + public PropertyMetaModel isThisPropertyMetaModel; + + public PropertyMetaModel typeArgumentsPropertyMetaModel; + + public PropertyMetaModel usingDiamondOperatorPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExpressionMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExpressionMetaModel.java new file mode 100644 index 000000000..dc773684e --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExpressionMetaModel.java @@ -0,0 +1,15 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class ExpressionMetaModel extends NodeMetaModel { + + ExpressionMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.Expression.class, "Expression", "com.github.javaparser.ast.expr", true, false); + } + + protected ExpressionMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExpressionStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExpressionStmtMetaModel.java new file mode 100644 index 000000000..69d7a59ce --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ExpressionStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ExpressionStmtMetaModel extends StatementMetaModel { + + ExpressionStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.ExpressionStmt.class, "ExpressionStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel expressionPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/FieldAccessExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/FieldAccessExprMetaModel.java new file mode 100644 index 000000000..b9e820e74 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/FieldAccessExprMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class FieldAccessExprMetaModel extends ExpressionMetaModel { + + FieldAccessExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.FieldAccessExpr.class, "FieldAccessExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel scopePropertyMetaModel; + + public PropertyMetaModel typeArgumentsPropertyMetaModel; + + public PropertyMetaModel usingDiamondOperatorPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/FieldDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/FieldDeclarationMetaModel.java new file mode 100644 index 000000000..9f12fae84 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/FieldDeclarationMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class FieldDeclarationMetaModel extends BodyDeclarationMetaModel { + + FieldDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.FieldDeclaration.class, "FieldDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel modifiersPropertyMetaModel; + + public PropertyMetaModel variablesPropertyMetaModel; + + public PropertyMetaModel maximumCommonTypePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ForStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ForStmtMetaModel.java new file mode 100644 index 000000000..c63039ebc --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ForStmtMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ForStmtMetaModel extends StatementMetaModel { + + ForStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.ForStmt.class, "ForStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel comparePropertyMetaModel; + + public PropertyMetaModel initializationPropertyMetaModel; + + public PropertyMetaModel updatePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ForeachStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ForeachStmtMetaModel.java new file mode 100644 index 000000000..8a8dc4e71 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ForeachStmtMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ForeachStmtMetaModel extends StatementMetaModel { + + ForeachStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.ForeachStmt.class, "ForeachStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel iterablePropertyMetaModel; + + public PropertyMetaModel variablePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/IfStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/IfStmtMetaModel.java new file mode 100644 index 000000000..91f4027ed --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/IfStmtMetaModel.java @@ -0,0 +1,24 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class IfStmtMetaModel extends StatementMetaModel { + + IfStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.IfStmt.class, "IfStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel conditionPropertyMetaModel; + + public PropertyMetaModel elseStmtPropertyMetaModel; + + public PropertyMetaModel thenStmtPropertyMetaModel; + + public PropertyMetaModel cascadingIfStmtPropertyMetaModel; + + public PropertyMetaModel elseBlockPropertyMetaModel; + + public PropertyMetaModel elseBranchPropertyMetaModel; + + public PropertyMetaModel thenBlockPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ImportDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ImportDeclarationMetaModel.java new file mode 100644 index 000000000..3c1e4f825 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ImportDeclarationMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ImportDeclarationMetaModel extends NodeMetaModel { + + ImportDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.ImportDeclaration.class, "ImportDeclaration", "com.github.javaparser.ast", false, false); + } + + public PropertyMetaModel isAsteriskPropertyMetaModel; + + public PropertyMetaModel isStaticPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/InitializerDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/InitializerDeclarationMetaModel.java new file mode 100644 index 000000000..035038c37 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/InitializerDeclarationMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class InitializerDeclarationMetaModel extends BodyDeclarationMetaModel { + + InitializerDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.InitializerDeclaration.class, "InitializerDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel isStaticPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/InstanceOfExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/InstanceOfExprMetaModel.java new file mode 100644 index 000000000..9b4534c91 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/InstanceOfExprMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class InstanceOfExprMetaModel extends ExpressionMetaModel { + + InstanceOfExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.InstanceOfExpr.class, "InstanceOfExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel expressionPropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/IntegerLiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/IntegerLiteralExprMetaModel.java new file mode 100644 index 000000000..b7932170b --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/IntegerLiteralExprMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class IntegerLiteralExprMetaModel extends LiteralStringValueExprMetaModel { + + IntegerLiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.IntegerLiteralExpr.class, "IntegerLiteralExpr", "com.github.javaparser.ast.expr", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/InternalProperty.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/InternalProperty.java new file mode 100644 index 000000000..83c5970b2 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/InternalProperty.java @@ -0,0 +1,17 @@ +package com.github.javaparser.metamodel; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +/** + * Indicate an internal property of a Node, + * meaning it is not part of the meta model. + * (Used during generation of the meta model.) + */ +@Retention(RUNTIME) +@Target(FIELD) +public @interface InternalProperty { +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/IntersectionTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/IntersectionTypeMetaModel.java new file mode 100644 index 000000000..73ad36f71 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/IntersectionTypeMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class IntersectionTypeMetaModel extends TypeMetaModel { + + IntersectionTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.IntersectionType.class, "IntersectionType", "com.github.javaparser.ast.type", false, false); + } + + public PropertyMetaModel elementsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/JavaParserMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/JavaParserMetaModel.java new file mode 100644 index 000000000..bffbd3711 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/JavaParserMetaModel.java @@ -0,0 +1,977 @@ +package com.github.javaparser.metamodel; + +import com.github.javaparser.ast.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +/** + * The model contains meta-data about all nodes in the AST. + */ +public final class JavaParserMetaModel { + + private JavaParserMetaModel() { + } + + private static final List<BaseNodeMetaModel> nodeMetaModels = new ArrayList<>(); + + private static void initializeConstructorParameters() { + bodyDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + callableDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.modifiersPropertyMetaModel); + callableDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + callableDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.typeParametersPropertyMetaModel); + callableDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.namePropertyMetaModel); + callableDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.parametersPropertyMetaModel); + callableDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.thrownExceptionsPropertyMetaModel); + callableDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.receiverParameterPropertyMetaModel); + typeMetaModel.getConstructorParameters().add(typeMetaModel.annotationsPropertyMetaModel); + annotationExprMetaModel.getConstructorParameters().add(annotationExprMetaModel.namePropertyMetaModel); + typeDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.modifiersPropertyMetaModel); + typeDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + typeDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.namePropertyMetaModel); + typeDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.membersPropertyMetaModel); + referenceTypeMetaModel.getConstructorParameters().add(typeMetaModel.annotationsPropertyMetaModel); + literalStringValueExprMetaModel.getConstructorParameters().add(literalStringValueExprMetaModel.valuePropertyMetaModel); + stringLiteralExprMetaModel.getConstructorParameters().add(literalStringValueExprMetaModel.valuePropertyMetaModel); + moduleDeclarationMetaModel.getConstructorParameters().add(moduleDeclarationMetaModel.annotationsPropertyMetaModel); + moduleDeclarationMetaModel.getConstructorParameters().add(moduleDeclarationMetaModel.namePropertyMetaModel); + moduleDeclarationMetaModel.getConstructorParameters().add(moduleDeclarationMetaModel.isOpenPropertyMetaModel); + moduleDeclarationMetaModel.getConstructorParameters().add(moduleDeclarationMetaModel.moduleStmtsPropertyMetaModel); + arrayCreationLevelMetaModel.getConstructorParameters().add(arrayCreationLevelMetaModel.dimensionPropertyMetaModel); + arrayCreationLevelMetaModel.getConstructorParameters().add(arrayCreationLevelMetaModel.annotationsPropertyMetaModel); + compilationUnitMetaModel.getConstructorParameters().add(compilationUnitMetaModel.packageDeclarationPropertyMetaModel); + compilationUnitMetaModel.getConstructorParameters().add(compilationUnitMetaModel.importsPropertyMetaModel); + compilationUnitMetaModel.getConstructorParameters().add(compilationUnitMetaModel.typesPropertyMetaModel); + compilationUnitMetaModel.getConstructorParameters().add(compilationUnitMetaModel.modulePropertyMetaModel); + packageDeclarationMetaModel.getConstructorParameters().add(packageDeclarationMetaModel.annotationsPropertyMetaModel); + packageDeclarationMetaModel.getConstructorParameters().add(packageDeclarationMetaModel.namePropertyMetaModel); + annotationDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.modifiersPropertyMetaModel); + annotationDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + annotationDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.namePropertyMetaModel); + annotationDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.membersPropertyMetaModel); + annotationMemberDeclarationMetaModel.getConstructorParameters().add(annotationMemberDeclarationMetaModel.modifiersPropertyMetaModel); + annotationMemberDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + annotationMemberDeclarationMetaModel.getConstructorParameters().add(annotationMemberDeclarationMetaModel.typePropertyMetaModel); + annotationMemberDeclarationMetaModel.getConstructorParameters().add(annotationMemberDeclarationMetaModel.namePropertyMetaModel); + annotationMemberDeclarationMetaModel.getConstructorParameters().add(annotationMemberDeclarationMetaModel.defaultValuePropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.modifiersPropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(classOrInterfaceDeclarationMetaModel.isInterfacePropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.namePropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(classOrInterfaceDeclarationMetaModel.typeParametersPropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(classOrInterfaceDeclarationMetaModel.extendedTypesPropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(classOrInterfaceDeclarationMetaModel.implementedTypesPropertyMetaModel); + classOrInterfaceDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.membersPropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.modifiersPropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.typeParametersPropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.namePropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.parametersPropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.thrownExceptionsPropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(constructorDeclarationMetaModel.bodyPropertyMetaModel); + constructorDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.receiverParameterPropertyMetaModel); + enumConstantDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + enumConstantDeclarationMetaModel.getConstructorParameters().add(enumConstantDeclarationMetaModel.namePropertyMetaModel); + enumConstantDeclarationMetaModel.getConstructorParameters().add(enumConstantDeclarationMetaModel.argumentsPropertyMetaModel); + enumConstantDeclarationMetaModel.getConstructorParameters().add(enumConstantDeclarationMetaModel.classBodyPropertyMetaModel); + enumDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.modifiersPropertyMetaModel); + enumDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + enumDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.namePropertyMetaModel); + enumDeclarationMetaModel.getConstructorParameters().add(enumDeclarationMetaModel.implementedTypesPropertyMetaModel); + enumDeclarationMetaModel.getConstructorParameters().add(enumDeclarationMetaModel.entriesPropertyMetaModel); + enumDeclarationMetaModel.getConstructorParameters().add(typeDeclarationMetaModel.membersPropertyMetaModel); + fieldDeclarationMetaModel.getConstructorParameters().add(fieldDeclarationMetaModel.modifiersPropertyMetaModel); + fieldDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + fieldDeclarationMetaModel.getConstructorParameters().add(fieldDeclarationMetaModel.variablesPropertyMetaModel); + initializerDeclarationMetaModel.getConstructorParameters().add(initializerDeclarationMetaModel.isStaticPropertyMetaModel); + initializerDeclarationMetaModel.getConstructorParameters().add(initializerDeclarationMetaModel.bodyPropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.modifiersPropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.typeParametersPropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(methodDeclarationMetaModel.typePropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.namePropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.parametersPropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.thrownExceptionsPropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(methodDeclarationMetaModel.bodyPropertyMetaModel); + methodDeclarationMetaModel.getConstructorParameters().add(callableDeclarationMetaModel.receiverParameterPropertyMetaModel); + parameterMetaModel.getConstructorParameters().add(parameterMetaModel.modifiersPropertyMetaModel); + parameterMetaModel.getConstructorParameters().add(parameterMetaModel.annotationsPropertyMetaModel); + parameterMetaModel.getConstructorParameters().add(parameterMetaModel.typePropertyMetaModel); + parameterMetaModel.getConstructorParameters().add(parameterMetaModel.isVarArgsPropertyMetaModel); + parameterMetaModel.getConstructorParameters().add(parameterMetaModel.varArgsAnnotationsPropertyMetaModel); + parameterMetaModel.getConstructorParameters().add(parameterMetaModel.namePropertyMetaModel); + receiverParameterMetaModel.getConstructorParameters().add(receiverParameterMetaModel.annotationsPropertyMetaModel); + receiverParameterMetaModel.getConstructorParameters().add(receiverParameterMetaModel.typePropertyMetaModel); + receiverParameterMetaModel.getConstructorParameters().add(receiverParameterMetaModel.namePropertyMetaModel); + variableDeclaratorMetaModel.getConstructorParameters().add(variableDeclaratorMetaModel.typePropertyMetaModel); + variableDeclaratorMetaModel.getConstructorParameters().add(variableDeclaratorMetaModel.namePropertyMetaModel); + variableDeclaratorMetaModel.getConstructorParameters().add(variableDeclaratorMetaModel.initializerPropertyMetaModel); + commentMetaModel.getConstructorParameters().add(commentMetaModel.contentPropertyMetaModel); + blockCommentMetaModel.getConstructorParameters().add(commentMetaModel.contentPropertyMetaModel); + javadocCommentMetaModel.getConstructorParameters().add(commentMetaModel.contentPropertyMetaModel); + lineCommentMetaModel.getConstructorParameters().add(commentMetaModel.contentPropertyMetaModel); + arrayAccessExprMetaModel.getConstructorParameters().add(arrayAccessExprMetaModel.namePropertyMetaModel); + arrayAccessExprMetaModel.getConstructorParameters().add(arrayAccessExprMetaModel.indexPropertyMetaModel); + arrayCreationExprMetaModel.getConstructorParameters().add(arrayCreationExprMetaModel.elementTypePropertyMetaModel); + arrayCreationExprMetaModel.getConstructorParameters().add(arrayCreationExprMetaModel.levelsPropertyMetaModel); + arrayCreationExprMetaModel.getConstructorParameters().add(arrayCreationExprMetaModel.initializerPropertyMetaModel); + arrayInitializerExprMetaModel.getConstructorParameters().add(arrayInitializerExprMetaModel.valuesPropertyMetaModel); + assignExprMetaModel.getConstructorParameters().add(assignExprMetaModel.targetPropertyMetaModel); + assignExprMetaModel.getConstructorParameters().add(assignExprMetaModel.valuePropertyMetaModel); + assignExprMetaModel.getConstructorParameters().add(assignExprMetaModel.operatorPropertyMetaModel); + binaryExprMetaModel.getConstructorParameters().add(binaryExprMetaModel.leftPropertyMetaModel); + binaryExprMetaModel.getConstructorParameters().add(binaryExprMetaModel.rightPropertyMetaModel); + binaryExprMetaModel.getConstructorParameters().add(binaryExprMetaModel.operatorPropertyMetaModel); + booleanLiteralExprMetaModel.getConstructorParameters().add(booleanLiteralExprMetaModel.valuePropertyMetaModel); + castExprMetaModel.getConstructorParameters().add(castExprMetaModel.typePropertyMetaModel); + castExprMetaModel.getConstructorParameters().add(castExprMetaModel.expressionPropertyMetaModel); + charLiteralExprMetaModel.getConstructorParameters().add(literalStringValueExprMetaModel.valuePropertyMetaModel); + classExprMetaModel.getConstructorParameters().add(classExprMetaModel.typePropertyMetaModel); + conditionalExprMetaModel.getConstructorParameters().add(conditionalExprMetaModel.conditionPropertyMetaModel); + conditionalExprMetaModel.getConstructorParameters().add(conditionalExprMetaModel.thenExprPropertyMetaModel); + conditionalExprMetaModel.getConstructorParameters().add(conditionalExprMetaModel.elseExprPropertyMetaModel); + doubleLiteralExprMetaModel.getConstructorParameters().add(literalStringValueExprMetaModel.valuePropertyMetaModel); + enclosedExprMetaModel.getConstructorParameters().add(enclosedExprMetaModel.innerPropertyMetaModel); + fieldAccessExprMetaModel.getConstructorParameters().add(fieldAccessExprMetaModel.scopePropertyMetaModel); + fieldAccessExprMetaModel.getConstructorParameters().add(fieldAccessExprMetaModel.typeArgumentsPropertyMetaModel); + fieldAccessExprMetaModel.getConstructorParameters().add(fieldAccessExprMetaModel.namePropertyMetaModel); + instanceOfExprMetaModel.getConstructorParameters().add(instanceOfExprMetaModel.expressionPropertyMetaModel); + instanceOfExprMetaModel.getConstructorParameters().add(instanceOfExprMetaModel.typePropertyMetaModel); + integerLiteralExprMetaModel.getConstructorParameters().add(literalStringValueExprMetaModel.valuePropertyMetaModel); + lambdaExprMetaModel.getConstructorParameters().add(lambdaExprMetaModel.parametersPropertyMetaModel); + lambdaExprMetaModel.getConstructorParameters().add(lambdaExprMetaModel.bodyPropertyMetaModel); + lambdaExprMetaModel.getConstructorParameters().add(lambdaExprMetaModel.isEnclosingParametersPropertyMetaModel); + longLiteralExprMetaModel.getConstructorParameters().add(literalStringValueExprMetaModel.valuePropertyMetaModel); + markerAnnotationExprMetaModel.getConstructorParameters().add(annotationExprMetaModel.namePropertyMetaModel); + memberValuePairMetaModel.getConstructorParameters().add(memberValuePairMetaModel.namePropertyMetaModel); + memberValuePairMetaModel.getConstructorParameters().add(memberValuePairMetaModel.valuePropertyMetaModel); + methodCallExprMetaModel.getConstructorParameters().add(methodCallExprMetaModel.scopePropertyMetaModel); + methodCallExprMetaModel.getConstructorParameters().add(methodCallExprMetaModel.typeArgumentsPropertyMetaModel); + methodCallExprMetaModel.getConstructorParameters().add(methodCallExprMetaModel.namePropertyMetaModel); + methodCallExprMetaModel.getConstructorParameters().add(methodCallExprMetaModel.argumentsPropertyMetaModel); + methodReferenceExprMetaModel.getConstructorParameters().add(methodReferenceExprMetaModel.scopePropertyMetaModel); + methodReferenceExprMetaModel.getConstructorParameters().add(methodReferenceExprMetaModel.typeArgumentsPropertyMetaModel); + methodReferenceExprMetaModel.getConstructorParameters().add(methodReferenceExprMetaModel.identifierPropertyMetaModel); + nameExprMetaModel.getConstructorParameters().add(nameExprMetaModel.namePropertyMetaModel); + nameMetaModel.getConstructorParameters().add(nameMetaModel.qualifierPropertyMetaModel); + nameMetaModel.getConstructorParameters().add(nameMetaModel.identifierPropertyMetaModel); + nameMetaModel.getConstructorParameters().add(nameMetaModel.annotationsPropertyMetaModel); + normalAnnotationExprMetaModel.getConstructorParameters().add(annotationExprMetaModel.namePropertyMetaModel); + normalAnnotationExprMetaModel.getConstructorParameters().add(normalAnnotationExprMetaModel.pairsPropertyMetaModel); + objectCreationExprMetaModel.getConstructorParameters().add(objectCreationExprMetaModel.scopePropertyMetaModel); + objectCreationExprMetaModel.getConstructorParameters().add(objectCreationExprMetaModel.typePropertyMetaModel); + objectCreationExprMetaModel.getConstructorParameters().add(objectCreationExprMetaModel.typeArgumentsPropertyMetaModel); + objectCreationExprMetaModel.getConstructorParameters().add(objectCreationExprMetaModel.argumentsPropertyMetaModel); + objectCreationExprMetaModel.getConstructorParameters().add(objectCreationExprMetaModel.anonymousClassBodyPropertyMetaModel); + simpleNameMetaModel.getConstructorParameters().add(simpleNameMetaModel.identifierPropertyMetaModel); + singleMemberAnnotationExprMetaModel.getConstructorParameters().add(annotationExprMetaModel.namePropertyMetaModel); + singleMemberAnnotationExprMetaModel.getConstructorParameters().add(singleMemberAnnotationExprMetaModel.memberValuePropertyMetaModel); + superExprMetaModel.getConstructorParameters().add(superExprMetaModel.classExprPropertyMetaModel); + thisExprMetaModel.getConstructorParameters().add(thisExprMetaModel.classExprPropertyMetaModel); + typeExprMetaModel.getConstructorParameters().add(typeExprMetaModel.typePropertyMetaModel); + unaryExprMetaModel.getConstructorParameters().add(unaryExprMetaModel.expressionPropertyMetaModel); + unaryExprMetaModel.getConstructorParameters().add(unaryExprMetaModel.operatorPropertyMetaModel); + variableDeclarationExprMetaModel.getConstructorParameters().add(variableDeclarationExprMetaModel.modifiersPropertyMetaModel); + variableDeclarationExprMetaModel.getConstructorParameters().add(variableDeclarationExprMetaModel.annotationsPropertyMetaModel); + variableDeclarationExprMetaModel.getConstructorParameters().add(variableDeclarationExprMetaModel.variablesPropertyMetaModel); + importDeclarationMetaModel.getConstructorParameters().add(importDeclarationMetaModel.namePropertyMetaModel); + importDeclarationMetaModel.getConstructorParameters().add(importDeclarationMetaModel.isStaticPropertyMetaModel); + importDeclarationMetaModel.getConstructorParameters().add(importDeclarationMetaModel.isAsteriskPropertyMetaModel); + assertStmtMetaModel.getConstructorParameters().add(assertStmtMetaModel.checkPropertyMetaModel); + assertStmtMetaModel.getConstructorParameters().add(assertStmtMetaModel.messagePropertyMetaModel); + blockStmtMetaModel.getConstructorParameters().add(blockStmtMetaModel.statementsPropertyMetaModel); + breakStmtMetaModel.getConstructorParameters().add(breakStmtMetaModel.labelPropertyMetaModel); + catchClauseMetaModel.getConstructorParameters().add(catchClauseMetaModel.parameterPropertyMetaModel); + catchClauseMetaModel.getConstructorParameters().add(catchClauseMetaModel.bodyPropertyMetaModel); + continueStmtMetaModel.getConstructorParameters().add(continueStmtMetaModel.labelPropertyMetaModel); + doStmtMetaModel.getConstructorParameters().add(doStmtMetaModel.bodyPropertyMetaModel); + doStmtMetaModel.getConstructorParameters().add(doStmtMetaModel.conditionPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.getConstructorParameters().add(explicitConstructorInvocationStmtMetaModel.typeArgumentsPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.getConstructorParameters().add(explicitConstructorInvocationStmtMetaModel.isThisPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.getConstructorParameters().add(explicitConstructorInvocationStmtMetaModel.expressionPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.getConstructorParameters().add(explicitConstructorInvocationStmtMetaModel.argumentsPropertyMetaModel); + expressionStmtMetaModel.getConstructorParameters().add(expressionStmtMetaModel.expressionPropertyMetaModel); + foreachStmtMetaModel.getConstructorParameters().add(foreachStmtMetaModel.variablePropertyMetaModel); + foreachStmtMetaModel.getConstructorParameters().add(foreachStmtMetaModel.iterablePropertyMetaModel); + foreachStmtMetaModel.getConstructorParameters().add(foreachStmtMetaModel.bodyPropertyMetaModel); + forStmtMetaModel.getConstructorParameters().add(forStmtMetaModel.initializationPropertyMetaModel); + forStmtMetaModel.getConstructorParameters().add(forStmtMetaModel.comparePropertyMetaModel); + forStmtMetaModel.getConstructorParameters().add(forStmtMetaModel.updatePropertyMetaModel); + forStmtMetaModel.getConstructorParameters().add(forStmtMetaModel.bodyPropertyMetaModel); + ifStmtMetaModel.getConstructorParameters().add(ifStmtMetaModel.conditionPropertyMetaModel); + ifStmtMetaModel.getConstructorParameters().add(ifStmtMetaModel.thenStmtPropertyMetaModel); + ifStmtMetaModel.getConstructorParameters().add(ifStmtMetaModel.elseStmtPropertyMetaModel); + labeledStmtMetaModel.getConstructorParameters().add(labeledStmtMetaModel.labelPropertyMetaModel); + labeledStmtMetaModel.getConstructorParameters().add(labeledStmtMetaModel.statementPropertyMetaModel); + returnStmtMetaModel.getConstructorParameters().add(returnStmtMetaModel.expressionPropertyMetaModel); + switchEntryStmtMetaModel.getConstructorParameters().add(switchEntryStmtMetaModel.labelPropertyMetaModel); + switchEntryStmtMetaModel.getConstructorParameters().add(switchEntryStmtMetaModel.statementsPropertyMetaModel); + switchStmtMetaModel.getConstructorParameters().add(switchStmtMetaModel.selectorPropertyMetaModel); + switchStmtMetaModel.getConstructorParameters().add(switchStmtMetaModel.entriesPropertyMetaModel); + synchronizedStmtMetaModel.getConstructorParameters().add(synchronizedStmtMetaModel.expressionPropertyMetaModel); + synchronizedStmtMetaModel.getConstructorParameters().add(synchronizedStmtMetaModel.bodyPropertyMetaModel); + throwStmtMetaModel.getConstructorParameters().add(throwStmtMetaModel.expressionPropertyMetaModel); + tryStmtMetaModel.getConstructorParameters().add(tryStmtMetaModel.resourcesPropertyMetaModel); + tryStmtMetaModel.getConstructorParameters().add(tryStmtMetaModel.tryBlockPropertyMetaModel); + tryStmtMetaModel.getConstructorParameters().add(tryStmtMetaModel.catchClausesPropertyMetaModel); + tryStmtMetaModel.getConstructorParameters().add(tryStmtMetaModel.finallyBlockPropertyMetaModel); + localClassDeclarationStmtMetaModel.getConstructorParameters().add(localClassDeclarationStmtMetaModel.classDeclarationPropertyMetaModel); + whileStmtMetaModel.getConstructorParameters().add(whileStmtMetaModel.conditionPropertyMetaModel); + whileStmtMetaModel.getConstructorParameters().add(whileStmtMetaModel.bodyPropertyMetaModel); + arrayTypeMetaModel.getConstructorParameters().add(arrayTypeMetaModel.componentTypePropertyMetaModel); + arrayTypeMetaModel.getConstructorParameters().add(arrayTypeMetaModel.originPropertyMetaModel); + arrayTypeMetaModel.getConstructorParameters().add(typeMetaModel.annotationsPropertyMetaModel); + classOrInterfaceTypeMetaModel.getConstructorParameters().add(classOrInterfaceTypeMetaModel.scopePropertyMetaModel); + classOrInterfaceTypeMetaModel.getConstructorParameters().add(classOrInterfaceTypeMetaModel.namePropertyMetaModel); + classOrInterfaceTypeMetaModel.getConstructorParameters().add(classOrInterfaceTypeMetaModel.typeArgumentsPropertyMetaModel); + classOrInterfaceTypeMetaModel.getConstructorParameters().add(typeMetaModel.annotationsPropertyMetaModel); + intersectionTypeMetaModel.getConstructorParameters().add(intersectionTypeMetaModel.elementsPropertyMetaModel); + primitiveTypeMetaModel.getConstructorParameters().add(primitiveTypeMetaModel.typePropertyMetaModel); + primitiveTypeMetaModel.getConstructorParameters().add(typeMetaModel.annotationsPropertyMetaModel); + typeParameterMetaModel.getConstructorParameters().add(typeParameterMetaModel.namePropertyMetaModel); + typeParameterMetaModel.getConstructorParameters().add(typeParameterMetaModel.typeBoundPropertyMetaModel); + typeParameterMetaModel.getConstructorParameters().add(typeMetaModel.annotationsPropertyMetaModel); + unionTypeMetaModel.getConstructorParameters().add(unionTypeMetaModel.elementsPropertyMetaModel); + wildcardTypeMetaModel.getConstructorParameters().add(wildcardTypeMetaModel.extendedTypePropertyMetaModel); + wildcardTypeMetaModel.getConstructorParameters().add(wildcardTypeMetaModel.superTypePropertyMetaModel); + wildcardTypeMetaModel.getConstructorParameters().add(typeMetaModel.annotationsPropertyMetaModel); + moduleRequiresStmtMetaModel.getConstructorParameters().add(moduleRequiresStmtMetaModel.modifiersPropertyMetaModel); + moduleRequiresStmtMetaModel.getConstructorParameters().add(moduleRequiresStmtMetaModel.namePropertyMetaModel); + moduleExportsStmtMetaModel.getConstructorParameters().add(moduleExportsStmtMetaModel.namePropertyMetaModel); + moduleExportsStmtMetaModel.getConstructorParameters().add(moduleExportsStmtMetaModel.moduleNamesPropertyMetaModel); + moduleProvidesStmtMetaModel.getConstructorParameters().add(moduleProvidesStmtMetaModel.typePropertyMetaModel); + moduleProvidesStmtMetaModel.getConstructorParameters().add(moduleProvidesStmtMetaModel.withTypesPropertyMetaModel); + moduleUsesStmtMetaModel.getConstructorParameters().add(moduleUsesStmtMetaModel.typePropertyMetaModel); + moduleOpensStmtMetaModel.getConstructorParameters().add(moduleOpensStmtMetaModel.namePropertyMetaModel); + moduleOpensStmtMetaModel.getConstructorParameters().add(moduleOpensStmtMetaModel.moduleNamesPropertyMetaModel); + } + + public static List<BaseNodeMetaModel> getNodeMetaModels() { + return nodeMetaModels; + } + + private static void initializeNodeMetaModels() { + nodeMetaModels.add(annotationDeclarationMetaModel); + nodeMetaModels.add(annotationExprMetaModel); + nodeMetaModels.add(annotationMemberDeclarationMetaModel); + nodeMetaModels.add(arrayAccessExprMetaModel); + nodeMetaModels.add(arrayCreationExprMetaModel); + nodeMetaModels.add(arrayCreationLevelMetaModel); + nodeMetaModels.add(arrayInitializerExprMetaModel); + nodeMetaModels.add(arrayTypeMetaModel); + nodeMetaModels.add(assertStmtMetaModel); + nodeMetaModels.add(assignExprMetaModel); + nodeMetaModels.add(binaryExprMetaModel); + nodeMetaModels.add(blockCommentMetaModel); + nodeMetaModels.add(blockStmtMetaModel); + nodeMetaModels.add(bodyDeclarationMetaModel); + nodeMetaModels.add(booleanLiteralExprMetaModel); + nodeMetaModels.add(breakStmtMetaModel); + nodeMetaModels.add(callableDeclarationMetaModel); + nodeMetaModels.add(castExprMetaModel); + nodeMetaModels.add(catchClauseMetaModel); + nodeMetaModels.add(charLiteralExprMetaModel); + nodeMetaModels.add(classExprMetaModel); + nodeMetaModels.add(classOrInterfaceDeclarationMetaModel); + nodeMetaModels.add(classOrInterfaceTypeMetaModel); + nodeMetaModels.add(commentMetaModel); + nodeMetaModels.add(compilationUnitMetaModel); + nodeMetaModels.add(conditionalExprMetaModel); + nodeMetaModels.add(constructorDeclarationMetaModel); + nodeMetaModels.add(continueStmtMetaModel); + nodeMetaModels.add(doStmtMetaModel); + nodeMetaModels.add(doubleLiteralExprMetaModel); + nodeMetaModels.add(emptyStmtMetaModel); + nodeMetaModels.add(enclosedExprMetaModel); + nodeMetaModels.add(enumConstantDeclarationMetaModel); + nodeMetaModels.add(enumDeclarationMetaModel); + nodeMetaModels.add(explicitConstructorInvocationStmtMetaModel); + nodeMetaModels.add(expressionMetaModel); + nodeMetaModels.add(expressionStmtMetaModel); + nodeMetaModels.add(fieldAccessExprMetaModel); + nodeMetaModels.add(fieldDeclarationMetaModel); + nodeMetaModels.add(forStmtMetaModel); + nodeMetaModels.add(foreachStmtMetaModel); + nodeMetaModels.add(ifStmtMetaModel); + nodeMetaModels.add(importDeclarationMetaModel); + nodeMetaModels.add(initializerDeclarationMetaModel); + nodeMetaModels.add(instanceOfExprMetaModel); + nodeMetaModels.add(integerLiteralExprMetaModel); + nodeMetaModels.add(intersectionTypeMetaModel); + nodeMetaModels.add(javadocCommentMetaModel); + nodeMetaModels.add(labeledStmtMetaModel); + nodeMetaModels.add(lambdaExprMetaModel); + nodeMetaModels.add(lineCommentMetaModel); + nodeMetaModels.add(literalExprMetaModel); + nodeMetaModels.add(literalStringValueExprMetaModel); + nodeMetaModels.add(localClassDeclarationStmtMetaModel); + nodeMetaModels.add(longLiteralExprMetaModel); + nodeMetaModels.add(markerAnnotationExprMetaModel); + nodeMetaModels.add(memberValuePairMetaModel); + nodeMetaModels.add(methodCallExprMetaModel); + nodeMetaModels.add(methodDeclarationMetaModel); + nodeMetaModels.add(methodReferenceExprMetaModel); + nodeMetaModels.add(moduleDeclarationMetaModel); + nodeMetaModels.add(moduleExportsStmtMetaModel); + nodeMetaModels.add(moduleOpensStmtMetaModel); + nodeMetaModels.add(moduleProvidesStmtMetaModel); + nodeMetaModels.add(moduleRequiresStmtMetaModel); + nodeMetaModels.add(moduleStmtMetaModel); + nodeMetaModels.add(moduleUsesStmtMetaModel); + nodeMetaModels.add(nameExprMetaModel); + nodeMetaModels.add(nameMetaModel); + nodeMetaModels.add(nodeMetaModel); + nodeMetaModels.add(normalAnnotationExprMetaModel); + nodeMetaModels.add(nullLiteralExprMetaModel); + nodeMetaModels.add(objectCreationExprMetaModel); + nodeMetaModels.add(packageDeclarationMetaModel); + nodeMetaModels.add(parameterMetaModel); + nodeMetaModels.add(primitiveTypeMetaModel); + nodeMetaModels.add(receiverParameterMetaModel); + nodeMetaModels.add(referenceTypeMetaModel); + nodeMetaModels.add(returnStmtMetaModel); + nodeMetaModels.add(simpleNameMetaModel); + nodeMetaModels.add(singleMemberAnnotationExprMetaModel); + nodeMetaModels.add(statementMetaModel); + nodeMetaModels.add(stringLiteralExprMetaModel); + nodeMetaModels.add(superExprMetaModel); + nodeMetaModels.add(switchEntryStmtMetaModel); + nodeMetaModels.add(switchStmtMetaModel); + nodeMetaModels.add(synchronizedStmtMetaModel); + nodeMetaModels.add(thisExprMetaModel); + nodeMetaModels.add(throwStmtMetaModel); + nodeMetaModels.add(tryStmtMetaModel); + nodeMetaModels.add(typeDeclarationMetaModel); + nodeMetaModels.add(typeExprMetaModel); + nodeMetaModels.add(typeMetaModel); + nodeMetaModels.add(typeParameterMetaModel); + nodeMetaModels.add(unaryExprMetaModel); + nodeMetaModels.add(unionTypeMetaModel); + nodeMetaModels.add(unknownTypeMetaModel); + nodeMetaModels.add(unparsableStmtMetaModel); + nodeMetaModels.add(varTypeMetaModel); + nodeMetaModels.add(variableDeclarationExprMetaModel); + nodeMetaModels.add(variableDeclaratorMetaModel); + nodeMetaModels.add(voidTypeMetaModel); + nodeMetaModels.add(whileStmtMetaModel); + nodeMetaModels.add(wildcardTypeMetaModel); + } + + private static void initializePropertyMetaModels() { + nodeMetaModel.commentPropertyMetaModel = new PropertyMetaModel(nodeMetaModel, "comment", com.github.javaparser.ast.comments.Comment.class, Optional.of(commentMetaModel), true, false, false, false, false); + nodeMetaModel.getDeclaredPropertyMetaModels().add(nodeMetaModel.commentPropertyMetaModel); + bodyDeclarationMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(bodyDeclarationMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + bodyDeclarationMetaModel.getDeclaredPropertyMetaModels().add(bodyDeclarationMetaModel.annotationsPropertyMetaModel); + callableDeclarationMetaModel.modifiersPropertyMetaModel = new PropertyMetaModel(callableDeclarationMetaModel, "modifiers", com.github.javaparser.ast.Modifier.class, Optional.empty(), false, false, false, true, false); + callableDeclarationMetaModel.getDeclaredPropertyMetaModels().add(callableDeclarationMetaModel.modifiersPropertyMetaModel); + callableDeclarationMetaModel.namePropertyMetaModel = new PropertyMetaModel(callableDeclarationMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + callableDeclarationMetaModel.getDeclaredPropertyMetaModels().add(callableDeclarationMetaModel.namePropertyMetaModel); + callableDeclarationMetaModel.parametersPropertyMetaModel = new PropertyMetaModel(callableDeclarationMetaModel, "parameters", com.github.javaparser.ast.body.Parameter.class, Optional.of(parameterMetaModel), false, false, true, false, false); + callableDeclarationMetaModel.getDeclaredPropertyMetaModels().add(callableDeclarationMetaModel.parametersPropertyMetaModel); + callableDeclarationMetaModel.receiverParameterPropertyMetaModel = new PropertyMetaModel(callableDeclarationMetaModel, "receiverParameter", com.github.javaparser.ast.body.ReceiverParameter.class, Optional.of(receiverParameterMetaModel), true, false, false, false, false); + callableDeclarationMetaModel.getDeclaredPropertyMetaModels().add(callableDeclarationMetaModel.receiverParameterPropertyMetaModel); + callableDeclarationMetaModel.thrownExceptionsPropertyMetaModel = new PropertyMetaModel(callableDeclarationMetaModel, "thrownExceptions", com.github.javaparser.ast.type.ReferenceType.class, Optional.of(referenceTypeMetaModel), false, false, true, false, false); + callableDeclarationMetaModel.getDeclaredPropertyMetaModels().add(callableDeclarationMetaModel.thrownExceptionsPropertyMetaModel); + callableDeclarationMetaModel.typeParametersPropertyMetaModel = new PropertyMetaModel(callableDeclarationMetaModel, "typeParameters", com.github.javaparser.ast.type.TypeParameter.class, Optional.of(typeParameterMetaModel), false, false, true, false, false); + callableDeclarationMetaModel.getDeclaredPropertyMetaModels().add(callableDeclarationMetaModel.typeParametersPropertyMetaModel); + typeMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(typeMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + typeMetaModel.getDeclaredPropertyMetaModels().add(typeMetaModel.annotationsPropertyMetaModel); + annotationExprMetaModel.namePropertyMetaModel = new PropertyMetaModel(annotationExprMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + annotationExprMetaModel.getDeclaredPropertyMetaModels().add(annotationExprMetaModel.namePropertyMetaModel); + typeDeclarationMetaModel.membersPropertyMetaModel = new PropertyMetaModel(typeDeclarationMetaModel, "members", com.github.javaparser.ast.body.BodyDeclaration.class, Optional.of(bodyDeclarationMetaModel), false, false, true, false, true); + typeDeclarationMetaModel.getDeclaredPropertyMetaModels().add(typeDeclarationMetaModel.membersPropertyMetaModel); + typeDeclarationMetaModel.modifiersPropertyMetaModel = new PropertyMetaModel(typeDeclarationMetaModel, "modifiers", com.github.javaparser.ast.Modifier.class, Optional.empty(), false, false, false, true, false); + typeDeclarationMetaModel.getDeclaredPropertyMetaModels().add(typeDeclarationMetaModel.modifiersPropertyMetaModel); + typeDeclarationMetaModel.namePropertyMetaModel = new PropertyMetaModel(typeDeclarationMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + typeDeclarationMetaModel.getDeclaredPropertyMetaModels().add(typeDeclarationMetaModel.namePropertyMetaModel); + literalStringValueExprMetaModel.valuePropertyMetaModel = new PropertyMetaModel(literalStringValueExprMetaModel, "value", java.lang.String.class, Optional.empty(), false, false, false, false, false); + literalStringValueExprMetaModel.getDeclaredPropertyMetaModels().add(literalStringValueExprMetaModel.valuePropertyMetaModel); + moduleDeclarationMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(moduleDeclarationMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + moduleDeclarationMetaModel.getDeclaredPropertyMetaModels().add(moduleDeclarationMetaModel.annotationsPropertyMetaModel); + moduleDeclarationMetaModel.isOpenPropertyMetaModel = new PropertyMetaModel(moduleDeclarationMetaModel, "isOpen", boolean.class, Optional.empty(), false, false, false, false, false); + moduleDeclarationMetaModel.getDeclaredPropertyMetaModels().add(moduleDeclarationMetaModel.isOpenPropertyMetaModel); + moduleDeclarationMetaModel.moduleStmtsPropertyMetaModel = new PropertyMetaModel(moduleDeclarationMetaModel, "moduleStmts", com.github.javaparser.ast.modules.ModuleStmt.class, Optional.of(moduleStmtMetaModel), false, false, true, false, false); + moduleDeclarationMetaModel.getDeclaredPropertyMetaModels().add(moduleDeclarationMetaModel.moduleStmtsPropertyMetaModel); + moduleDeclarationMetaModel.namePropertyMetaModel = new PropertyMetaModel(moduleDeclarationMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + moduleDeclarationMetaModel.getDeclaredPropertyMetaModels().add(moduleDeclarationMetaModel.namePropertyMetaModel); + arrayCreationLevelMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(arrayCreationLevelMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + arrayCreationLevelMetaModel.getDeclaredPropertyMetaModels().add(arrayCreationLevelMetaModel.annotationsPropertyMetaModel); + arrayCreationLevelMetaModel.dimensionPropertyMetaModel = new PropertyMetaModel(arrayCreationLevelMetaModel, "dimension", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + arrayCreationLevelMetaModel.getDeclaredPropertyMetaModels().add(arrayCreationLevelMetaModel.dimensionPropertyMetaModel); + compilationUnitMetaModel.importsPropertyMetaModel = new PropertyMetaModel(compilationUnitMetaModel, "imports", com.github.javaparser.ast.ImportDeclaration.class, Optional.of(importDeclarationMetaModel), false, false, true, false, false); + compilationUnitMetaModel.getDeclaredPropertyMetaModels().add(compilationUnitMetaModel.importsPropertyMetaModel); + compilationUnitMetaModel.modulePropertyMetaModel = new PropertyMetaModel(compilationUnitMetaModel, "module", com.github.javaparser.ast.modules.ModuleDeclaration.class, Optional.of(moduleDeclarationMetaModel), true, false, false, false, false); + compilationUnitMetaModel.getDeclaredPropertyMetaModels().add(compilationUnitMetaModel.modulePropertyMetaModel); + compilationUnitMetaModel.packageDeclarationPropertyMetaModel = new PropertyMetaModel(compilationUnitMetaModel, "packageDeclaration", com.github.javaparser.ast.PackageDeclaration.class, Optional.of(packageDeclarationMetaModel), true, false, false, false, false); + compilationUnitMetaModel.getDeclaredPropertyMetaModels().add(compilationUnitMetaModel.packageDeclarationPropertyMetaModel); + compilationUnitMetaModel.typesPropertyMetaModel = new PropertyMetaModel(compilationUnitMetaModel, "types", com.github.javaparser.ast.body.TypeDeclaration.class, Optional.of(typeDeclarationMetaModel), false, false, true, false, true); + compilationUnitMetaModel.getDeclaredPropertyMetaModels().add(compilationUnitMetaModel.typesPropertyMetaModel); + packageDeclarationMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(packageDeclarationMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + packageDeclarationMetaModel.getDeclaredPropertyMetaModels().add(packageDeclarationMetaModel.annotationsPropertyMetaModel); + packageDeclarationMetaModel.namePropertyMetaModel = new PropertyMetaModel(packageDeclarationMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + packageDeclarationMetaModel.getDeclaredPropertyMetaModels().add(packageDeclarationMetaModel.namePropertyMetaModel); + annotationMemberDeclarationMetaModel.defaultValuePropertyMetaModel = new PropertyMetaModel(annotationMemberDeclarationMetaModel, "defaultValue", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + annotationMemberDeclarationMetaModel.getDeclaredPropertyMetaModels().add(annotationMemberDeclarationMetaModel.defaultValuePropertyMetaModel); + annotationMemberDeclarationMetaModel.modifiersPropertyMetaModel = new PropertyMetaModel(annotationMemberDeclarationMetaModel, "modifiers", com.github.javaparser.ast.Modifier.class, Optional.empty(), false, false, false, true, false); + annotationMemberDeclarationMetaModel.getDeclaredPropertyMetaModels().add(annotationMemberDeclarationMetaModel.modifiersPropertyMetaModel); + annotationMemberDeclarationMetaModel.namePropertyMetaModel = new PropertyMetaModel(annotationMemberDeclarationMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + annotationMemberDeclarationMetaModel.getDeclaredPropertyMetaModels().add(annotationMemberDeclarationMetaModel.namePropertyMetaModel); + annotationMemberDeclarationMetaModel.typePropertyMetaModel = new PropertyMetaModel(annotationMemberDeclarationMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + annotationMemberDeclarationMetaModel.getDeclaredPropertyMetaModels().add(annotationMemberDeclarationMetaModel.typePropertyMetaModel); + classOrInterfaceDeclarationMetaModel.extendedTypesPropertyMetaModel = new PropertyMetaModel(classOrInterfaceDeclarationMetaModel, "extendedTypes", com.github.javaparser.ast.type.ClassOrInterfaceType.class, Optional.of(classOrInterfaceTypeMetaModel), false, false, true, false, false); + classOrInterfaceDeclarationMetaModel.getDeclaredPropertyMetaModels().add(classOrInterfaceDeclarationMetaModel.extendedTypesPropertyMetaModel); + classOrInterfaceDeclarationMetaModel.implementedTypesPropertyMetaModel = new PropertyMetaModel(classOrInterfaceDeclarationMetaModel, "implementedTypes", com.github.javaparser.ast.type.ClassOrInterfaceType.class, Optional.of(classOrInterfaceTypeMetaModel), false, false, true, false, false); + classOrInterfaceDeclarationMetaModel.getDeclaredPropertyMetaModels().add(classOrInterfaceDeclarationMetaModel.implementedTypesPropertyMetaModel); + classOrInterfaceDeclarationMetaModel.isInterfacePropertyMetaModel = new PropertyMetaModel(classOrInterfaceDeclarationMetaModel, "isInterface", boolean.class, Optional.empty(), false, false, false, false, false); + classOrInterfaceDeclarationMetaModel.getDeclaredPropertyMetaModels().add(classOrInterfaceDeclarationMetaModel.isInterfacePropertyMetaModel); + classOrInterfaceDeclarationMetaModel.typeParametersPropertyMetaModel = new PropertyMetaModel(classOrInterfaceDeclarationMetaModel, "typeParameters", com.github.javaparser.ast.type.TypeParameter.class, Optional.of(typeParameterMetaModel), false, false, true, false, false); + classOrInterfaceDeclarationMetaModel.getDeclaredPropertyMetaModels().add(classOrInterfaceDeclarationMetaModel.typeParametersPropertyMetaModel); + constructorDeclarationMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(constructorDeclarationMetaModel, "body", com.github.javaparser.ast.stmt.BlockStmt.class, Optional.of(blockStmtMetaModel), false, false, false, false, false); + constructorDeclarationMetaModel.getDeclaredPropertyMetaModels().add(constructorDeclarationMetaModel.bodyPropertyMetaModel); + enumConstantDeclarationMetaModel.argumentsPropertyMetaModel = new PropertyMetaModel(enumConstantDeclarationMetaModel, "arguments", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + enumConstantDeclarationMetaModel.getDeclaredPropertyMetaModels().add(enumConstantDeclarationMetaModel.argumentsPropertyMetaModel); + enumConstantDeclarationMetaModel.classBodyPropertyMetaModel = new PropertyMetaModel(enumConstantDeclarationMetaModel, "classBody", com.github.javaparser.ast.body.BodyDeclaration.class, Optional.of(bodyDeclarationMetaModel), false, false, true, false, true); + enumConstantDeclarationMetaModel.getDeclaredPropertyMetaModels().add(enumConstantDeclarationMetaModel.classBodyPropertyMetaModel); + enumConstantDeclarationMetaModel.namePropertyMetaModel = new PropertyMetaModel(enumConstantDeclarationMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + enumConstantDeclarationMetaModel.getDeclaredPropertyMetaModels().add(enumConstantDeclarationMetaModel.namePropertyMetaModel); + enumDeclarationMetaModel.entriesPropertyMetaModel = new PropertyMetaModel(enumDeclarationMetaModel, "entries", com.github.javaparser.ast.body.EnumConstantDeclaration.class, Optional.of(enumConstantDeclarationMetaModel), false, false, true, false, false); + enumDeclarationMetaModel.getDeclaredPropertyMetaModels().add(enumDeclarationMetaModel.entriesPropertyMetaModel); + enumDeclarationMetaModel.implementedTypesPropertyMetaModel = new PropertyMetaModel(enumDeclarationMetaModel, "implementedTypes", com.github.javaparser.ast.type.ClassOrInterfaceType.class, Optional.of(classOrInterfaceTypeMetaModel), false, false, true, false, false); + enumDeclarationMetaModel.getDeclaredPropertyMetaModels().add(enumDeclarationMetaModel.implementedTypesPropertyMetaModel); + fieldDeclarationMetaModel.modifiersPropertyMetaModel = new PropertyMetaModel(fieldDeclarationMetaModel, "modifiers", com.github.javaparser.ast.Modifier.class, Optional.empty(), false, false, false, true, false); + fieldDeclarationMetaModel.getDeclaredPropertyMetaModels().add(fieldDeclarationMetaModel.modifiersPropertyMetaModel); + fieldDeclarationMetaModel.variablesPropertyMetaModel = new PropertyMetaModel(fieldDeclarationMetaModel, "variables", com.github.javaparser.ast.body.VariableDeclarator.class, Optional.of(variableDeclaratorMetaModel), false, true, true, false, false); + fieldDeclarationMetaModel.getDeclaredPropertyMetaModels().add(fieldDeclarationMetaModel.variablesPropertyMetaModel); + fieldDeclarationMetaModel.maximumCommonTypePropertyMetaModel = new PropertyMetaModel(fieldDeclarationMetaModel, "maximumCommonType", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, false, false, false); + fieldDeclarationMetaModel.getDerivedPropertyMetaModels().add(fieldDeclarationMetaModel.maximumCommonTypePropertyMetaModel); + initializerDeclarationMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(initializerDeclarationMetaModel, "body", com.github.javaparser.ast.stmt.BlockStmt.class, Optional.of(blockStmtMetaModel), false, false, false, false, false); + initializerDeclarationMetaModel.getDeclaredPropertyMetaModels().add(initializerDeclarationMetaModel.bodyPropertyMetaModel); + initializerDeclarationMetaModel.isStaticPropertyMetaModel = new PropertyMetaModel(initializerDeclarationMetaModel, "isStatic", boolean.class, Optional.empty(), false, false, false, false, false); + initializerDeclarationMetaModel.getDeclaredPropertyMetaModels().add(initializerDeclarationMetaModel.isStaticPropertyMetaModel); + methodDeclarationMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(methodDeclarationMetaModel, "body", com.github.javaparser.ast.stmt.BlockStmt.class, Optional.of(blockStmtMetaModel), true, false, false, false, false); + methodDeclarationMetaModel.getDeclaredPropertyMetaModels().add(methodDeclarationMetaModel.bodyPropertyMetaModel); + methodDeclarationMetaModel.typePropertyMetaModel = new PropertyMetaModel(methodDeclarationMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + methodDeclarationMetaModel.getDeclaredPropertyMetaModels().add(methodDeclarationMetaModel.typePropertyMetaModel); + parameterMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(parameterMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + parameterMetaModel.getDeclaredPropertyMetaModels().add(parameterMetaModel.annotationsPropertyMetaModel); + parameterMetaModel.isVarArgsPropertyMetaModel = new PropertyMetaModel(parameterMetaModel, "isVarArgs", boolean.class, Optional.empty(), false, false, false, false, false); + parameterMetaModel.getDeclaredPropertyMetaModels().add(parameterMetaModel.isVarArgsPropertyMetaModel); + parameterMetaModel.modifiersPropertyMetaModel = new PropertyMetaModel(parameterMetaModel, "modifiers", com.github.javaparser.ast.Modifier.class, Optional.empty(), false, false, false, true, false); + parameterMetaModel.getDeclaredPropertyMetaModels().add(parameterMetaModel.modifiersPropertyMetaModel); + parameterMetaModel.namePropertyMetaModel = new PropertyMetaModel(parameterMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + parameterMetaModel.getDeclaredPropertyMetaModels().add(parameterMetaModel.namePropertyMetaModel); + parameterMetaModel.typePropertyMetaModel = new PropertyMetaModel(parameterMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + parameterMetaModel.getDeclaredPropertyMetaModels().add(parameterMetaModel.typePropertyMetaModel); + parameterMetaModel.varArgsAnnotationsPropertyMetaModel = new PropertyMetaModel(parameterMetaModel, "varArgsAnnotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + parameterMetaModel.getDeclaredPropertyMetaModels().add(parameterMetaModel.varArgsAnnotationsPropertyMetaModel); + receiverParameterMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(receiverParameterMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + receiverParameterMetaModel.getDeclaredPropertyMetaModels().add(receiverParameterMetaModel.annotationsPropertyMetaModel); + receiverParameterMetaModel.namePropertyMetaModel = new PropertyMetaModel(receiverParameterMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + receiverParameterMetaModel.getDeclaredPropertyMetaModels().add(receiverParameterMetaModel.namePropertyMetaModel); + receiverParameterMetaModel.typePropertyMetaModel = new PropertyMetaModel(receiverParameterMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + receiverParameterMetaModel.getDeclaredPropertyMetaModels().add(receiverParameterMetaModel.typePropertyMetaModel); + variableDeclaratorMetaModel.initializerPropertyMetaModel = new PropertyMetaModel(variableDeclaratorMetaModel, "initializer", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, true, false, false, false); + variableDeclaratorMetaModel.getDeclaredPropertyMetaModels().add(variableDeclaratorMetaModel.initializerPropertyMetaModel); + variableDeclaratorMetaModel.namePropertyMetaModel = new PropertyMetaModel(variableDeclaratorMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + variableDeclaratorMetaModel.getDeclaredPropertyMetaModels().add(variableDeclaratorMetaModel.namePropertyMetaModel); + variableDeclaratorMetaModel.typePropertyMetaModel = new PropertyMetaModel(variableDeclaratorMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + variableDeclaratorMetaModel.getDeclaredPropertyMetaModels().add(variableDeclaratorMetaModel.typePropertyMetaModel); + commentMetaModel.contentPropertyMetaModel = new PropertyMetaModel(commentMetaModel, "content", java.lang.String.class, Optional.empty(), false, false, false, false, false); + commentMetaModel.getDeclaredPropertyMetaModels().add(commentMetaModel.contentPropertyMetaModel); + arrayAccessExprMetaModel.indexPropertyMetaModel = new PropertyMetaModel(arrayAccessExprMetaModel, "index", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + arrayAccessExprMetaModel.getDeclaredPropertyMetaModels().add(arrayAccessExprMetaModel.indexPropertyMetaModel); + arrayAccessExprMetaModel.namePropertyMetaModel = new PropertyMetaModel(arrayAccessExprMetaModel, "name", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + arrayAccessExprMetaModel.getDeclaredPropertyMetaModels().add(arrayAccessExprMetaModel.namePropertyMetaModel); + arrayCreationExprMetaModel.elementTypePropertyMetaModel = new PropertyMetaModel(arrayCreationExprMetaModel, "elementType", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + arrayCreationExprMetaModel.getDeclaredPropertyMetaModels().add(arrayCreationExprMetaModel.elementTypePropertyMetaModel); + arrayCreationExprMetaModel.initializerPropertyMetaModel = new PropertyMetaModel(arrayCreationExprMetaModel, "initializer", com.github.javaparser.ast.expr.ArrayInitializerExpr.class, Optional.of(arrayInitializerExprMetaModel), true, false, false, false, false); + arrayCreationExprMetaModel.getDeclaredPropertyMetaModels().add(arrayCreationExprMetaModel.initializerPropertyMetaModel); + arrayCreationExprMetaModel.levelsPropertyMetaModel = new PropertyMetaModel(arrayCreationExprMetaModel, "levels", com.github.javaparser.ast.ArrayCreationLevel.class, Optional.of(arrayCreationLevelMetaModel), false, true, true, false, false); + arrayCreationExprMetaModel.getDeclaredPropertyMetaModels().add(arrayCreationExprMetaModel.levelsPropertyMetaModel); + arrayInitializerExprMetaModel.valuesPropertyMetaModel = new PropertyMetaModel(arrayInitializerExprMetaModel, "values", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + arrayInitializerExprMetaModel.getDeclaredPropertyMetaModels().add(arrayInitializerExprMetaModel.valuesPropertyMetaModel); + assignExprMetaModel.operatorPropertyMetaModel = new PropertyMetaModel(assignExprMetaModel, "operator", com.github.javaparser.ast.expr.AssignExpr.Operator.class, Optional.empty(), false, false, false, false, false); + assignExprMetaModel.getDeclaredPropertyMetaModels().add(assignExprMetaModel.operatorPropertyMetaModel); + assignExprMetaModel.targetPropertyMetaModel = new PropertyMetaModel(assignExprMetaModel, "target", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + assignExprMetaModel.getDeclaredPropertyMetaModels().add(assignExprMetaModel.targetPropertyMetaModel); + assignExprMetaModel.valuePropertyMetaModel = new PropertyMetaModel(assignExprMetaModel, "value", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + assignExprMetaModel.getDeclaredPropertyMetaModels().add(assignExprMetaModel.valuePropertyMetaModel); + binaryExprMetaModel.leftPropertyMetaModel = new PropertyMetaModel(binaryExprMetaModel, "left", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + binaryExprMetaModel.getDeclaredPropertyMetaModels().add(binaryExprMetaModel.leftPropertyMetaModel); + binaryExprMetaModel.operatorPropertyMetaModel = new PropertyMetaModel(binaryExprMetaModel, "operator", com.github.javaparser.ast.expr.BinaryExpr.Operator.class, Optional.empty(), false, false, false, false, false); + binaryExprMetaModel.getDeclaredPropertyMetaModels().add(binaryExprMetaModel.operatorPropertyMetaModel); + binaryExprMetaModel.rightPropertyMetaModel = new PropertyMetaModel(binaryExprMetaModel, "right", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + binaryExprMetaModel.getDeclaredPropertyMetaModels().add(binaryExprMetaModel.rightPropertyMetaModel); + booleanLiteralExprMetaModel.valuePropertyMetaModel = new PropertyMetaModel(booleanLiteralExprMetaModel, "value", boolean.class, Optional.empty(), false, false, false, false, false); + booleanLiteralExprMetaModel.getDeclaredPropertyMetaModels().add(booleanLiteralExprMetaModel.valuePropertyMetaModel); + castExprMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(castExprMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + castExprMetaModel.getDeclaredPropertyMetaModels().add(castExprMetaModel.expressionPropertyMetaModel); + castExprMetaModel.typePropertyMetaModel = new PropertyMetaModel(castExprMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + castExprMetaModel.getDeclaredPropertyMetaModels().add(castExprMetaModel.typePropertyMetaModel); + classExprMetaModel.typePropertyMetaModel = new PropertyMetaModel(classExprMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + classExprMetaModel.getDeclaredPropertyMetaModels().add(classExprMetaModel.typePropertyMetaModel); + conditionalExprMetaModel.conditionPropertyMetaModel = new PropertyMetaModel(conditionalExprMetaModel, "condition", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + conditionalExprMetaModel.getDeclaredPropertyMetaModels().add(conditionalExprMetaModel.conditionPropertyMetaModel); + conditionalExprMetaModel.elseExprPropertyMetaModel = new PropertyMetaModel(conditionalExprMetaModel, "elseExpr", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + conditionalExprMetaModel.getDeclaredPropertyMetaModels().add(conditionalExprMetaModel.elseExprPropertyMetaModel); + conditionalExprMetaModel.thenExprPropertyMetaModel = new PropertyMetaModel(conditionalExprMetaModel, "thenExpr", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + conditionalExprMetaModel.getDeclaredPropertyMetaModels().add(conditionalExprMetaModel.thenExprPropertyMetaModel); + enclosedExprMetaModel.innerPropertyMetaModel = new PropertyMetaModel(enclosedExprMetaModel, "inner", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + enclosedExprMetaModel.getDeclaredPropertyMetaModels().add(enclosedExprMetaModel.innerPropertyMetaModel); + fieldAccessExprMetaModel.namePropertyMetaModel = new PropertyMetaModel(fieldAccessExprMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + fieldAccessExprMetaModel.getDeclaredPropertyMetaModels().add(fieldAccessExprMetaModel.namePropertyMetaModel); + fieldAccessExprMetaModel.scopePropertyMetaModel = new PropertyMetaModel(fieldAccessExprMetaModel, "scope", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + fieldAccessExprMetaModel.getDeclaredPropertyMetaModels().add(fieldAccessExprMetaModel.scopePropertyMetaModel); + fieldAccessExprMetaModel.typeArgumentsPropertyMetaModel = new PropertyMetaModel(fieldAccessExprMetaModel, "typeArguments", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, true, false, false); + fieldAccessExprMetaModel.getDeclaredPropertyMetaModels().add(fieldAccessExprMetaModel.typeArgumentsPropertyMetaModel); + fieldAccessExprMetaModel.usingDiamondOperatorPropertyMetaModel = new PropertyMetaModel(fieldAccessExprMetaModel, "usingDiamondOperator", boolean.class, Optional.empty(), false, false, false, false, false); + fieldAccessExprMetaModel.getDerivedPropertyMetaModels().add(fieldAccessExprMetaModel.usingDiamondOperatorPropertyMetaModel); + instanceOfExprMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(instanceOfExprMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + instanceOfExprMetaModel.getDeclaredPropertyMetaModels().add(instanceOfExprMetaModel.expressionPropertyMetaModel); + instanceOfExprMetaModel.typePropertyMetaModel = new PropertyMetaModel(instanceOfExprMetaModel, "type", com.github.javaparser.ast.type.ReferenceType.class, Optional.of(referenceTypeMetaModel), false, false, false, false, false); + instanceOfExprMetaModel.getDeclaredPropertyMetaModels().add(instanceOfExprMetaModel.typePropertyMetaModel); + lambdaExprMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(lambdaExprMetaModel, "body", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, false, false, false); + lambdaExprMetaModel.getDeclaredPropertyMetaModels().add(lambdaExprMetaModel.bodyPropertyMetaModel); + lambdaExprMetaModel.isEnclosingParametersPropertyMetaModel = new PropertyMetaModel(lambdaExprMetaModel, "isEnclosingParameters", boolean.class, Optional.empty(), false, false, false, false, false); + lambdaExprMetaModel.getDeclaredPropertyMetaModels().add(lambdaExprMetaModel.isEnclosingParametersPropertyMetaModel); + lambdaExprMetaModel.parametersPropertyMetaModel = new PropertyMetaModel(lambdaExprMetaModel, "parameters", com.github.javaparser.ast.body.Parameter.class, Optional.of(parameterMetaModel), false, false, true, false, false); + lambdaExprMetaModel.getDeclaredPropertyMetaModels().add(lambdaExprMetaModel.parametersPropertyMetaModel); + lambdaExprMetaModel.expressionBodyPropertyMetaModel = new PropertyMetaModel(lambdaExprMetaModel, "expressionBody", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + lambdaExprMetaModel.getDerivedPropertyMetaModels().add(lambdaExprMetaModel.expressionBodyPropertyMetaModel); + memberValuePairMetaModel.namePropertyMetaModel = new PropertyMetaModel(memberValuePairMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + memberValuePairMetaModel.getDeclaredPropertyMetaModels().add(memberValuePairMetaModel.namePropertyMetaModel); + memberValuePairMetaModel.valuePropertyMetaModel = new PropertyMetaModel(memberValuePairMetaModel, "value", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + memberValuePairMetaModel.getDeclaredPropertyMetaModels().add(memberValuePairMetaModel.valuePropertyMetaModel); + methodCallExprMetaModel.argumentsPropertyMetaModel = new PropertyMetaModel(methodCallExprMetaModel, "arguments", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + methodCallExprMetaModel.getDeclaredPropertyMetaModels().add(methodCallExprMetaModel.argumentsPropertyMetaModel); + methodCallExprMetaModel.namePropertyMetaModel = new PropertyMetaModel(methodCallExprMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + methodCallExprMetaModel.getDeclaredPropertyMetaModels().add(methodCallExprMetaModel.namePropertyMetaModel); + methodCallExprMetaModel.scopePropertyMetaModel = new PropertyMetaModel(methodCallExprMetaModel, "scope", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + methodCallExprMetaModel.getDeclaredPropertyMetaModels().add(methodCallExprMetaModel.scopePropertyMetaModel); + methodCallExprMetaModel.typeArgumentsPropertyMetaModel = new PropertyMetaModel(methodCallExprMetaModel, "typeArguments", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, true, false, false); + methodCallExprMetaModel.getDeclaredPropertyMetaModels().add(methodCallExprMetaModel.typeArgumentsPropertyMetaModel); + methodCallExprMetaModel.usingDiamondOperatorPropertyMetaModel = new PropertyMetaModel(methodCallExprMetaModel, "usingDiamondOperator", boolean.class, Optional.empty(), false, false, false, false, false); + methodCallExprMetaModel.getDerivedPropertyMetaModels().add(methodCallExprMetaModel.usingDiamondOperatorPropertyMetaModel); + methodReferenceExprMetaModel.identifierPropertyMetaModel = new PropertyMetaModel(methodReferenceExprMetaModel, "identifier", java.lang.String.class, Optional.empty(), false, true, false, false, false); + methodReferenceExprMetaModel.getDeclaredPropertyMetaModels().add(methodReferenceExprMetaModel.identifierPropertyMetaModel); + methodReferenceExprMetaModel.scopePropertyMetaModel = new PropertyMetaModel(methodReferenceExprMetaModel, "scope", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + methodReferenceExprMetaModel.getDeclaredPropertyMetaModels().add(methodReferenceExprMetaModel.scopePropertyMetaModel); + methodReferenceExprMetaModel.typeArgumentsPropertyMetaModel = new PropertyMetaModel(methodReferenceExprMetaModel, "typeArguments", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, true, false, false); + methodReferenceExprMetaModel.getDeclaredPropertyMetaModels().add(methodReferenceExprMetaModel.typeArgumentsPropertyMetaModel); + methodReferenceExprMetaModel.usingDiamondOperatorPropertyMetaModel = new PropertyMetaModel(methodReferenceExprMetaModel, "usingDiamondOperator", boolean.class, Optional.empty(), false, false, false, false, false); + methodReferenceExprMetaModel.getDerivedPropertyMetaModels().add(methodReferenceExprMetaModel.usingDiamondOperatorPropertyMetaModel); + nameExprMetaModel.namePropertyMetaModel = new PropertyMetaModel(nameExprMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + nameExprMetaModel.getDeclaredPropertyMetaModels().add(nameExprMetaModel.namePropertyMetaModel); + nameMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(nameMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + nameMetaModel.getDeclaredPropertyMetaModels().add(nameMetaModel.annotationsPropertyMetaModel); + nameMetaModel.identifierPropertyMetaModel = new PropertyMetaModel(nameMetaModel, "identifier", java.lang.String.class, Optional.empty(), false, true, false, false, false); + nameMetaModel.getDeclaredPropertyMetaModels().add(nameMetaModel.identifierPropertyMetaModel); + nameMetaModel.qualifierPropertyMetaModel = new PropertyMetaModel(nameMetaModel, "qualifier", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), true, false, false, false, false); + nameMetaModel.getDeclaredPropertyMetaModels().add(nameMetaModel.qualifierPropertyMetaModel); + normalAnnotationExprMetaModel.pairsPropertyMetaModel = new PropertyMetaModel(normalAnnotationExprMetaModel, "pairs", com.github.javaparser.ast.expr.MemberValuePair.class, Optional.of(memberValuePairMetaModel), false, false, true, false, false); + normalAnnotationExprMetaModel.getDeclaredPropertyMetaModels().add(normalAnnotationExprMetaModel.pairsPropertyMetaModel); + objectCreationExprMetaModel.anonymousClassBodyPropertyMetaModel = new PropertyMetaModel(objectCreationExprMetaModel, "anonymousClassBody", com.github.javaparser.ast.body.BodyDeclaration.class, Optional.of(bodyDeclarationMetaModel), true, false, true, false, true); + objectCreationExprMetaModel.getDeclaredPropertyMetaModels().add(objectCreationExprMetaModel.anonymousClassBodyPropertyMetaModel); + objectCreationExprMetaModel.argumentsPropertyMetaModel = new PropertyMetaModel(objectCreationExprMetaModel, "arguments", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + objectCreationExprMetaModel.getDeclaredPropertyMetaModels().add(objectCreationExprMetaModel.argumentsPropertyMetaModel); + objectCreationExprMetaModel.scopePropertyMetaModel = new PropertyMetaModel(objectCreationExprMetaModel, "scope", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + objectCreationExprMetaModel.getDeclaredPropertyMetaModels().add(objectCreationExprMetaModel.scopePropertyMetaModel); + objectCreationExprMetaModel.typePropertyMetaModel = new PropertyMetaModel(objectCreationExprMetaModel, "type", com.github.javaparser.ast.type.ClassOrInterfaceType.class, Optional.of(classOrInterfaceTypeMetaModel), false, false, false, false, false); + objectCreationExprMetaModel.getDeclaredPropertyMetaModels().add(objectCreationExprMetaModel.typePropertyMetaModel); + objectCreationExprMetaModel.typeArgumentsPropertyMetaModel = new PropertyMetaModel(objectCreationExprMetaModel, "typeArguments", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, true, false, false); + objectCreationExprMetaModel.getDeclaredPropertyMetaModels().add(objectCreationExprMetaModel.typeArgumentsPropertyMetaModel); + objectCreationExprMetaModel.usingDiamondOperatorPropertyMetaModel = new PropertyMetaModel(objectCreationExprMetaModel, "usingDiamondOperator", boolean.class, Optional.empty(), false, false, false, false, false); + objectCreationExprMetaModel.getDerivedPropertyMetaModels().add(objectCreationExprMetaModel.usingDiamondOperatorPropertyMetaModel); + simpleNameMetaModel.identifierPropertyMetaModel = new PropertyMetaModel(simpleNameMetaModel, "identifier", java.lang.String.class, Optional.empty(), false, true, false, false, false); + simpleNameMetaModel.getDeclaredPropertyMetaModels().add(simpleNameMetaModel.identifierPropertyMetaModel); + singleMemberAnnotationExprMetaModel.memberValuePropertyMetaModel = new PropertyMetaModel(singleMemberAnnotationExprMetaModel, "memberValue", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + singleMemberAnnotationExprMetaModel.getDeclaredPropertyMetaModels().add(singleMemberAnnotationExprMetaModel.memberValuePropertyMetaModel); + superExprMetaModel.classExprPropertyMetaModel = new PropertyMetaModel(superExprMetaModel, "classExpr", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + superExprMetaModel.getDeclaredPropertyMetaModels().add(superExprMetaModel.classExprPropertyMetaModel); + thisExprMetaModel.classExprPropertyMetaModel = new PropertyMetaModel(thisExprMetaModel, "classExpr", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + thisExprMetaModel.getDeclaredPropertyMetaModels().add(thisExprMetaModel.classExprPropertyMetaModel); + typeExprMetaModel.typePropertyMetaModel = new PropertyMetaModel(typeExprMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + typeExprMetaModel.getDeclaredPropertyMetaModels().add(typeExprMetaModel.typePropertyMetaModel); + unaryExprMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(unaryExprMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + unaryExprMetaModel.getDeclaredPropertyMetaModels().add(unaryExprMetaModel.expressionPropertyMetaModel); + unaryExprMetaModel.operatorPropertyMetaModel = new PropertyMetaModel(unaryExprMetaModel, "operator", com.github.javaparser.ast.expr.UnaryExpr.Operator.class, Optional.empty(), false, false, false, false, false); + unaryExprMetaModel.getDeclaredPropertyMetaModels().add(unaryExprMetaModel.operatorPropertyMetaModel); + unaryExprMetaModel.postfixPropertyMetaModel = new PropertyMetaModel(unaryExprMetaModel, "postfix", boolean.class, Optional.empty(), false, false, false, false, false); + unaryExprMetaModel.getDerivedPropertyMetaModels().add(unaryExprMetaModel.postfixPropertyMetaModel); + unaryExprMetaModel.prefixPropertyMetaModel = new PropertyMetaModel(unaryExprMetaModel, "prefix", boolean.class, Optional.empty(), false, false, false, false, false); + unaryExprMetaModel.getDerivedPropertyMetaModels().add(unaryExprMetaModel.prefixPropertyMetaModel); + variableDeclarationExprMetaModel.annotationsPropertyMetaModel = new PropertyMetaModel(variableDeclarationExprMetaModel, "annotations", com.github.javaparser.ast.expr.AnnotationExpr.class, Optional.of(annotationExprMetaModel), false, false, true, false, false); + variableDeclarationExprMetaModel.getDeclaredPropertyMetaModels().add(variableDeclarationExprMetaModel.annotationsPropertyMetaModel); + variableDeclarationExprMetaModel.modifiersPropertyMetaModel = new PropertyMetaModel(variableDeclarationExprMetaModel, "modifiers", com.github.javaparser.ast.Modifier.class, Optional.empty(), false, false, false, true, false); + variableDeclarationExprMetaModel.getDeclaredPropertyMetaModels().add(variableDeclarationExprMetaModel.modifiersPropertyMetaModel); + variableDeclarationExprMetaModel.variablesPropertyMetaModel = new PropertyMetaModel(variableDeclarationExprMetaModel, "variables", com.github.javaparser.ast.body.VariableDeclarator.class, Optional.of(variableDeclaratorMetaModel), false, true, true, false, false); + variableDeclarationExprMetaModel.getDeclaredPropertyMetaModels().add(variableDeclarationExprMetaModel.variablesPropertyMetaModel); + variableDeclarationExprMetaModel.maximumCommonTypePropertyMetaModel = new PropertyMetaModel(variableDeclarationExprMetaModel, "maximumCommonType", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, false, false, false); + variableDeclarationExprMetaModel.getDerivedPropertyMetaModels().add(variableDeclarationExprMetaModel.maximumCommonTypePropertyMetaModel); + importDeclarationMetaModel.isAsteriskPropertyMetaModel = new PropertyMetaModel(importDeclarationMetaModel, "isAsterisk", boolean.class, Optional.empty(), false, false, false, false, false); + importDeclarationMetaModel.getDeclaredPropertyMetaModels().add(importDeclarationMetaModel.isAsteriskPropertyMetaModel); + importDeclarationMetaModel.isStaticPropertyMetaModel = new PropertyMetaModel(importDeclarationMetaModel, "isStatic", boolean.class, Optional.empty(), false, false, false, false, false); + importDeclarationMetaModel.getDeclaredPropertyMetaModels().add(importDeclarationMetaModel.isStaticPropertyMetaModel); + importDeclarationMetaModel.namePropertyMetaModel = new PropertyMetaModel(importDeclarationMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + importDeclarationMetaModel.getDeclaredPropertyMetaModels().add(importDeclarationMetaModel.namePropertyMetaModel); + assertStmtMetaModel.checkPropertyMetaModel = new PropertyMetaModel(assertStmtMetaModel, "check", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + assertStmtMetaModel.getDeclaredPropertyMetaModels().add(assertStmtMetaModel.checkPropertyMetaModel); + assertStmtMetaModel.messagePropertyMetaModel = new PropertyMetaModel(assertStmtMetaModel, "message", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + assertStmtMetaModel.getDeclaredPropertyMetaModels().add(assertStmtMetaModel.messagePropertyMetaModel); + blockStmtMetaModel.statementsPropertyMetaModel = new PropertyMetaModel(blockStmtMetaModel, "statements", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, true, false, false); + blockStmtMetaModel.getDeclaredPropertyMetaModels().add(blockStmtMetaModel.statementsPropertyMetaModel); + breakStmtMetaModel.labelPropertyMetaModel = new PropertyMetaModel(breakStmtMetaModel, "label", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), true, false, false, false, false); + breakStmtMetaModel.getDeclaredPropertyMetaModels().add(breakStmtMetaModel.labelPropertyMetaModel); + catchClauseMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(catchClauseMetaModel, "body", com.github.javaparser.ast.stmt.BlockStmt.class, Optional.of(blockStmtMetaModel), false, false, false, false, false); + catchClauseMetaModel.getDeclaredPropertyMetaModels().add(catchClauseMetaModel.bodyPropertyMetaModel); + catchClauseMetaModel.parameterPropertyMetaModel = new PropertyMetaModel(catchClauseMetaModel, "parameter", com.github.javaparser.ast.body.Parameter.class, Optional.of(parameterMetaModel), false, false, false, false, false); + catchClauseMetaModel.getDeclaredPropertyMetaModels().add(catchClauseMetaModel.parameterPropertyMetaModel); + continueStmtMetaModel.labelPropertyMetaModel = new PropertyMetaModel(continueStmtMetaModel, "label", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), true, false, false, false, false); + continueStmtMetaModel.getDeclaredPropertyMetaModels().add(continueStmtMetaModel.labelPropertyMetaModel); + doStmtMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(doStmtMetaModel, "body", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, false, false, false); + doStmtMetaModel.getDeclaredPropertyMetaModels().add(doStmtMetaModel.bodyPropertyMetaModel); + doStmtMetaModel.conditionPropertyMetaModel = new PropertyMetaModel(doStmtMetaModel, "condition", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + doStmtMetaModel.getDeclaredPropertyMetaModels().add(doStmtMetaModel.conditionPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.argumentsPropertyMetaModel = new PropertyMetaModel(explicitConstructorInvocationStmtMetaModel, "arguments", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + explicitConstructorInvocationStmtMetaModel.getDeclaredPropertyMetaModels().add(explicitConstructorInvocationStmtMetaModel.argumentsPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(explicitConstructorInvocationStmtMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + explicitConstructorInvocationStmtMetaModel.getDeclaredPropertyMetaModels().add(explicitConstructorInvocationStmtMetaModel.expressionPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.isThisPropertyMetaModel = new PropertyMetaModel(explicitConstructorInvocationStmtMetaModel, "isThis", boolean.class, Optional.empty(), false, false, false, false, false); + explicitConstructorInvocationStmtMetaModel.getDeclaredPropertyMetaModels().add(explicitConstructorInvocationStmtMetaModel.isThisPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.typeArgumentsPropertyMetaModel = new PropertyMetaModel(explicitConstructorInvocationStmtMetaModel, "typeArguments", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, true, false, false); + explicitConstructorInvocationStmtMetaModel.getDeclaredPropertyMetaModels().add(explicitConstructorInvocationStmtMetaModel.typeArgumentsPropertyMetaModel); + explicitConstructorInvocationStmtMetaModel.usingDiamondOperatorPropertyMetaModel = new PropertyMetaModel(explicitConstructorInvocationStmtMetaModel, "usingDiamondOperator", boolean.class, Optional.empty(), false, false, false, false, false); + explicitConstructorInvocationStmtMetaModel.getDerivedPropertyMetaModels().add(explicitConstructorInvocationStmtMetaModel.usingDiamondOperatorPropertyMetaModel); + expressionStmtMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(expressionStmtMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + expressionStmtMetaModel.getDeclaredPropertyMetaModels().add(expressionStmtMetaModel.expressionPropertyMetaModel); + foreachStmtMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(foreachStmtMetaModel, "body", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, false, false, false); + foreachStmtMetaModel.getDeclaredPropertyMetaModels().add(foreachStmtMetaModel.bodyPropertyMetaModel); + foreachStmtMetaModel.iterablePropertyMetaModel = new PropertyMetaModel(foreachStmtMetaModel, "iterable", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + foreachStmtMetaModel.getDeclaredPropertyMetaModels().add(foreachStmtMetaModel.iterablePropertyMetaModel); + foreachStmtMetaModel.variablePropertyMetaModel = new PropertyMetaModel(foreachStmtMetaModel, "variable", com.github.javaparser.ast.expr.VariableDeclarationExpr.class, Optional.of(variableDeclarationExprMetaModel), false, false, false, false, false); + foreachStmtMetaModel.getDeclaredPropertyMetaModels().add(foreachStmtMetaModel.variablePropertyMetaModel); + forStmtMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(forStmtMetaModel, "body", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, false, false, false); + forStmtMetaModel.getDeclaredPropertyMetaModels().add(forStmtMetaModel.bodyPropertyMetaModel); + forStmtMetaModel.comparePropertyMetaModel = new PropertyMetaModel(forStmtMetaModel, "compare", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + forStmtMetaModel.getDeclaredPropertyMetaModels().add(forStmtMetaModel.comparePropertyMetaModel); + forStmtMetaModel.initializationPropertyMetaModel = new PropertyMetaModel(forStmtMetaModel, "initialization", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + forStmtMetaModel.getDeclaredPropertyMetaModels().add(forStmtMetaModel.initializationPropertyMetaModel); + forStmtMetaModel.updatePropertyMetaModel = new PropertyMetaModel(forStmtMetaModel, "update", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + forStmtMetaModel.getDeclaredPropertyMetaModels().add(forStmtMetaModel.updatePropertyMetaModel); + ifStmtMetaModel.conditionPropertyMetaModel = new PropertyMetaModel(ifStmtMetaModel, "condition", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + ifStmtMetaModel.getDeclaredPropertyMetaModels().add(ifStmtMetaModel.conditionPropertyMetaModel); + ifStmtMetaModel.elseStmtPropertyMetaModel = new PropertyMetaModel(ifStmtMetaModel, "elseStmt", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), true, false, false, false, false); + ifStmtMetaModel.getDeclaredPropertyMetaModels().add(ifStmtMetaModel.elseStmtPropertyMetaModel); + ifStmtMetaModel.thenStmtPropertyMetaModel = new PropertyMetaModel(ifStmtMetaModel, "thenStmt", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, false, false, false); + ifStmtMetaModel.getDeclaredPropertyMetaModels().add(ifStmtMetaModel.thenStmtPropertyMetaModel); + ifStmtMetaModel.cascadingIfStmtPropertyMetaModel = new PropertyMetaModel(ifStmtMetaModel, "cascadingIfStmt", boolean.class, Optional.empty(), false, false, false, false, false); + ifStmtMetaModel.getDerivedPropertyMetaModels().add(ifStmtMetaModel.cascadingIfStmtPropertyMetaModel); + ifStmtMetaModel.elseBlockPropertyMetaModel = new PropertyMetaModel(ifStmtMetaModel, "elseBlock", boolean.class, Optional.empty(), false, false, false, false, false); + ifStmtMetaModel.getDerivedPropertyMetaModels().add(ifStmtMetaModel.elseBlockPropertyMetaModel); + ifStmtMetaModel.elseBranchPropertyMetaModel = new PropertyMetaModel(ifStmtMetaModel, "elseBranch", boolean.class, Optional.empty(), false, false, false, false, false); + ifStmtMetaModel.getDerivedPropertyMetaModels().add(ifStmtMetaModel.elseBranchPropertyMetaModel); + ifStmtMetaModel.thenBlockPropertyMetaModel = new PropertyMetaModel(ifStmtMetaModel, "thenBlock", boolean.class, Optional.empty(), false, false, false, false, false); + ifStmtMetaModel.getDerivedPropertyMetaModels().add(ifStmtMetaModel.thenBlockPropertyMetaModel); + labeledStmtMetaModel.labelPropertyMetaModel = new PropertyMetaModel(labeledStmtMetaModel, "label", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + labeledStmtMetaModel.getDeclaredPropertyMetaModels().add(labeledStmtMetaModel.labelPropertyMetaModel); + labeledStmtMetaModel.statementPropertyMetaModel = new PropertyMetaModel(labeledStmtMetaModel, "statement", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, false, false, false); + labeledStmtMetaModel.getDeclaredPropertyMetaModels().add(labeledStmtMetaModel.statementPropertyMetaModel); + returnStmtMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(returnStmtMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + returnStmtMetaModel.getDeclaredPropertyMetaModels().add(returnStmtMetaModel.expressionPropertyMetaModel); + switchEntryStmtMetaModel.labelPropertyMetaModel = new PropertyMetaModel(switchEntryStmtMetaModel, "label", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), true, false, false, false, false); + switchEntryStmtMetaModel.getDeclaredPropertyMetaModels().add(switchEntryStmtMetaModel.labelPropertyMetaModel); + switchEntryStmtMetaModel.statementsPropertyMetaModel = new PropertyMetaModel(switchEntryStmtMetaModel, "statements", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, true, false, false); + switchEntryStmtMetaModel.getDeclaredPropertyMetaModels().add(switchEntryStmtMetaModel.statementsPropertyMetaModel); + switchStmtMetaModel.entriesPropertyMetaModel = new PropertyMetaModel(switchStmtMetaModel, "entries", com.github.javaparser.ast.stmt.SwitchEntryStmt.class, Optional.of(switchEntryStmtMetaModel), false, false, true, false, false); + switchStmtMetaModel.getDeclaredPropertyMetaModels().add(switchStmtMetaModel.entriesPropertyMetaModel); + switchStmtMetaModel.selectorPropertyMetaModel = new PropertyMetaModel(switchStmtMetaModel, "selector", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + switchStmtMetaModel.getDeclaredPropertyMetaModels().add(switchStmtMetaModel.selectorPropertyMetaModel); + synchronizedStmtMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(synchronizedStmtMetaModel, "body", com.github.javaparser.ast.stmt.BlockStmt.class, Optional.of(blockStmtMetaModel), false, false, false, false, false); + synchronizedStmtMetaModel.getDeclaredPropertyMetaModels().add(synchronizedStmtMetaModel.bodyPropertyMetaModel); + synchronizedStmtMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(synchronizedStmtMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + synchronizedStmtMetaModel.getDeclaredPropertyMetaModels().add(synchronizedStmtMetaModel.expressionPropertyMetaModel); + throwStmtMetaModel.expressionPropertyMetaModel = new PropertyMetaModel(throwStmtMetaModel, "expression", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + throwStmtMetaModel.getDeclaredPropertyMetaModels().add(throwStmtMetaModel.expressionPropertyMetaModel); + tryStmtMetaModel.catchClausesPropertyMetaModel = new PropertyMetaModel(tryStmtMetaModel, "catchClauses", com.github.javaparser.ast.stmt.CatchClause.class, Optional.of(catchClauseMetaModel), false, false, true, false, false); + tryStmtMetaModel.getDeclaredPropertyMetaModels().add(tryStmtMetaModel.catchClausesPropertyMetaModel); + tryStmtMetaModel.finallyBlockPropertyMetaModel = new PropertyMetaModel(tryStmtMetaModel, "finallyBlock", com.github.javaparser.ast.stmt.BlockStmt.class, Optional.of(blockStmtMetaModel), true, false, false, false, false); + tryStmtMetaModel.getDeclaredPropertyMetaModels().add(tryStmtMetaModel.finallyBlockPropertyMetaModel); + tryStmtMetaModel.resourcesPropertyMetaModel = new PropertyMetaModel(tryStmtMetaModel, "resources", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, true, false, false); + tryStmtMetaModel.getDeclaredPropertyMetaModels().add(tryStmtMetaModel.resourcesPropertyMetaModel); + tryStmtMetaModel.tryBlockPropertyMetaModel = new PropertyMetaModel(tryStmtMetaModel, "tryBlock", com.github.javaparser.ast.stmt.BlockStmt.class, Optional.of(blockStmtMetaModel), false, false, false, false, false); + tryStmtMetaModel.getDeclaredPropertyMetaModels().add(tryStmtMetaModel.tryBlockPropertyMetaModel); + localClassDeclarationStmtMetaModel.classDeclarationPropertyMetaModel = new PropertyMetaModel(localClassDeclarationStmtMetaModel, "classDeclaration", com.github.javaparser.ast.body.ClassOrInterfaceDeclaration.class, Optional.of(classOrInterfaceDeclarationMetaModel), false, false, false, false, false); + localClassDeclarationStmtMetaModel.getDeclaredPropertyMetaModels().add(localClassDeclarationStmtMetaModel.classDeclarationPropertyMetaModel); + whileStmtMetaModel.bodyPropertyMetaModel = new PropertyMetaModel(whileStmtMetaModel, "body", com.github.javaparser.ast.stmt.Statement.class, Optional.of(statementMetaModel), false, false, false, false, false); + whileStmtMetaModel.getDeclaredPropertyMetaModels().add(whileStmtMetaModel.bodyPropertyMetaModel); + whileStmtMetaModel.conditionPropertyMetaModel = new PropertyMetaModel(whileStmtMetaModel, "condition", com.github.javaparser.ast.expr.Expression.class, Optional.of(expressionMetaModel), false, false, false, false, false); + whileStmtMetaModel.getDeclaredPropertyMetaModels().add(whileStmtMetaModel.conditionPropertyMetaModel); + arrayTypeMetaModel.componentTypePropertyMetaModel = new PropertyMetaModel(arrayTypeMetaModel, "componentType", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + arrayTypeMetaModel.getDeclaredPropertyMetaModels().add(arrayTypeMetaModel.componentTypePropertyMetaModel); + arrayTypeMetaModel.originPropertyMetaModel = new PropertyMetaModel(arrayTypeMetaModel, "origin", com.github.javaparser.ast.type.ArrayType.Origin.class, Optional.empty(), false, false, false, false, false); + arrayTypeMetaModel.getDeclaredPropertyMetaModels().add(arrayTypeMetaModel.originPropertyMetaModel); + classOrInterfaceTypeMetaModel.namePropertyMetaModel = new PropertyMetaModel(classOrInterfaceTypeMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + classOrInterfaceTypeMetaModel.getDeclaredPropertyMetaModels().add(classOrInterfaceTypeMetaModel.namePropertyMetaModel); + classOrInterfaceTypeMetaModel.scopePropertyMetaModel = new PropertyMetaModel(classOrInterfaceTypeMetaModel, "scope", com.github.javaparser.ast.type.ClassOrInterfaceType.class, Optional.of(classOrInterfaceTypeMetaModel), true, false, false, false, false); + classOrInterfaceTypeMetaModel.getDeclaredPropertyMetaModels().add(classOrInterfaceTypeMetaModel.scopePropertyMetaModel); + classOrInterfaceTypeMetaModel.typeArgumentsPropertyMetaModel = new PropertyMetaModel(classOrInterfaceTypeMetaModel, "typeArguments", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), true, false, true, false, false); + classOrInterfaceTypeMetaModel.getDeclaredPropertyMetaModels().add(classOrInterfaceTypeMetaModel.typeArgumentsPropertyMetaModel); + classOrInterfaceTypeMetaModel.usingDiamondOperatorPropertyMetaModel = new PropertyMetaModel(classOrInterfaceTypeMetaModel, "usingDiamondOperator", boolean.class, Optional.empty(), false, false, false, false, false); + classOrInterfaceTypeMetaModel.getDerivedPropertyMetaModels().add(classOrInterfaceTypeMetaModel.usingDiamondOperatorPropertyMetaModel); + intersectionTypeMetaModel.elementsPropertyMetaModel = new PropertyMetaModel(intersectionTypeMetaModel, "elements", com.github.javaparser.ast.type.ReferenceType.class, Optional.of(referenceTypeMetaModel), false, true, true, false, false); + intersectionTypeMetaModel.getDeclaredPropertyMetaModels().add(intersectionTypeMetaModel.elementsPropertyMetaModel); + primitiveTypeMetaModel.typePropertyMetaModel = new PropertyMetaModel(primitiveTypeMetaModel, "type", com.github.javaparser.ast.type.PrimitiveType.Primitive.class, Optional.empty(), false, false, false, false, false); + primitiveTypeMetaModel.getDeclaredPropertyMetaModels().add(primitiveTypeMetaModel.typePropertyMetaModel); + typeParameterMetaModel.namePropertyMetaModel = new PropertyMetaModel(typeParameterMetaModel, "name", com.github.javaparser.ast.expr.SimpleName.class, Optional.of(simpleNameMetaModel), false, false, false, false, false); + typeParameterMetaModel.getDeclaredPropertyMetaModels().add(typeParameterMetaModel.namePropertyMetaModel); + typeParameterMetaModel.typeBoundPropertyMetaModel = new PropertyMetaModel(typeParameterMetaModel, "typeBound", com.github.javaparser.ast.type.ClassOrInterfaceType.class, Optional.of(classOrInterfaceTypeMetaModel), false, false, true, false, false); + typeParameterMetaModel.getDeclaredPropertyMetaModels().add(typeParameterMetaModel.typeBoundPropertyMetaModel); + unionTypeMetaModel.elementsPropertyMetaModel = new PropertyMetaModel(unionTypeMetaModel, "elements", com.github.javaparser.ast.type.ReferenceType.class, Optional.of(referenceTypeMetaModel), false, true, true, false, false); + unionTypeMetaModel.getDeclaredPropertyMetaModels().add(unionTypeMetaModel.elementsPropertyMetaModel); + wildcardTypeMetaModel.extendedTypePropertyMetaModel = new PropertyMetaModel(wildcardTypeMetaModel, "extendedType", com.github.javaparser.ast.type.ReferenceType.class, Optional.of(referenceTypeMetaModel), true, false, false, false, false); + wildcardTypeMetaModel.getDeclaredPropertyMetaModels().add(wildcardTypeMetaModel.extendedTypePropertyMetaModel); + wildcardTypeMetaModel.superTypePropertyMetaModel = new PropertyMetaModel(wildcardTypeMetaModel, "superType", com.github.javaparser.ast.type.ReferenceType.class, Optional.of(referenceTypeMetaModel), true, false, false, false, false); + wildcardTypeMetaModel.getDeclaredPropertyMetaModels().add(wildcardTypeMetaModel.superTypePropertyMetaModel); + moduleRequiresStmtMetaModel.modifiersPropertyMetaModel = new PropertyMetaModel(moduleRequiresStmtMetaModel, "modifiers", com.github.javaparser.ast.Modifier.class, Optional.empty(), false, false, false, true, false); + moduleRequiresStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleRequiresStmtMetaModel.modifiersPropertyMetaModel); + moduleRequiresStmtMetaModel.namePropertyMetaModel = new PropertyMetaModel(moduleRequiresStmtMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + moduleRequiresStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleRequiresStmtMetaModel.namePropertyMetaModel); + moduleExportsStmtMetaModel.moduleNamesPropertyMetaModel = new PropertyMetaModel(moduleExportsStmtMetaModel, "moduleNames", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, true, false, false); + moduleExportsStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleExportsStmtMetaModel.moduleNamesPropertyMetaModel); + moduleExportsStmtMetaModel.namePropertyMetaModel = new PropertyMetaModel(moduleExportsStmtMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + moduleExportsStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleExportsStmtMetaModel.namePropertyMetaModel); + moduleProvidesStmtMetaModel.typePropertyMetaModel = new PropertyMetaModel(moduleProvidesStmtMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + moduleProvidesStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleProvidesStmtMetaModel.typePropertyMetaModel); + moduleProvidesStmtMetaModel.withTypesPropertyMetaModel = new PropertyMetaModel(moduleProvidesStmtMetaModel, "withTypes", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, true, false, false); + moduleProvidesStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleProvidesStmtMetaModel.withTypesPropertyMetaModel); + moduleUsesStmtMetaModel.typePropertyMetaModel = new PropertyMetaModel(moduleUsesStmtMetaModel, "type", com.github.javaparser.ast.type.Type.class, Optional.of(typeMetaModel), false, false, false, false, false); + moduleUsesStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleUsesStmtMetaModel.typePropertyMetaModel); + moduleOpensStmtMetaModel.moduleNamesPropertyMetaModel = new PropertyMetaModel(moduleOpensStmtMetaModel, "moduleNames", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, true, false, false); + moduleOpensStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleOpensStmtMetaModel.moduleNamesPropertyMetaModel); + moduleOpensStmtMetaModel.namePropertyMetaModel = new PropertyMetaModel(moduleOpensStmtMetaModel, "name", com.github.javaparser.ast.expr.Name.class, Optional.of(nameMetaModel), false, false, false, false, false); + moduleOpensStmtMetaModel.getDeclaredPropertyMetaModels().add(moduleOpensStmtMetaModel.namePropertyMetaModel); + } + + public static Optional<BaseNodeMetaModel> getNodeMetaModel(Class<? extends Node> c) { + for (BaseNodeMetaModel nodeMetaModel : nodeMetaModels) { + if (nodeMetaModel.getTypeNameGenerified().equals(c.getSimpleName())) { + return Optional.of(nodeMetaModel); + } + } + return Optional.empty(); + } + + public static final NodeMetaModel nodeMetaModel = new NodeMetaModel(Optional.empty()); + + public static final BodyDeclarationMetaModel bodyDeclarationMetaModel = new BodyDeclarationMetaModel(Optional.of(nodeMetaModel)); + + public static final CallableDeclarationMetaModel callableDeclarationMetaModel = new CallableDeclarationMetaModel(Optional.of(bodyDeclarationMetaModel)); + + public static final StatementMetaModel statementMetaModel = new StatementMetaModel(Optional.of(nodeMetaModel)); + + public static final ExpressionMetaModel expressionMetaModel = new ExpressionMetaModel(Optional.of(nodeMetaModel)); + + public static final TypeMetaModel typeMetaModel = new TypeMetaModel(Optional.of(nodeMetaModel)); + + public static final AnnotationExprMetaModel annotationExprMetaModel = new AnnotationExprMetaModel(Optional.of(expressionMetaModel)); + + public static final TypeDeclarationMetaModel typeDeclarationMetaModel = new TypeDeclarationMetaModel(Optional.of(bodyDeclarationMetaModel)); + + public static final ReferenceTypeMetaModel referenceTypeMetaModel = new ReferenceTypeMetaModel(Optional.of(typeMetaModel)); + + public static final LiteralExprMetaModel literalExprMetaModel = new LiteralExprMetaModel(Optional.of(expressionMetaModel)); + + public static final LiteralStringValueExprMetaModel literalStringValueExprMetaModel = new LiteralStringValueExprMetaModel(Optional.of(literalExprMetaModel)); + + public static final StringLiteralExprMetaModel stringLiteralExprMetaModel = new StringLiteralExprMetaModel(Optional.of(literalStringValueExprMetaModel)); + + public static final ModuleDeclarationMetaModel moduleDeclarationMetaModel = new ModuleDeclarationMetaModel(Optional.of(nodeMetaModel)); + + public static final ModuleStmtMetaModel moduleStmtMetaModel = new ModuleStmtMetaModel(Optional.of(nodeMetaModel)); + + public static final ArrayCreationLevelMetaModel arrayCreationLevelMetaModel = new ArrayCreationLevelMetaModel(Optional.of(nodeMetaModel)); + + public static final CompilationUnitMetaModel compilationUnitMetaModel = new CompilationUnitMetaModel(Optional.of(nodeMetaModel)); + + public static final PackageDeclarationMetaModel packageDeclarationMetaModel = new PackageDeclarationMetaModel(Optional.of(nodeMetaModel)); + + public static final AnnotationDeclarationMetaModel annotationDeclarationMetaModel = new AnnotationDeclarationMetaModel(Optional.of(typeDeclarationMetaModel)); + + public static final AnnotationMemberDeclarationMetaModel annotationMemberDeclarationMetaModel = new AnnotationMemberDeclarationMetaModel(Optional.of(bodyDeclarationMetaModel)); + + public static final ClassOrInterfaceDeclarationMetaModel classOrInterfaceDeclarationMetaModel = new ClassOrInterfaceDeclarationMetaModel(Optional.of(typeDeclarationMetaModel)); + + public static final ConstructorDeclarationMetaModel constructorDeclarationMetaModel = new ConstructorDeclarationMetaModel(Optional.of(callableDeclarationMetaModel)); + + public static final EnumConstantDeclarationMetaModel enumConstantDeclarationMetaModel = new EnumConstantDeclarationMetaModel(Optional.of(bodyDeclarationMetaModel)); + + public static final EnumDeclarationMetaModel enumDeclarationMetaModel = new EnumDeclarationMetaModel(Optional.of(typeDeclarationMetaModel)); + + public static final FieldDeclarationMetaModel fieldDeclarationMetaModel = new FieldDeclarationMetaModel(Optional.of(bodyDeclarationMetaModel)); + + public static final InitializerDeclarationMetaModel initializerDeclarationMetaModel = new InitializerDeclarationMetaModel(Optional.of(bodyDeclarationMetaModel)); + + public static final MethodDeclarationMetaModel methodDeclarationMetaModel = new MethodDeclarationMetaModel(Optional.of(callableDeclarationMetaModel)); + + public static final ParameterMetaModel parameterMetaModel = new ParameterMetaModel(Optional.of(nodeMetaModel)); + + public static final ReceiverParameterMetaModel receiverParameterMetaModel = new ReceiverParameterMetaModel(Optional.of(nodeMetaModel)); + + public static final VariableDeclaratorMetaModel variableDeclaratorMetaModel = new VariableDeclaratorMetaModel(Optional.of(nodeMetaModel)); + + public static final CommentMetaModel commentMetaModel = new CommentMetaModel(Optional.of(nodeMetaModel)); + + public static final BlockCommentMetaModel blockCommentMetaModel = new BlockCommentMetaModel(Optional.of(commentMetaModel)); + + public static final JavadocCommentMetaModel javadocCommentMetaModel = new JavadocCommentMetaModel(Optional.of(commentMetaModel)); + + public static final LineCommentMetaModel lineCommentMetaModel = new LineCommentMetaModel(Optional.of(commentMetaModel)); + + public static final ArrayAccessExprMetaModel arrayAccessExprMetaModel = new ArrayAccessExprMetaModel(Optional.of(expressionMetaModel)); + + public static final ArrayCreationExprMetaModel arrayCreationExprMetaModel = new ArrayCreationExprMetaModel(Optional.of(expressionMetaModel)); + + public static final ArrayInitializerExprMetaModel arrayInitializerExprMetaModel = new ArrayInitializerExprMetaModel(Optional.of(expressionMetaModel)); + + public static final AssignExprMetaModel assignExprMetaModel = new AssignExprMetaModel(Optional.of(expressionMetaModel)); + + public static final BinaryExprMetaModel binaryExprMetaModel = new BinaryExprMetaModel(Optional.of(expressionMetaModel)); + + public static final BooleanLiteralExprMetaModel booleanLiteralExprMetaModel = new BooleanLiteralExprMetaModel(Optional.of(literalExprMetaModel)); + + public static final CastExprMetaModel castExprMetaModel = new CastExprMetaModel(Optional.of(expressionMetaModel)); + + public static final CharLiteralExprMetaModel charLiteralExprMetaModel = new CharLiteralExprMetaModel(Optional.of(literalStringValueExprMetaModel)); + + public static final ClassExprMetaModel classExprMetaModel = new ClassExprMetaModel(Optional.of(expressionMetaModel)); + + public static final ConditionalExprMetaModel conditionalExprMetaModel = new ConditionalExprMetaModel(Optional.of(expressionMetaModel)); + + public static final DoubleLiteralExprMetaModel doubleLiteralExprMetaModel = new DoubleLiteralExprMetaModel(Optional.of(literalStringValueExprMetaModel)); + + public static final EnclosedExprMetaModel enclosedExprMetaModel = new EnclosedExprMetaModel(Optional.of(expressionMetaModel)); + + public static final FieldAccessExprMetaModel fieldAccessExprMetaModel = new FieldAccessExprMetaModel(Optional.of(expressionMetaModel)); + + public static final InstanceOfExprMetaModel instanceOfExprMetaModel = new InstanceOfExprMetaModel(Optional.of(expressionMetaModel)); + + public static final IntegerLiteralExprMetaModel integerLiteralExprMetaModel = new IntegerLiteralExprMetaModel(Optional.of(literalStringValueExprMetaModel)); + + public static final LambdaExprMetaModel lambdaExprMetaModel = new LambdaExprMetaModel(Optional.of(expressionMetaModel)); + + public static final LongLiteralExprMetaModel longLiteralExprMetaModel = new LongLiteralExprMetaModel(Optional.of(literalStringValueExprMetaModel)); + + public static final MarkerAnnotationExprMetaModel markerAnnotationExprMetaModel = new MarkerAnnotationExprMetaModel(Optional.of(annotationExprMetaModel)); + + public static final MemberValuePairMetaModel memberValuePairMetaModel = new MemberValuePairMetaModel(Optional.of(nodeMetaModel)); + + public static final MethodCallExprMetaModel methodCallExprMetaModel = new MethodCallExprMetaModel(Optional.of(expressionMetaModel)); + + public static final MethodReferenceExprMetaModel methodReferenceExprMetaModel = new MethodReferenceExprMetaModel(Optional.of(expressionMetaModel)); + + public static final NameExprMetaModel nameExprMetaModel = new NameExprMetaModel(Optional.of(expressionMetaModel)); + + public static final NameMetaModel nameMetaModel = new NameMetaModel(Optional.of(nodeMetaModel)); + + public static final NormalAnnotationExprMetaModel normalAnnotationExprMetaModel = new NormalAnnotationExprMetaModel(Optional.of(annotationExprMetaModel)); + + public static final NullLiteralExprMetaModel nullLiteralExprMetaModel = new NullLiteralExprMetaModel(Optional.of(literalExprMetaModel)); + + public static final ObjectCreationExprMetaModel objectCreationExprMetaModel = new ObjectCreationExprMetaModel(Optional.of(expressionMetaModel)); + + public static final SimpleNameMetaModel simpleNameMetaModel = new SimpleNameMetaModel(Optional.of(nodeMetaModel)); + + public static final SingleMemberAnnotationExprMetaModel singleMemberAnnotationExprMetaModel = new SingleMemberAnnotationExprMetaModel(Optional.of(annotationExprMetaModel)); + + public static final SuperExprMetaModel superExprMetaModel = new SuperExprMetaModel(Optional.of(expressionMetaModel)); + + public static final ThisExprMetaModel thisExprMetaModel = new ThisExprMetaModel(Optional.of(expressionMetaModel)); + + public static final TypeExprMetaModel typeExprMetaModel = new TypeExprMetaModel(Optional.of(expressionMetaModel)); + + public static final UnaryExprMetaModel unaryExprMetaModel = new UnaryExprMetaModel(Optional.of(expressionMetaModel)); + + public static final VariableDeclarationExprMetaModel variableDeclarationExprMetaModel = new VariableDeclarationExprMetaModel(Optional.of(expressionMetaModel)); + + public static final ImportDeclarationMetaModel importDeclarationMetaModel = new ImportDeclarationMetaModel(Optional.of(nodeMetaModel)); + + public static final AssertStmtMetaModel assertStmtMetaModel = new AssertStmtMetaModel(Optional.of(statementMetaModel)); + + public static final BlockStmtMetaModel blockStmtMetaModel = new BlockStmtMetaModel(Optional.of(statementMetaModel)); + + public static final BreakStmtMetaModel breakStmtMetaModel = new BreakStmtMetaModel(Optional.of(statementMetaModel)); + + public static final CatchClauseMetaModel catchClauseMetaModel = new CatchClauseMetaModel(Optional.of(nodeMetaModel)); + + public static final ContinueStmtMetaModel continueStmtMetaModel = new ContinueStmtMetaModel(Optional.of(statementMetaModel)); + + public static final DoStmtMetaModel doStmtMetaModel = new DoStmtMetaModel(Optional.of(statementMetaModel)); + + public static final EmptyStmtMetaModel emptyStmtMetaModel = new EmptyStmtMetaModel(Optional.of(statementMetaModel)); + + public static final ExplicitConstructorInvocationStmtMetaModel explicitConstructorInvocationStmtMetaModel = new ExplicitConstructorInvocationStmtMetaModel(Optional.of(statementMetaModel)); + + public static final ExpressionStmtMetaModel expressionStmtMetaModel = new ExpressionStmtMetaModel(Optional.of(statementMetaModel)); + + public static final ForeachStmtMetaModel foreachStmtMetaModel = new ForeachStmtMetaModel(Optional.of(statementMetaModel)); + + public static final ForStmtMetaModel forStmtMetaModel = new ForStmtMetaModel(Optional.of(statementMetaModel)); + + public static final IfStmtMetaModel ifStmtMetaModel = new IfStmtMetaModel(Optional.of(statementMetaModel)); + + public static final LabeledStmtMetaModel labeledStmtMetaModel = new LabeledStmtMetaModel(Optional.of(statementMetaModel)); + + public static final ReturnStmtMetaModel returnStmtMetaModel = new ReturnStmtMetaModel(Optional.of(statementMetaModel)); + + public static final SwitchEntryStmtMetaModel switchEntryStmtMetaModel = new SwitchEntryStmtMetaModel(Optional.of(statementMetaModel)); + + public static final SwitchStmtMetaModel switchStmtMetaModel = new SwitchStmtMetaModel(Optional.of(statementMetaModel)); + + public static final SynchronizedStmtMetaModel synchronizedStmtMetaModel = new SynchronizedStmtMetaModel(Optional.of(statementMetaModel)); + + public static final ThrowStmtMetaModel throwStmtMetaModel = new ThrowStmtMetaModel(Optional.of(statementMetaModel)); + + public static final TryStmtMetaModel tryStmtMetaModel = new TryStmtMetaModel(Optional.of(statementMetaModel)); + + public static final LocalClassDeclarationStmtMetaModel localClassDeclarationStmtMetaModel = new LocalClassDeclarationStmtMetaModel(Optional.of(statementMetaModel)); + + public static final WhileStmtMetaModel whileStmtMetaModel = new WhileStmtMetaModel(Optional.of(statementMetaModel)); + + public static final UnparsableStmtMetaModel unparsableStmtMetaModel = new UnparsableStmtMetaModel(Optional.of(statementMetaModel)); + + public static final ArrayTypeMetaModel arrayTypeMetaModel = new ArrayTypeMetaModel(Optional.of(referenceTypeMetaModel)); + + public static final ClassOrInterfaceTypeMetaModel classOrInterfaceTypeMetaModel = new ClassOrInterfaceTypeMetaModel(Optional.of(referenceTypeMetaModel)); + + public static final IntersectionTypeMetaModel intersectionTypeMetaModel = new IntersectionTypeMetaModel(Optional.of(typeMetaModel)); + + public static final PrimitiveTypeMetaModel primitiveTypeMetaModel = new PrimitiveTypeMetaModel(Optional.of(typeMetaModel)); + + public static final TypeParameterMetaModel typeParameterMetaModel = new TypeParameterMetaModel(Optional.of(referenceTypeMetaModel)); + + public static final UnionTypeMetaModel unionTypeMetaModel = new UnionTypeMetaModel(Optional.of(typeMetaModel)); + + public static final UnknownTypeMetaModel unknownTypeMetaModel = new UnknownTypeMetaModel(Optional.of(typeMetaModel)); + + public static final VoidTypeMetaModel voidTypeMetaModel = new VoidTypeMetaModel(Optional.of(typeMetaModel)); + + public static final WildcardTypeMetaModel wildcardTypeMetaModel = new WildcardTypeMetaModel(Optional.of(typeMetaModel)); + + public static final VarTypeMetaModel varTypeMetaModel = new VarTypeMetaModel(Optional.of(typeMetaModel)); + + public static final ModuleRequiresStmtMetaModel moduleRequiresStmtMetaModel = new ModuleRequiresStmtMetaModel(Optional.of(moduleStmtMetaModel)); + + public static final ModuleExportsStmtMetaModel moduleExportsStmtMetaModel = new ModuleExportsStmtMetaModel(Optional.of(moduleStmtMetaModel)); + + public static final ModuleProvidesStmtMetaModel moduleProvidesStmtMetaModel = new ModuleProvidesStmtMetaModel(Optional.of(moduleStmtMetaModel)); + + public static final ModuleUsesStmtMetaModel moduleUsesStmtMetaModel = new ModuleUsesStmtMetaModel(Optional.of(moduleStmtMetaModel)); + + public static final ModuleOpensStmtMetaModel moduleOpensStmtMetaModel = new ModuleOpensStmtMetaModel(Optional.of(moduleStmtMetaModel)); + + static { + initializeNodeMetaModels(); + initializePropertyMetaModels(); + initializeConstructorParameters(); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/JavadocCommentMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/JavadocCommentMetaModel.java new file mode 100644 index 000000000..4da20077c --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/JavadocCommentMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class JavadocCommentMetaModel extends CommentMetaModel { + + JavadocCommentMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.comments.JavadocComment.class, "JavadocComment", "com.github.javaparser.ast.comments", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/LabeledStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LabeledStmtMetaModel.java new file mode 100644 index 000000000..d8532efac --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LabeledStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class LabeledStmtMetaModel extends StatementMetaModel { + + LabeledStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.LabeledStmt.class, "LabeledStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel labelPropertyMetaModel; + + public PropertyMetaModel statementPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/LambdaExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LambdaExprMetaModel.java new file mode 100644 index 000000000..ad50a65a6 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LambdaExprMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class LambdaExprMetaModel extends ExpressionMetaModel { + + LambdaExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.LambdaExpr.class, "LambdaExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel isEnclosingParametersPropertyMetaModel; + + public PropertyMetaModel parametersPropertyMetaModel; + + public PropertyMetaModel expressionBodyPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/LineCommentMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LineCommentMetaModel.java new file mode 100644 index 000000000..dfc8bbdf7 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LineCommentMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class LineCommentMetaModel extends CommentMetaModel { + + LineCommentMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.comments.LineComment.class, "LineComment", "com.github.javaparser.ast.comments", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/LiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LiteralExprMetaModel.java new file mode 100644 index 000000000..47f9fcdec --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LiteralExprMetaModel.java @@ -0,0 +1,15 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class LiteralExprMetaModel extends ExpressionMetaModel { + + LiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.LiteralExpr.class, "LiteralExpr", "com.github.javaparser.ast.expr", true, false); + } + + protected LiteralExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/LiteralStringValueExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LiteralStringValueExprMetaModel.java new file mode 100644 index 000000000..6ed8578b9 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LiteralStringValueExprMetaModel.java @@ -0,0 +1,17 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class LiteralStringValueExprMetaModel extends LiteralExprMetaModel { + + LiteralStringValueExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.LiteralStringValueExpr.class, "LiteralStringValueExpr", "com.github.javaparser.ast.expr", true, false); + } + + protected LiteralStringValueExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel valuePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/LocalClassDeclarationStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LocalClassDeclarationStmtMetaModel.java new file mode 100644 index 000000000..d936eb093 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LocalClassDeclarationStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class LocalClassDeclarationStmtMetaModel extends StatementMetaModel { + + LocalClassDeclarationStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.LocalClassDeclarationStmt.class, "LocalClassDeclarationStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel classDeclarationPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/LongLiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LongLiteralExprMetaModel.java new file mode 100644 index 000000000..42006b536 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/LongLiteralExprMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class LongLiteralExprMetaModel extends LiteralStringValueExprMetaModel { + + LongLiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.LongLiteralExpr.class, "LongLiteralExpr", "com.github.javaparser.ast.expr", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/MarkerAnnotationExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MarkerAnnotationExprMetaModel.java new file mode 100644 index 000000000..0371b5142 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MarkerAnnotationExprMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class MarkerAnnotationExprMetaModel extends AnnotationExprMetaModel { + + MarkerAnnotationExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.MarkerAnnotationExpr.class, "MarkerAnnotationExpr", "com.github.javaparser.ast.expr", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/MemberValuePairMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MemberValuePairMetaModel.java new file mode 100644 index 000000000..652181847 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MemberValuePairMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class MemberValuePairMetaModel extends NodeMetaModel { + + MemberValuePairMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.MemberValuePair.class, "MemberValuePair", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel valuePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodCallExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodCallExprMetaModel.java new file mode 100644 index 000000000..728407c28 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodCallExprMetaModel.java @@ -0,0 +1,20 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class MethodCallExprMetaModel extends ExpressionMetaModel { + + MethodCallExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.MethodCallExpr.class, "MethodCallExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel argumentsPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel scopePropertyMetaModel; + + public PropertyMetaModel typeArgumentsPropertyMetaModel; + + public PropertyMetaModel usingDiamondOperatorPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodDeclarationMetaModel.java new file mode 100644 index 000000000..74aaeae69 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodDeclarationMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class MethodDeclarationMetaModel extends CallableDeclarationMetaModel { + + MethodDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.MethodDeclaration.class, "MethodDeclaration", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodReferenceExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodReferenceExprMetaModel.java new file mode 100644 index 000000000..4968046c1 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/MethodReferenceExprMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class MethodReferenceExprMetaModel extends ExpressionMetaModel { + + MethodReferenceExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.MethodReferenceExpr.class, "MethodReferenceExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel identifierPropertyMetaModel; + + public PropertyMetaModel scopePropertyMetaModel; + + public PropertyMetaModel typeArgumentsPropertyMetaModel; + + public PropertyMetaModel usingDiamondOperatorPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleDeclarationMetaModel.java new file mode 100644 index 000000000..0cf3c3e7a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleDeclarationMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ModuleDeclarationMetaModel extends NodeMetaModel { + + ModuleDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.modules.ModuleDeclaration.class, "ModuleDeclaration", "com.github.javaparser.ast.modules", false, false); + } + + public PropertyMetaModel annotationsPropertyMetaModel; + + public PropertyMetaModel isOpenPropertyMetaModel; + + public PropertyMetaModel moduleStmtsPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleExportsStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleExportsStmtMetaModel.java new file mode 100644 index 000000000..7b6af7e10 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleExportsStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ModuleExportsStmtMetaModel extends ModuleStmtMetaModel { + + ModuleExportsStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.modules.ModuleExportsStmt.class, "ModuleExportsStmt", "com.github.javaparser.ast.modules", false, false); + } + + public PropertyMetaModel moduleNamesPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleOpensStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleOpensStmtMetaModel.java new file mode 100644 index 000000000..16a5a4847 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleOpensStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ModuleOpensStmtMetaModel extends ModuleStmtMetaModel { + + ModuleOpensStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.modules.ModuleOpensStmt.class, "ModuleOpensStmt", "com.github.javaparser.ast.modules", false, false); + } + + public PropertyMetaModel moduleNamesPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleProvidesStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleProvidesStmtMetaModel.java new file mode 100644 index 000000000..2c3bffc1a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleProvidesStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ModuleProvidesStmtMetaModel extends ModuleStmtMetaModel { + + ModuleProvidesStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.modules.ModuleProvidesStmt.class, "ModuleProvidesStmt", "com.github.javaparser.ast.modules", false, false); + } + + public PropertyMetaModel typePropertyMetaModel; + + public PropertyMetaModel withTypesPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleRequiresStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleRequiresStmtMetaModel.java new file mode 100644 index 000000000..320a81167 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleRequiresStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ModuleRequiresStmtMetaModel extends ModuleStmtMetaModel { + + ModuleRequiresStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.modules.ModuleRequiresStmt.class, "ModuleRequiresStmt", "com.github.javaparser.ast.modules", false, false); + } + + public PropertyMetaModel modifiersPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleStmtMetaModel.java new file mode 100644 index 000000000..63ca214e8 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleStmtMetaModel.java @@ -0,0 +1,15 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class ModuleStmtMetaModel extends NodeMetaModel { + + ModuleStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.modules.ModuleStmt.class, "ModuleStmt", "com.github.javaparser.ast.modules", true, false); + } + + protected ModuleStmtMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleUsesStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleUsesStmtMetaModel.java new file mode 100644 index 000000000..bac904356 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ModuleUsesStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ModuleUsesStmtMetaModel extends ModuleStmtMetaModel { + + ModuleUsesStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.modules.ModuleUsesStmt.class, "ModuleUsesStmt", "com.github.javaparser.ast.modules", false, false); + } + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/NameExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NameExprMetaModel.java new file mode 100644 index 000000000..bed296190 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NameExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class NameExprMetaModel extends ExpressionMetaModel { + + NameExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.NameExpr.class, "NameExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/NameMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NameMetaModel.java new file mode 100644 index 000000000..cd54085d0 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NameMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class NameMetaModel extends NodeMetaModel { + + NameMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.Name.class, "Name", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel annotationsPropertyMetaModel; + + public PropertyMetaModel identifierPropertyMetaModel; + + public PropertyMetaModel qualifierPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/NodeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NodeMetaModel.java new file mode 100644 index 000000000..332dfd4fc --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NodeMetaModel.java @@ -0,0 +1,17 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class NodeMetaModel extends BaseNodeMetaModel { + + NodeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.Node.class, "Node", "com.github.javaparser.ast", true, false); + } + + protected NodeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel commentPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/NonEmptyProperty.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NonEmptyProperty.java new file mode 100644 index 000000000..7be7fdcc6 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NonEmptyProperty.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +/** + * Indicate that leaving this property empty does not lead to a correct AST. + * Empty means either empty string or empty collection. + * (Used during generation of the meta model.) + */ +@Retention(RUNTIME) +@Target({FIELD, METHOD}) +public @interface NonEmptyProperty { +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/NormalAnnotationExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NormalAnnotationExprMetaModel.java new file mode 100644 index 000000000..a88a77700 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NormalAnnotationExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class NormalAnnotationExprMetaModel extends AnnotationExprMetaModel { + + NormalAnnotationExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.NormalAnnotationExpr.class, "NormalAnnotationExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel pairsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/NullLiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NullLiteralExprMetaModel.java new file mode 100644 index 000000000..698fb302e --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/NullLiteralExprMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class NullLiteralExprMetaModel extends LiteralExprMetaModel { + + NullLiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.NullLiteralExpr.class, "NullLiteralExpr", "com.github.javaparser.ast.expr", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ObjectCreationExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ObjectCreationExprMetaModel.java new file mode 100644 index 000000000..4149d1dfd --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ObjectCreationExprMetaModel.java @@ -0,0 +1,22 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ObjectCreationExprMetaModel extends ExpressionMetaModel { + + ObjectCreationExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.ObjectCreationExpr.class, "ObjectCreationExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel anonymousClassBodyPropertyMetaModel; + + public PropertyMetaModel argumentsPropertyMetaModel; + + public PropertyMetaModel scopePropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; + + public PropertyMetaModel typeArgumentsPropertyMetaModel; + + public PropertyMetaModel usingDiamondOperatorPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/OptionalProperty.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/OptionalProperty.java new file mode 100644 index 000000000..5052e3bcf --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/OptionalProperty.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +/** + * Indicate an optional property of a Node. + * (Used during generation of the meta model.) + */ +@Retention(RUNTIME) +@Target(FIELD) +public @interface OptionalProperty { +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/PackageDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/PackageDeclarationMetaModel.java new file mode 100644 index 000000000..3ae52b4f1 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/PackageDeclarationMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class PackageDeclarationMetaModel extends NodeMetaModel { + + PackageDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.PackageDeclaration.class, "PackageDeclaration", "com.github.javaparser.ast", false, false); + } + + public PropertyMetaModel annotationsPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ParameterMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ParameterMetaModel.java new file mode 100644 index 000000000..034b5c7e4 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ParameterMetaModel.java @@ -0,0 +1,22 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ParameterMetaModel extends NodeMetaModel { + + ParameterMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.Parameter.class, "Parameter", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel annotationsPropertyMetaModel; + + public PropertyMetaModel isVarArgsPropertyMetaModel; + + public PropertyMetaModel modifiersPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; + + public PropertyMetaModel varArgsAnnotationsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/PrimitiveTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/PrimitiveTypeMetaModel.java new file mode 100644 index 000000000..71ee28c5c --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/PrimitiveTypeMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class PrimitiveTypeMetaModel extends TypeMetaModel { + + PrimitiveTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.PrimitiveType.class, "PrimitiveType", "com.github.javaparser.ast.type", false, false); + } + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/PropertyMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/PropertyMetaModel.java new file mode 100644 index 000000000..5dcf4afb5 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/PropertyMetaModel.java @@ -0,0 +1,248 @@ +package com.github.javaparser.metamodel; + +import com.github.javaparser.ast.Node; + +import java.lang.reflect.Field; +import java.util.Optional; + +import static com.github.javaparser.utils.CodeGenerationUtils.getterName; +import static com.github.javaparser.utils.CodeGenerationUtils.setterName; + +/** + * Meta-data about a property of a node in the AST. + */ +public class PropertyMetaModel { + private final BaseNodeMetaModel containingNodeMetaModel; + private final String name; + private final Class<?> type; + private final Optional<BaseNodeMetaModel> nodeReference; + private final boolean isOptional; + private final boolean isNonEmpty; + private final boolean isNodeList; + private final boolean isEnumSet; + private final boolean hasWildcard; + + public PropertyMetaModel(BaseNodeMetaModel containingNodeMetaModel, String name, Class<?> type, Optional<BaseNodeMetaModel> nodeReference, boolean isOptional, boolean isNonEmpty, boolean isNodeList, boolean isEnumSet, boolean hasWildcard) { + this.containingNodeMetaModel = containingNodeMetaModel; + this.name = name; + this.type = type; + this.nodeReference = nodeReference; + this.isOptional = isOptional; + this.isNonEmpty = isNonEmpty; + this.isNodeList = isNodeList; + this.isEnumSet = isEnumSet; + this.hasWildcard = hasWildcard; + } + + /** + * @return is this the field fieldName on class c? + */ + public boolean is(Class<? extends Node> c, String fieldName) { + return containingNodeMetaModel.is(c) && name.equals(fieldName); + } + + /** + * @return is this fields called fieldName? + */ + public boolean is(String fieldName) { + return name.equals(fieldName); + } + + /** + * @return the name used in the AST for the setter + */ + public String getSetterMethodName() { + return setterName(name); + } + + /** + * @return the name used in the AST for the getter + */ + public String getGetterMethodName() { + return getterName(type, name); + } + + /** + * @return the NodeMetaModel that "has" this property. + */ + public BaseNodeMetaModel getContainingNodeMetaModel() { + return containingNodeMetaModel; + } + + /** + * @return the name of the property. This is equal to the name of the field in the AST. + */ + public String getName() { + return name; + } + + /** + * @return if this property is a String or a NodeList: whether it may be empty. + */ + public boolean isNonEmpty() { + return isNonEmpty; + } + + /** + * @return the class of the field. + */ + public Class<?> getType() { + return type; + } + + /** + * @return if this property is a Node, this will get the node meta model. + */ + public Optional<BaseNodeMetaModel> getNodeReference() { + return nodeReference; + } + + /** + * @return whether this property is optional. + */ + public boolean isOptional() { + return isOptional; + } + + /** + * @return whether this property is not optional. + */ + public boolean isRequired() { + return !isOptional; + } + + /** + * @return whether this property is contained in a NodeList. + */ + public boolean isNodeList() { + return isNodeList; + } + + /** + * @return whether this property is contained in an EnumSet. + */ + public boolean isEnumSet() { + return isEnumSet; + } + + /** + * @return whether this property has a wildcard following it, like BodyDeclaration<?>. + */ + public boolean hasWildcard() { + return hasWildcard; + } + + /** + * @return whether this property is not a list or set. + */ + public boolean isSingular() { + return !(isNodeList || isEnumSet); + } + + @Override + public String toString() { + return "(" + getTypeName() + ")\t" + containingNodeMetaModel + "#" + name; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + PropertyMetaModel that = (PropertyMetaModel) o; + + if (!name.equals(that.name)) return false; + if (!type.equals(that.type)) return false; + + return true; + } + + @Override + public int hashCode() { + int result = name.hashCode(); + result = 31 * result + type.hashCode(); + return result; + } + + /** + * @return the type of a single element of this property, so no Optional or NodeList or EnumSet. + */ + public String getTypeNameGenerified() { + if (hasWildcard) { + return getTypeName() + "<?>"; + } + return getTypeName(); + } + + /** + * @return the raw type of a single element of this property, so nothing but the name. + */ + public String getTypeName() { + return type.getSimpleName(); + } + + /** + * @return the type that is returned from getters in the AST. + */ + public String getTypeNameForGetter() { + if (isOptional) { + return "Optional<" + getTypeNameForSetter() + ">"; + } + return getTypeNameForSetter(); + } + + /** + * @return the type that is passed to setters in the AST. + */ + public String getTypeNameForSetter() { + if (isNodeList) { + return "NodeList<" + getTypeNameGenerified() + ">"; + } + if (isEnumSet) { + return "EnumSet<" + getTypeNameGenerified() + ">"; + } + return getTypeNameGenerified(); + } + + /** + * @return is this property an AST Node? + */ + public boolean isNode() { + return getNodeReference().isPresent(); + } + + /** + * The name of the field in the containing BaseNodeMetaModel for this property meta model. + */ + public String getMetaModelFieldName() { + return getName() + "PropertyMetaModel"; + } + + /** + * @return is this property an attribute, meaning: not a node? + */ + public boolean isAttribute() { + return !isNode(); + } + + /** + * Introspects the node to get the value from this field. + * Note that an optional empty field will return null here. + */ + public Object getValue(Node node) { + try { + for (Class<?> c = node.getClass(); c != null; c = c.getSuperclass()) { + Field[] fields = c.getDeclaredFields(); + for (Field classField : fields) { + if (classField.getName().equals(getName())) { + classField.setAccessible(true); + return classField.get(node); + } + } + } + throw new NoSuchFieldError(getName()); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReceiverParameterMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReceiverParameterMetaModel.java new file mode 100644 index 000000000..e0fb46355 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReceiverParameterMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ReceiverParameterMetaModel extends NodeMetaModel { + + ReceiverParameterMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.ReceiverParameter.class, "ReceiverParameter", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel annotationsPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReferenceTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReferenceTypeMetaModel.java new file mode 100644 index 000000000..fa0361ba5 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReferenceTypeMetaModel.java @@ -0,0 +1,15 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class ReferenceTypeMetaModel extends TypeMetaModel { + + ReferenceTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.ReferenceType.class, "ReferenceType", "com.github.javaparser.ast.type", true, false); + } + + protected ReferenceTypeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReturnStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReturnStmtMetaModel.java new file mode 100644 index 000000000..27af5ec88 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ReturnStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ReturnStmtMetaModel extends StatementMetaModel { + + ReturnStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.ReturnStmt.class, "ReturnStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel expressionPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/SimpleNameMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SimpleNameMetaModel.java new file mode 100644 index 000000000..1c042966f --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SimpleNameMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class SimpleNameMetaModel extends NodeMetaModel { + + SimpleNameMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.SimpleName.class, "SimpleName", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel identifierPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/SingleMemberAnnotationExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SingleMemberAnnotationExprMetaModel.java new file mode 100644 index 000000000..a5223cda3 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SingleMemberAnnotationExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class SingleMemberAnnotationExprMetaModel extends AnnotationExprMetaModel { + + SingleMemberAnnotationExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.SingleMemberAnnotationExpr.class, "SingleMemberAnnotationExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel memberValuePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/StatementMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/StatementMetaModel.java new file mode 100644 index 000000000..8433ab0b6 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/StatementMetaModel.java @@ -0,0 +1,15 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class StatementMetaModel extends NodeMetaModel { + + StatementMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.Statement.class, "Statement", "com.github.javaparser.ast.stmt", true, false); + } + + protected StatementMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/StringLiteralExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/StringLiteralExprMetaModel.java new file mode 100644 index 000000000..1dc0acf55 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/StringLiteralExprMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class StringLiteralExprMetaModel extends LiteralStringValueExprMetaModel { + + StringLiteralExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.StringLiteralExpr.class, "StringLiteralExpr", "com.github.javaparser.ast.expr", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/SuperExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SuperExprMetaModel.java new file mode 100644 index 000000000..745df8bb7 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SuperExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class SuperExprMetaModel extends ExpressionMetaModel { + + SuperExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.SuperExpr.class, "SuperExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel classExprPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/SwitchEntryStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SwitchEntryStmtMetaModel.java new file mode 100644 index 000000000..b8e625210 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SwitchEntryStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class SwitchEntryStmtMetaModel extends StatementMetaModel { + + SwitchEntryStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.SwitchEntryStmt.class, "SwitchEntryStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel labelPropertyMetaModel; + + public PropertyMetaModel statementsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/SwitchStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SwitchStmtMetaModel.java new file mode 100644 index 000000000..dc9df0eea --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SwitchStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class SwitchStmtMetaModel extends StatementMetaModel { + + SwitchStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.SwitchStmt.class, "SwitchStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel entriesPropertyMetaModel; + + public PropertyMetaModel selectorPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/SynchronizedStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SynchronizedStmtMetaModel.java new file mode 100644 index 000000000..01a870979 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/SynchronizedStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class SynchronizedStmtMetaModel extends StatementMetaModel { + + SynchronizedStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.SynchronizedStmt.class, "SynchronizedStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel expressionPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ThisExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ThisExprMetaModel.java new file mode 100644 index 000000000..fbfd5a5bb --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ThisExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ThisExprMetaModel extends ExpressionMetaModel { + + ThisExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.ThisExpr.class, "ThisExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel classExprPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/ThrowStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ThrowStmtMetaModel.java new file mode 100644 index 000000000..c5bd2e195 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/ThrowStmtMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class ThrowStmtMetaModel extends StatementMetaModel { + + ThrowStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.ThrowStmt.class, "ThrowStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel expressionPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/TryStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TryStmtMetaModel.java new file mode 100644 index 000000000..28756db5e --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TryStmtMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class TryStmtMetaModel extends StatementMetaModel { + + TryStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.TryStmt.class, "TryStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel catchClausesPropertyMetaModel; + + public PropertyMetaModel finallyBlockPropertyMetaModel; + + public PropertyMetaModel resourcesPropertyMetaModel; + + public PropertyMetaModel tryBlockPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeDeclarationMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeDeclarationMetaModel.java new file mode 100644 index 000000000..f7f0d00ab --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeDeclarationMetaModel.java @@ -0,0 +1,21 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class TypeDeclarationMetaModel extends BodyDeclarationMetaModel { + + TypeDeclarationMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.TypeDeclaration.class, "TypeDeclaration", "com.github.javaparser.ast.body", true, true); + } + + protected TypeDeclarationMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel membersPropertyMetaModel; + + public PropertyMetaModel modifiersPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeExprMetaModel.java new file mode 100644 index 000000000..8d0b90dad --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeExprMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class TypeExprMetaModel extends ExpressionMetaModel { + + TypeExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.TypeExpr.class, "TypeExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeMetaModel.java new file mode 100644 index 000000000..76b084b32 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeMetaModel.java @@ -0,0 +1,17 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; +import com.github.javaparser.ast.Node; + +public class TypeMetaModel extends NodeMetaModel { + + TypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.Type.class, "Type", "com.github.javaparser.ast.type", true, false); + } + + protected TypeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard) { + super(superNodeMetaModel, type, name, packageName, isAbstract, hasWildcard); + } + + public PropertyMetaModel annotationsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeParameterMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeParameterMetaModel.java new file mode 100644 index 000000000..2e8740206 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/TypeParameterMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class TypeParameterMetaModel extends ReferenceTypeMetaModel { + + TypeParameterMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.TypeParameter.class, "TypeParameter", "com.github.javaparser.ast.type", false, false); + } + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel typeBoundPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnaryExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnaryExprMetaModel.java new file mode 100644 index 000000000..309af9a92 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnaryExprMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class UnaryExprMetaModel extends ExpressionMetaModel { + + UnaryExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.UnaryExpr.class, "UnaryExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel expressionPropertyMetaModel; + + public PropertyMetaModel operatorPropertyMetaModel; + + public PropertyMetaModel postfixPropertyMetaModel; + + public PropertyMetaModel prefixPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnionTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnionTypeMetaModel.java new file mode 100644 index 000000000..14e81becd --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnionTypeMetaModel.java @@ -0,0 +1,12 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class UnionTypeMetaModel extends TypeMetaModel { + + UnionTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.UnionType.class, "UnionType", "com.github.javaparser.ast.type", false, false); + } + + public PropertyMetaModel elementsPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnknownTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnknownTypeMetaModel.java new file mode 100644 index 000000000..d83518b79 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnknownTypeMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class UnknownTypeMetaModel extends TypeMetaModel { + + UnknownTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.UnknownType.class, "UnknownType", "com.github.javaparser.ast.type", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnparsableStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnparsableStmtMetaModel.java new file mode 100644 index 000000000..7d18f74ab --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/UnparsableStmtMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class UnparsableStmtMetaModel extends StatementMetaModel { + + UnparsableStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.UnparsableStmt.class, "UnparsableStmt", "com.github.javaparser.ast.stmt", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/VarTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VarTypeMetaModel.java new file mode 100644 index 000000000..1ada830c5 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VarTypeMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class VarTypeMetaModel extends TypeMetaModel { + + VarTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.VarType.class, "VarType", "com.github.javaparser.ast.type", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/VariableDeclarationExprMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VariableDeclarationExprMetaModel.java new file mode 100644 index 000000000..c9c30c0b5 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VariableDeclarationExprMetaModel.java @@ -0,0 +1,18 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class VariableDeclarationExprMetaModel extends ExpressionMetaModel { + + VariableDeclarationExprMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.expr.VariableDeclarationExpr.class, "VariableDeclarationExpr", "com.github.javaparser.ast.expr", false, false); + } + + public PropertyMetaModel annotationsPropertyMetaModel; + + public PropertyMetaModel modifiersPropertyMetaModel; + + public PropertyMetaModel variablesPropertyMetaModel; + + public PropertyMetaModel maximumCommonTypePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/VariableDeclaratorMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VariableDeclaratorMetaModel.java new file mode 100644 index 000000000..83f12aca6 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VariableDeclaratorMetaModel.java @@ -0,0 +1,16 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class VariableDeclaratorMetaModel extends NodeMetaModel { + + VariableDeclaratorMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.body.VariableDeclarator.class, "VariableDeclarator", "com.github.javaparser.ast.body", false, false); + } + + public PropertyMetaModel initializerPropertyMetaModel; + + public PropertyMetaModel namePropertyMetaModel; + + public PropertyMetaModel typePropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/VoidTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VoidTypeMetaModel.java new file mode 100644 index 000000000..bb92f5613 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/VoidTypeMetaModel.java @@ -0,0 +1,10 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class VoidTypeMetaModel extends TypeMetaModel { + + VoidTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.VoidType.class, "VoidType", "com.github.javaparser.ast.type", false, false); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/WhileStmtMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/WhileStmtMetaModel.java new file mode 100644 index 000000000..83a122d9f --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/WhileStmtMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class WhileStmtMetaModel extends StatementMetaModel { + + WhileStmtMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.stmt.WhileStmt.class, "WhileStmt", "com.github.javaparser.ast.stmt", false, false); + } + + public PropertyMetaModel bodyPropertyMetaModel; + + public PropertyMetaModel conditionPropertyMetaModel; +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/metamodel/WildcardTypeMetaModel.java b/javaparser-core/src/main/java/com/github/javaparser/metamodel/WildcardTypeMetaModel.java new file mode 100644 index 000000000..0d4b9fc7e --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/metamodel/WildcardTypeMetaModel.java @@ -0,0 +1,14 @@ +package com.github.javaparser.metamodel; + +import java.util.Optional; + +public class WildcardTypeMetaModel extends TypeMetaModel { + + WildcardTypeMetaModel(Optional<BaseNodeMetaModel> superBaseNodeMetaModel) { + super(superBaseNodeMetaModel, com.github.javaparser.ast.type.WildcardType.class, "WildcardType", "com.github.javaparser.ast.type", false, false); + } + + public PropertyMetaModel extendedTypePropertyMetaModel; + + public PropertyMetaModel superTypePropertyMetaModel; +} |