From 61fe50886acfa37d9063ff3fcb34432c82dede8a Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Mon, 19 Feb 2018 21:04:36 +0100 Subject: Create functional language levels. Fix a random superfluous interface. --- .../com/github/javaparser/ParserConfiguration.java | 21 +++++++++++++++++++-- .../javaparser/ast/body/ConstructorDeclaration.java | 2 +- .../javaparser/version/Java10PostProcessor.java | 15 ++------------- .../javaparser/version/Java11PostProcessor.java | 11 ----------- 4 files changed, 22 insertions(+), 27 deletions(-) (limited to 'javaparser-core') diff --git a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java index deb8d4cdc..e4c9b22a4 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java @@ -42,19 +42,36 @@ import static com.github.javaparser.utils.Utils.assertNotNull; */ public class ParserConfiguration { public enum LanguageLevel { + /** Does no post processing or validation. Only for people wanting the fastest parsing. */ RAW(null, null), + /** Always points to the most popular Java version. */ + POPULAR(new Java8Validator(), null), + /** Always points to the newest Java version supported. */ + LATEST(new Java11Validator(), new Java11PostProcessor()), + /** Java 1.0 */ JAVA_1_0(new Java1_0Validator(), null), + /** Java 1.1 */ JAVA_1_1(new Java1_1Validator(), null), + /** Java 1.2 */ JAVA_1_2(new Java1_2Validator(), null), + /** Java 1.3 */ JAVA_1_3(new Java1_3Validator(), null), + /** Java 1.4 */ JAVA_1_4(new Java1_4Validator(), null), + /** Java 5 */ JAVA_5(new Java5Validator(), null), + /** Java 6 */ JAVA_6(new Java6Validator(), null), + /** Java 7 */ JAVA_7(new Java7Validator(), null), + /** Java 8 */ JAVA_8(new Java8Validator(), null), + /** Java 9 */ JAVA_9(new Java9Validator(), null), - JAVA_10_PREVIEW(null, new Java10PostProcessor()), - JAVA_11_PREVIEW(null, new Java11PostProcessor()); + /** Java 10 (work in progress) */ + JAVA_10_PREVIEW(new Java10Validator(), new Java10PostProcessor()), + /** Java 11 (work in progress) */ + JAVA_11_PREVIEW(new Java11Validator(), new Java11PostProcessor()); final Validator validator; final ParseResult.PostProcessor postProcessor; diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java index 3658d14f9..ab1dad9cb 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java @@ -55,7 +55,7 @@ import java.util.Optional; * * @author Julio Vilmar Gesser */ -public final class ConstructorDeclaration extends CallableDeclaration implements NodeWithBlockStmt, NodeWithAccessModifiers, NodeWithJavadoc, NodeWithDeclaration, NodeWithSimpleName, NodeWithParameters, NodeWithThrownExceptions, NodeWithTypeParameters, Resolvable { +public final class ConstructorDeclaration extends CallableDeclaration implements NodeWithBlockStmt, NodeWithAccessModifiers, NodeWithJavadoc, NodeWithSimpleName, NodeWithParameters, NodeWithThrownExceptions, NodeWithTypeParameters, Resolvable { private BlockStmt body; diff --git a/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java b/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java index 01251712e..7130870e7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java +++ b/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java @@ -1,23 +1,15 @@ package com.github.javaparser.version; -import com.github.javaparser.ParseResult; -import com.github.javaparser.ParserConfiguration; -import com.github.javaparser.ast.Node; import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.VarType; -import com.github.javaparser.ast.validator.Java10Validator; -import com.github.javaparser.ast.validator.ProblemReporter; -import static com.github.javaparser.ParseResult.*; +import static com.github.javaparser.ParseResult.PostProcessor; /** * Processes the generic AST into a Java 10 AST and validates it. */ public class Java10PostProcessor extends PostProcessors { - protected final PostProcessor java10Validator = new Java10Validator().postProcessor(); - protected final PostProcessor varNodeCreator = new PostProcessor() { - @Override - public void process(ParseResult result, ParserConfiguration configuration) { + protected final PostProcessor varNodeCreator = (result, configuration) -> result.getResult().ifPresent(node -> { node.findAll(ClassOrInterfaceType.class).forEach(n -> { if (n.getNameAsString().equals("var")) { @@ -25,11 +17,8 @@ public class Java10PostProcessor extends PostProcessors { } }); }); - } - }; public Java10PostProcessor() { add(varNodeCreator); - add(java10Validator); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java b/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java index 5d36efc05..004967edd 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java +++ b/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java @@ -1,18 +1,7 @@ package com.github.javaparser.version; -import com.github.javaparser.ParseResult; -import com.github.javaparser.ParserConfiguration; -import com.github.javaparser.ast.Node; -import com.github.javaparser.ast.validator.Java11Validator; -import com.github.javaparser.ast.validator.ProblemReporter; - /** * Processes the generic AST into a Java 10 AST and validates it. */ public class Java11PostProcessor extends Java10PostProcessor { - protected final ParseResult.PostProcessor java11Validator = new Java11Validator().postProcessor(); - - public Java11PostProcessor() { - replace(java10Validator, java11Validator); - } } -- cgit v1.2.3 From 8d247c646efd3940285f408c5a5066be588a3334 Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Tue, 20 Feb 2018 21:56:01 +0100 Subject: Validate positions of var --- .../javaparser/ast/validator/Java10Validator.java | 26 +++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) (limited to 'javaparser-core') diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java index b182e8db5..42e5c61c8 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java @@ -1,14 +1,38 @@ package com.github.javaparser.ast.validator; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.body.VariableDeclarator; +import com.github.javaparser.ast.expr.VariableDeclarationExpr; +import com.github.javaparser.ast.stmt.ForStmt; +import com.github.javaparser.ast.stmt.ForeachStmt; import com.github.javaparser.ast.type.VarType; +import java.util.Optional; + /** * This validator validates according to Java 10 syntax rules. */ public class Java10Validator extends Java9Validator { protected final Validator varOnlyOnLocalVariableDefinitionAndFor = new SingleNodeTypeValidator<>(VarType.class, (n, reporter) -> { - // TODO issue 1407 + Optional variableDeclarator = n.findParent(VariableDeclarator.class); + if (!variableDeclarator.isPresent()) { + reporter.report(n, "\"var\" is not allowed here."); + return; + } + variableDeclarator.ifPresent(vd -> { + Optional container = vd.getParentNode(); + if (!container.isPresent()) { + reporter.report(n, "\"var\" is not allowed here."); + return; + } + container.ifPresent(c -> { + boolean positionIsFine = c instanceof ForStmt || c instanceof ForeachStmt || c instanceof VariableDeclarationExpr; + if (!positionIsFine) { + reporter.report(n, "\"var\" is not allowed here."); + } + }); + }); }); public Java10Validator() { -- cgit v1.2.3 From 7aa7db5d738815da4e3a119311709dc50cc5640a Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Wed, 21 Feb 2018 21:20:10 +0100 Subject: Validate positions of var --- .../javaparser/ast/validator/Java10Validator.java | 29 +------ .../javaparser/ast/validator/Java11Validator.java | 6 ++ .../ast/validator/chunks/VarValidator.java | 93 ++++++++++++++++++++++ 3 files changed, 101 insertions(+), 27 deletions(-) create mode 100644 javaparser-core/src/main/java/com/github/javaparser/ast/validator/chunks/VarValidator.java (limited to 'javaparser-core') diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java index 42e5c61c8..c7fda2f46 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java @@ -1,39 +1,14 @@ package com.github.javaparser.ast.validator; -import com.github.javaparser.ast.Node; -import com.github.javaparser.ast.body.VariableDeclarator; -import com.github.javaparser.ast.expr.VariableDeclarationExpr; -import com.github.javaparser.ast.stmt.ForStmt; -import com.github.javaparser.ast.stmt.ForeachStmt; import com.github.javaparser.ast.type.VarType; - -import java.util.Optional; +import com.github.javaparser.ast.validator.chunks.VarValidator; /** * This validator validates according to Java 10 syntax rules. */ public class Java10Validator extends Java9Validator { - protected final Validator varOnlyOnLocalVariableDefinitionAndFor = new SingleNodeTypeValidator<>(VarType.class, (n, reporter) -> { - Optional variableDeclarator = n.findParent(VariableDeclarator.class); - if (!variableDeclarator.isPresent()) { - reporter.report(n, "\"var\" is not allowed here."); - return; - } - variableDeclarator.ifPresent(vd -> { - Optional container = vd.getParentNode(); - if (!container.isPresent()) { - reporter.report(n, "\"var\" is not allowed here."); - return; - } - container.ifPresent(c -> { - boolean positionIsFine = c instanceof ForStmt || c instanceof ForeachStmt || c instanceof VariableDeclarationExpr; - if (!positionIsFine) { - reporter.report(n, "\"var\" is not allowed here."); - } - }); - }); - }); + protected final Validator varOnlyOnLocalVariableDefinitionAndFor = new SingleNodeTypeValidator<>(VarType.class, new VarValidator(false)); public Java10Validator() { super(); diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java index d80577268..0eb879aa0 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java @@ -1,10 +1,16 @@ package com.github.javaparser.ast.validator; +import com.github.javaparser.ast.type.VarType; +import com.github.javaparser.ast.validator.chunks.VarValidator; + /** * This validator validates according to Java 11 syntax rules. */ public class Java11Validator extends Java10Validator { + protected final Validator varAlsoInLambdaParameters = new SingleNodeTypeValidator<>(VarType.class, new VarValidator(true)); + public Java11Validator() { super(); + replace(varOnlyOnLocalVariableDefinitionAndFor, varAlsoInLambdaParameters); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/chunks/VarValidator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/chunks/VarValidator.java new file mode 100644 index 000000000..19357e83c --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/chunks/VarValidator.java @@ -0,0 +1,93 @@ +package com.github.javaparser.ast.validator.chunks; + +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.body.Parameter; +import com.github.javaparser.ast.body.VariableDeclarator; +import com.github.javaparser.ast.expr.ArrayCreationExpr; +import com.github.javaparser.ast.expr.LambdaExpr; +import com.github.javaparser.ast.expr.NullLiteralExpr; +import com.github.javaparser.ast.expr.VariableDeclarationExpr; +import com.github.javaparser.ast.stmt.ExpressionStmt; +import com.github.javaparser.ast.stmt.ForStmt; +import com.github.javaparser.ast.stmt.ForeachStmt; +import com.github.javaparser.ast.type.VarType; +import com.github.javaparser.ast.validator.ProblemReporter; +import com.github.javaparser.ast.validator.TypedValidator; + +import java.util.Optional; + +public class VarValidator implements TypedValidator { + private boolean varAllowedInLambdaParameters; + + public VarValidator(boolean varAllowedInLambdaParameters) { + this.varAllowedInLambdaParameters = varAllowedInLambdaParameters; + } + + @Override + public void accept(VarType node, ProblemReporter reporter) { + // All allowed locations are within a VariableDeclaration inside a VariableDeclarationExpr inside something else. + Optional variableDeclarator = node.findParent(VariableDeclarator.class); + if (!variableDeclarator.isPresent()) { + // Java 11's var in lambda's + if (varAllowedInLambdaParameters) { + boolean valid = node + .findParent(Parameter.class) + .flatMap(Node::getParentNode) + .map((Node p) -> p instanceof LambdaExpr).orElse(false); + if (valid) { + return; + } + } + reportIllegalPosition(node, reporter); + return; + } + variableDeclarator.ifPresent(vd -> { + Optional variableDeclarationExpr = vd.getParentNode(); + if (!variableDeclarationExpr.isPresent()) { + reportIllegalPosition(node, reporter); + return; + } + variableDeclarationExpr.ifPresent(vdeNode -> { + if (!(vdeNode instanceof VariableDeclarationExpr)) { + reportIllegalPosition(node, reporter); + return; + } + VariableDeclarationExpr vde = (VariableDeclarationExpr) vdeNode; + if (vde.getVariables().size() > 1) { + reporter.report(vde, "\"var\" only takes a single variable."); + } + Optional container = vdeNode.getParentNode(); + if (!container.isPresent()) { + reportIllegalPosition(node, reporter); + return; + } + container.ifPresent(c -> { + boolean positionIsFine = c instanceof ForStmt || c instanceof ForeachStmt || c instanceof ExpressionStmt; + if (!positionIsFine) { + reportIllegalPosition(node, reporter); + } + // A local variable declaration ends up inside an ExpressionStmt. + if (c instanceof ExpressionStmt) { + if (!vd.getInitializer().isPresent()) { + reporter.report(node, "\"var\" needs an initializer."); + } + vd.getInitializer().ifPresent(initializer -> { + if (initializer instanceof NullLiteralExpr) { + reporter.report(node, "\"var\" cannot infer type from just null."); + } + if (initializer instanceof ArrayCreationExpr) { + reporter.report(node, "\"var\" cannot infer array types."); + } + }); + + } + }); + }); + }); + + } + + private void reportIllegalPosition(VarType n, ProblemReporter reporter) { + reporter.report(n, "\"var\" is not allowed here."); + } +} -- cgit v1.2.3 From 537828d8909778f063972567196bbb7771b8b662 Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Wed, 21 Feb 2018 21:55:40 +0100 Subject: Move bulk test to Java 10 --- .../src/main/java/com/github/javaparser/ParserConfiguration.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'javaparser-core') diff --git a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java index deb8d4cdc..7c4a0e8da 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java @@ -53,7 +53,7 @@ public class ParserConfiguration { JAVA_7(new Java7Validator(), null), JAVA_8(new Java8Validator(), null), JAVA_9(new Java9Validator(), null), - JAVA_10_PREVIEW(null, new Java10PostProcessor()), + JAVA_10(null, new Java10PostProcessor()), JAVA_11_PREVIEW(null, new Java11PostProcessor()); final Validator validator; @@ -181,7 +181,7 @@ public class ParserConfiguration { public ParserConfiguration setValidator(Validator validator) { // This whole method is a backwards compatability hack. if (validator instanceof Java10Validator) { - setLanguageLevel(LanguageLevel.JAVA_10_PREVIEW); + setLanguageLevel(LanguageLevel.JAVA_10); } else if (validator instanceof Java9Validator) { setLanguageLevel(LanguageLevel.JAVA_9); } else if (validator instanceof Java8Validator) { -- cgit v1.2.3 From 81f814434fc4d7c879bd18f3a6863a59ab34324b Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Wed, 21 Feb 2018 22:01:25 +0100 Subject: Add current language level --- .../src/main/java/com/github/javaparser/ParserConfiguration.java | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'javaparser-core') diff --git a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java index e4c9b22a4..293b41ab1 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java @@ -44,10 +44,12 @@ public class ParserConfiguration { public enum LanguageLevel { /** Does no post processing or validation. Only for people wanting the fastest parsing. */ RAW(null, null), - /** Always points to the most popular Java version. */ + /** The most used Java version. */ POPULAR(new Java8Validator(), null), - /** Always points to the newest Java version supported. */ - LATEST(new Java11Validator(), new Java11PostProcessor()), + /** The latest Java version that is available. */ + CURRENT(new Java8Validator(), null), + /** The newest Java features supported. */ + BLEEDING_EDGE(new Java11Validator(), new Java11PostProcessor()), /** Java 1.0 */ JAVA_1_0(new Java1_0Validator(), null), /** Java 1.1 */ -- cgit v1.2.3 From 967180d2ef9fc3d33c09cf9013e7640b63f69fce Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Wed, 21 Feb 2018 22:16:49 +0100 Subject: Set default language level to CURRENT --- .../com/github/javaparser/ParserConfiguration.java | 28 +++++++++++----------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'javaparser-core') diff --git a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java index 293b41ab1..41d981016 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java @@ -33,6 +33,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Optional; +import static com.github.javaparser.ParserConfiguration.LanguageLevel.*; import static com.github.javaparser.utils.Utils.assertNotNull; /** @@ -91,7 +92,7 @@ public class ParserConfiguration { private boolean lexicalPreservationEnabled = false; private SymbolResolver symbolResolver = null; private int tabSize = 1; - private LanguageLevel languageLevel; + private LanguageLevel languageLevel = CURRENT; private final List postProcessors = new ArrayList<>(); @@ -126,7 +127,6 @@ public class ParserConfiguration { } }) )); - setLanguageLevel(LanguageLevel.JAVA_8); } public boolean isAttributeComments() { @@ -200,29 +200,29 @@ public class ParserConfiguration { public ParserConfiguration setValidator(Validator validator) { // This whole method is a backwards compatability hack. if (validator instanceof Java10Validator) { - setLanguageLevel(LanguageLevel.JAVA_10_PREVIEW); + setLanguageLevel(JAVA_10_PREVIEW); } else if (validator instanceof Java9Validator) { - setLanguageLevel(LanguageLevel.JAVA_9); + setLanguageLevel(JAVA_9); } else if (validator instanceof Java8Validator) { - setLanguageLevel(LanguageLevel.JAVA_8); + setLanguageLevel(JAVA_8); } else if (validator instanceof Java7Validator) { - setLanguageLevel(LanguageLevel.JAVA_7); + setLanguageLevel(JAVA_7); } else if (validator instanceof Java6Validator) { - setLanguageLevel(LanguageLevel.JAVA_6); + setLanguageLevel(JAVA_6); } else if (validator instanceof Java5Validator) { - setLanguageLevel(LanguageLevel.JAVA_5); + setLanguageLevel(JAVA_5); } else if (validator instanceof Java1_4Validator) { - setLanguageLevel(LanguageLevel.JAVA_1_4); + setLanguageLevel(JAVA_1_4); } else if (validator instanceof Java1_3Validator) { - setLanguageLevel(LanguageLevel.JAVA_1_3); + setLanguageLevel(JAVA_1_3); } else if (validator instanceof Java1_2Validator) { - setLanguageLevel(LanguageLevel.JAVA_1_2); + setLanguageLevel(JAVA_1_2); } else if (validator instanceof Java1_1Validator) { - setLanguageLevel(LanguageLevel.JAVA_1_1); + setLanguageLevel(JAVA_1_1); } else if (validator instanceof Java1_0Validator) { - setLanguageLevel(LanguageLevel.JAVA_1_0); + setLanguageLevel(JAVA_1_0); } else if (validator instanceof NoProblemsValidator) { - setLanguageLevel(LanguageLevel.RAW); + setLanguageLevel(RAW); } return this; } -- cgit v1.2.3