From 0f20de0d621796315261e76a75f04d89d99be301 Mon Sep 17 00:00:00 2001 From: Alexander Weigl Date: Thu, 2 May 2024 12:18:02 +0200 Subject: [PATCH] add JML clauses in TypeCastingGenerator * new tests from issues found by JJBMC --- .../core/node/TypeCastingGenerator.java | 3 +- .../java/com/github/javaparser/JKIssue.java | 14 +- .../MissingParentSimpleExprClause.java | 4 + .../ast/jml/clauses/JmlCallableClause.java | 22 ++++ .../javaparser/ast/jml/clauses/JmlClause.java | 124 ++++++++++++++++++ .../ast/jml/clauses/JmlClauseLabel.java | 21 +++ .../ast/jml/clauses/JmlForallClause.java | 22 ++++ .../ast/jml/clauses/JmlMultiExprClause.java | 21 +++ .../ast/jml/clauses/JmlOldClause.java | 22 ++++ .../ast/jml/clauses/JmlSignalsClause.java | 22 ++++ .../ast/jml/clauses/JmlSignalsOnlyClause.java | 22 ++++ .../ast/jml/clauses/JmlSimpleExprClause.java | 24 +++- .../printer/ConcreteSyntaxModel.java | 12 +- .../lexicalpreservation/Difference.java | 4 +- .../LexicalPreservingPrinter.java | 7 +- .../logic/FunctionalInterfaceLogic.java | 4 +- .../logic/MethodResolutionLogic.java | 4 +- .../java/com/github/jml/FullExamplesTest.java | 18 +++ .../jml/resolution/NameResolutionTest.java | 2 +- 19 files changed, 351 insertions(+), 21 deletions(-) create mode 100644 javaparser-core-testing/src/test/test_sourcecode/MissingParentSimpleExprClause.java diff --git a/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/node/TypeCastingGenerator.java b/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/node/TypeCastingGenerator.java index 0cd16015c2..de2fb713a9 100644 --- a/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/node/TypeCastingGenerator.java +++ b/javaparser-core-generators/src/main/java/com/github/javaparser/generator/core/node/TypeCastingGenerator.java @@ -45,7 +45,8 @@ public class TypeCastingGenerator extends NodeGenerator { JavaParserMetaModel.typeMetaModel, JavaParserMetaModel.moduleDirectiveMetaModel, JavaParserMetaModel.bodyDeclarationMetaModel, - JavaParserMetaModel.commentMetaModel + JavaParserMetaModel.commentMetaModel, + JavaParserMetaModel.jmlClauseMetaModel ); public TypeCastingGenerator(SourceRoot sourceRoot) { diff --git a/javaparser-core-testing/src/test/java/com/github/javaparser/JKIssue.java b/javaparser-core-testing/src/test/java/com/github/javaparser/JKIssue.java index 92c543fec2..e62cbf6335 100644 --- a/javaparser-core-testing/src/test/java/com/github/javaparser/JKIssue.java +++ b/javaparser-core-testing/src/test/java/com/github/javaparser/JKIssue.java @@ -28,7 +28,7 @@ import java.nio.file.Paths; public class JKIssue { - @Test() + @Test void test() throws IOException { ParserConfiguration cfg = new ParserConfiguration(); cfg.setProcessJml(true); @@ -41,4 +41,16 @@ void test() throws IOException { Assertions.assertEquals(1, method.getContracts().get().size()); } } + + @Test + void test2() throws IOException { + ParserConfiguration cfg = new ParserConfiguration(); + cfg.setProcessJml(true); + JavaParser parser = new JavaParser(cfg); + CompilationUnit cu = parser.parse(Paths.get("src/test/test_sourcecode/MissingParentSimpleExprClause.java")) + .getResult().get(); + + var clause = cu.getType(0).getMethods().get(0).getContracts().get().get(0).getClauses().get(0).asJmlSimpleExprClause(); + Assertions.assertEquals(1, clause.getChildNodes().size()); + } } diff --git a/javaparser-core-testing/src/test/test_sourcecode/MissingParentSimpleExprClause.java b/javaparser-core-testing/src/test/test_sourcecode/MissingParentSimpleExprClause.java new file mode 100644 index 0000000000..6f99ac4aa9 --- /dev/null +++ b/javaparser-core-testing/src/test/test_sourcecode/MissingParentSimpleExprClause.java @@ -0,0 +1,4 @@ +public class JKIssueDoubleContract { + //@ ensures true; + private int test() {} +} \ No newline at end of file diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlCallableClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlCallableClause.java index 396402bdc6..bd56a790a2 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlCallableClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlCallableClause.java @@ -10,6 +10,9 @@ import com.github.javaparser.metamodel.JmlCallableClauseMetaModel; import com.github.javaparser.ast.Node; +import java.util.Optional; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (2/22/21) @@ -58,4 +61,23 @@ public JmlCallableClauseMetaModel getMetaModel() { public JmlClauseKind getKind() { return JmlClauseKind.CALLABLE; } + + @Override + public boolean isJmlCallableClause() { + return true; + } + + @Override + public JmlCallableClause asJmlCallableClause() { + return this; + } + + @Override + public Optional toJmlCallableClause() { + return Optional.of(this); + } + + public void ifJmlCallableClause(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClause.java index eacdf6ef73..5d1986af84 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClause.java @@ -13,6 +13,10 @@ import com.github.javaparser.metamodel.OptionalProperty; import java.util.Optional; +import static com.github.javaparser.utils.CodeGenerationUtils.f; + +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (2/21/21) @@ -116,4 +120,124 @@ public boolean replace(Node node, Node replacementNode) { } return super.replace(node, replacementNode); } + + public boolean isJmlCallableClause() { + return false; + } + + public JmlCallableClause asJmlCallableClause() { + throw new IllegalStateException(f("%s is not JmlCallableClause, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlCallableClause() { + return Optional.empty(); + } + + public void ifJmlCallableClause(Consumer action) { + } + + public boolean isJmlClauseLabel() { + return false; + } + + public JmlClauseLabel asJmlClauseLabel() { + throw new IllegalStateException(f("%s is not JmlClauseLabel, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlClauseLabel() { + return Optional.empty(); + } + + public void ifJmlClauseLabel(Consumer action) { + } + + public boolean isJmlForallClause() { + return false; + } + + public JmlForallClause asJmlForallClause() { + throw new IllegalStateException(f("%s is not JmlForallClause, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlForallClause() { + return Optional.empty(); + } + + public void ifJmlForallClause(Consumer action) { + } + + public boolean isJmlMultiExprClause() { + return false; + } + + public JmlMultiExprClause asJmlMultiExprClause() { + throw new IllegalStateException(f("%s is not JmlMultiExprClause, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlMultiExprClause() { + return Optional.empty(); + } + + public void ifJmlMultiExprClause(Consumer action) { + } + + public boolean isJmlOldClause() { + return false; + } + + public JmlOldClause asJmlOldClause() { + throw new IllegalStateException(f("%s is not JmlOldClause, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlOldClause() { + return Optional.empty(); + } + + public void ifJmlOldClause(Consumer action) { + } + + public boolean isJmlSignalsClause() { + return false; + } + + public JmlSignalsClause asJmlSignalsClause() { + throw new IllegalStateException(f("%s is not JmlSignalsClause, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlSignalsClause() { + return Optional.empty(); + } + + public void ifJmlSignalsClause(Consumer action) { + } + + public boolean isJmlSignalsOnlyClause() { + return false; + } + + public JmlSignalsOnlyClause asJmlSignalsOnlyClause() { + throw new IllegalStateException(f("%s is not JmlSignalsOnlyClause, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlSignalsOnlyClause() { + return Optional.empty(); + } + + public void ifJmlSignalsOnlyClause(Consumer action) { + } + + public boolean isJmlSimpleExprClause() { + return false; + } + + public JmlSimpleExprClause asJmlSimpleExprClause() { + throw new IllegalStateException(f("%s is not JmlSimpleExprClause, it is %s", this, this.getClass().getSimpleName())); + } + + public Optional toJmlSimpleExprClause() { + return Optional.empty(); + } + + public void ifJmlSimpleExprClause(Consumer action) { + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClauseLabel.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClauseLabel.java index a72272be6e..66c92aa350 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClauseLabel.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlClauseLabel.java @@ -18,6 +18,8 @@ import java.util.Optional; import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (2/21/21) @@ -185,4 +187,23 @@ public JmlClauseLabel setKind(final JmlClauseKind kind) { this.kind = kind; return this; } + + @Override + public boolean isJmlClauseLabel() { + return true; + } + + @Override + public JmlClauseLabel asJmlClauseLabel() { + return this; + } + + @Override + public Optional toJmlClauseLabel() { + return Optional.of(this); + } + + public void ifJmlClauseLabel(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlForallClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlForallClause.java index ed107e9c55..5c4f7b5417 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlForallClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlForallClause.java @@ -14,6 +14,9 @@ import com.github.javaparser.metamodel.JmlForallClauseMetaModel; import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.Optional; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (2/22/21) @@ -114,4 +117,23 @@ public JmlForallClauseMetaModel getMetaModel() { public JmlClauseKind getKind() { return JmlClauseKind.FORALL; } + + @Override + public boolean isJmlForallClause() { + return true; + } + + @Override + public JmlForallClause asJmlForallClause() { + return this; + } + + @Override + public Optional toJmlForallClause() { + return Optional.of(this); + } + + public void ifJmlForallClause(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlMultiExprClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlMultiExprClause.java index d1c54c19f0..bb4eedc342 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlMultiExprClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlMultiExprClause.java @@ -18,6 +18,8 @@ import java.util.Optional; import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (25.02.22) @@ -192,4 +194,23 @@ public JmlMultiExprClause setExpression(final NodeList expressions) setAsParentNodeOf(expressions); return this; } + + @Override + public boolean isJmlMultiExprClause() { + return true; + } + + @Override + public JmlMultiExprClause asJmlMultiExprClause() { + return this; + } + + @Override + public Optional toJmlMultiExprClause() { + return Optional.of(this); + } + + public void ifJmlMultiExprClause(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlOldClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlOldClause.java index 8e0980c49e..846094f4af 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlOldClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlOldClause.java @@ -13,6 +13,9 @@ import com.github.javaparser.metamodel.JmlOldClauseMetaModel; import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.Optional; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (12/12/21) @@ -101,4 +104,23 @@ public JmlOldClauseMetaModel getMetaModel() { public JmlClauseKind getKind() { return JmlClauseKind.OLD; } + + @Override + public boolean isJmlOldClause() { + return true; + } + + @Override + public JmlOldClause asJmlOldClause() { + return this; + } + + @Override + public Optional toJmlOldClause() { + return Optional.of(this); + } + + public void ifJmlOldClause(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsClause.java index b56b5b72b2..0457bf6768 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsClause.java @@ -15,6 +15,9 @@ import com.github.javaparser.metamodel.JmlSignalsClauseMetaModel; import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.Optional; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (2/21/21) @@ -133,4 +136,23 @@ public boolean replace(Node node, Node replacementNode) { public JmlSignalsClause clone() { return (JmlSignalsClause) accept(new CloneVisitor(), null); } + + @Override + public boolean isJmlSignalsClause() { + return true; + } + + @Override + public JmlSignalsClause asJmlSignalsClause() { + return this; + } + + @Override + public Optional toJmlSignalsClause() { + return Optional.of(this); + } + + public void ifJmlSignalsClause(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsOnlyClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsOnlyClause.java index 94415c6777..a1da71729a 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsOnlyClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSignalsOnlyClause.java @@ -14,6 +14,9 @@ import com.github.javaparser.metamodel.JmlSignalsOnlyClauseMetaModel; import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.Optional; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (2/21/21) @@ -131,4 +134,23 @@ public JmlSignalsOnlyClauseMetaModel getMetaModel() { public JmlClauseKind getKind() { return JmlClauseKind.SIGNALS_ONLY; } + + @Override + public boolean isJmlSignalsOnlyClause() { + return true; + } + + @Override + public JmlSignalsOnlyClause asJmlSignalsOnlyClause() { + return this; + } + + @Override + public Optional toJmlSignalsOnlyClause() { + return Optional.of(this); + } + + public void ifJmlSignalsOnlyClause(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSimpleExprClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSimpleExprClause.java index 21bdc1ca8a..5152600ba7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSimpleExprClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/jml/clauses/JmlSimpleExprClause.java @@ -18,6 +18,8 @@ import java.util.Optional; import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.function.Consumer; + /** * @author Alexander Weigl * @version 1 (2/21/21) @@ -55,9 +57,6 @@ public JmlSimpleExprClause(TokenRange range, JavaToken kind, SimpleName name, No this(range, JmlClauseKind.getKindByToken(kind), name, heaps, expr); } - public JmlSimpleExprClause(TokenRange orElse, JmlClauseKind kind, SimpleName name, NodeList heaps, NodeList expression) { - } - @Override @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") public boolean remove(Node node) { @@ -204,4 +203,23 @@ public JmlSimpleExprClause setExpression(final Expression expression) { public JmlSimpleExprClauseMetaModel getMetaModel() { return JavaParserMetaModel.jmlSimpleExprClauseMetaModel; } + + @Override + public boolean isJmlSimpleExprClause() { + return true; + } + + @Override + public JmlSimpleExprClause asJmlSimpleExprClause() { + return this; + } + + @Override + public Optional toJmlSimpleExprClause() { + return Optional.of(this); + } + + public void ifJmlSimpleExprClause(Consumer action) { + action.accept(this); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/ConcreteSyntaxModel.java b/javaparser-core/src/main/java/com/github/javaparser/printer/ConcreteSyntaxModel.java index 9db35b00b9..458d70f7c6 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/ConcreteSyntaxModel.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/ConcreteSyntaxModel.java @@ -104,9 +104,9 @@ private static CsmElement typeArguments() { // FIXME: we should introduce a derived property // FIXME: we should introduce a derived property // FIXME: we should introduce a derived property - concreteSyntaxModelByClass.// FIXME: we should introduce a derived property - put(// list(ObservableProperty.EXTRA_ARRAY_LEVELS), - VariableDeclarator.class, sequence(comment(), child(ObservableProperty.NAME), conditional(ObservableProperty.INITIALIZER, IS_PRESENT, sequence(space(), token(GeneratedJavaParserConstants.ASSIGN), space(), child(ObservableProperty.INITIALIZER))))); + // FIXME: we should introduce a derived property + concreteSyntaxModelByClass.// list(ObservableProperty.EXTRA_ARRAY_LEVELS), + put(VariableDeclarator.class, sequence(comment(), child(ObservableProperty.NAME), conditional(ObservableProperty.INITIALIZER, IS_PRESENT, sequence(space(), token(GeneratedJavaParserConstants.ASSIGN), space(), child(ObservableProperty.INITIALIZER))))); // / // / Expressions // / @@ -212,11 +212,11 @@ private static CsmElement typeArguments() { concreteSyntaxModelByClass.put(JmlClauseLabel.class, sequence(child(ObservableProperty.KIND), token(LPAREN), child(LABEL), token(RPAREN), space(), child(EXPRESSION), semicolon(), newline())); //space(), //space(), + //space(), concreteSyntaxModelByClass.//space(), put(//space(), - JmlCallableClause.class, //space(), - sequence(//child(EXPRESSION), - child(MODIFIERS), token(CALLABLE), semicolon())); + JmlCallableClause.class, //child(EXPRESSION), + sequence(child(MODIFIERS), token(CALLABLE), semicolon())); concreteSyntaxModelByClass.put(JmlClassExprDeclaration.class, sequence(child(MODIFIERS), attribute(KIND), space(), attribute(NAME), token(COLON), child(EXPRESSION), semicolon())); concreteSyntaxModelByClass.put(JmlBodyDeclaration.class, sequence()); concreteSyntaxModelByClass.put(JmlClassAccessibleDeclaration.class, sequence()); diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java index 2333400e4d..101bf62cb7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java @@ -548,8 +548,8 @@ private void applyRemovedDiffElement(RemovedGroup removedGroup, Removed removed, originalIndex = considerRemovingIndentation(nodeText, originalIndex); } } else if (removed.isToken() && originalElementIsToken && (// handle EOLs separately as their token kind might not be equal. This is because the 'removed' - removed.getTokenType() == ((TokenTextElement) originalElement).getTokenKind() || // element always has the current operating system's EOL as type - (((TokenTextElement) originalElement).getToken().getCategory().isEndOfLine() && removed.isNewLine()))) { + // element always has the current operating system's EOL as type + removed.getTokenType() == ((TokenTextElement) originalElement).getTokenKind() || (((TokenTextElement) originalElement).getToken().getCategory().isEndOfLine() && removed.isNewLine()))) { nodeText.removeElement(originalIndex); diffIndex++; } else if ((removed.isWhiteSpaceNotEol() || removed.getElement() instanceof CsmIndent || removed.getElement() instanceof CsmUnindent) && originalElement.isSpaceOrTab()) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java index cff3d132fc..d532d6f930 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java @@ -134,9 +134,10 @@ public void concretePropertyChange(Node observedNode, ObservableProperty propert NodeText nodeText = parentNode.map(parent -> getOrCreateNodeText(parentNode.get())).orElseGet(() -> getOrCreateNodeText(observedNode)); if (oldValue == null) { // this case corresponds to the addition of a comment - int index = // Find the position of the comment node and put in front of it the [...] - parentNode.isPresent() ? // - nodeText.findChild(observedNode) : 0; + // Find the position of the comment node and put in front of it the [...] + int // Find the position of the comment node and put in front of it the [...] + index = // + parentNode.isPresent() ? nodeText.findChild(observedNode) : 0; /* Add the same indentation to the comment as the previous node * for example if we want to add a comment on the body of the method declaration : * Actual code diff --git a/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/FunctionalInterfaceLogic.java b/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/FunctionalInterfaceLogic.java index 25fafe5058..ef52d0a053 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/FunctionalInterfaceLogic.java +++ b/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/FunctionalInterfaceLogic.java @@ -64,9 +64,9 @@ public static Optional getFunctionalMethod(ResolvedReferenceTypeDec Set // Remove methods inherited by Object: // Consider the case of Comparator which define equals. It would be considered a functional method. // TODO a functional interface can have multiple subsignature method with a return-type-substitutable + // TODO a functional interface can have multiple subsignature method with a return-type-substitutable methods = // TODO a functional interface can have multiple subsignature method with a return-type-substitutable - typeDeclaration.getAllMethods().stream().filter(m -> m.getDeclaration().isAbstract()).// TODO a functional interface can have multiple subsignature method with a return-type-substitutable - filter(m -> !isPublicMemberOfObject(m)).collect(Collectors.toSet()); + typeDeclaration.getAllMethods().stream().filter(m -> m.getDeclaration().isAbstract()).filter(m -> !isPublicMemberOfObject(m)).collect(Collectors.toSet()); // see https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.8 if (methods.size() == 0) { return Optional.empty(); diff --git a/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/MethodResolutionLogic.java b/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/MethodResolutionLogic.java index 14a58b97f3..f1ab06d0ab 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/MethodResolutionLogic.java +++ b/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/MethodResolutionLogic.java @@ -510,9 +510,9 @@ public static SymbolReference findMostApplicable(List List // Only consider methods with a matching name // Filters out duplicate ResolvedMethodDeclaration by their signature. // Filters out duplicate ResolvedMethodDeclaration by their signature. + // Checks if ResolvedMethodDeclaration is applicable to argumentsTypes. applicableMethods = // Checks if ResolvedMethodDeclaration is applicable to argumentsTypes. - methods.stream().// Checks if ResolvedMethodDeclaration is applicable to argumentsTypes. - filter(m -> m.getName().equals(name)).filter(distinctByKey(ResolvedMethodDeclaration::getQualifiedSignature)).filter((m) -> isApplicable(m, name, argumentsTypes, typeSolver, wildcardTolerance)).collect(Collectors.toList()); + methods.stream().filter(m -> m.getName().equals(name)).filter(distinctByKey(ResolvedMethodDeclaration::getQualifiedSignature)).filter((m) -> isApplicable(m, name, argumentsTypes, typeSolver, wildcardTolerance)).collect(Collectors.toList()); // If no applicable methods found, return as unsolved. if (applicableMethods.isEmpty()) { return SymbolReference.unsolved(); diff --git a/jmlparser-jml-tests/src/test/java/com/github/jml/FullExamplesTest.java b/jmlparser-jml-tests/src/test/java/com/github/jml/FullExamplesTest.java index 28d120f46b..8755108217 100644 --- a/jmlparser-jml-tests/src/test/java/com/github/jml/FullExamplesTest.java +++ b/jmlparser-jml-tests/src/test/java/com/github/jml/FullExamplesTest.java @@ -12,7 +12,9 @@ import com.github.javaparser.ast.jml.doc.JmlDocStmt; import com.github.javaparser.ast.jml.doc.JmlDocType; import com.github.javaparser.ast.visitor.VoidVisitorAdapter; +import com.github.javaparser.ast.visitor.VoidVisitorWithDefaults; import com.github.javaparser.jml.JmlDocSanitizer; +import com.google.common.truth.Truth; import org.junit.jupiter.api.*; import java.io.File; @@ -170,6 +172,22 @@ private void testParse(Path p) throws IOException { }); //storeProcessor.process(result, config); Assertions.assertTrue(result.isSuccessful(), "parsing failed"); + + testParentAndChild(result.getResult().get()); + } + + private void testParentAndChild(Node node) { + node.accept(new VoidVisitorWithDefaults<>() { + @Override + public void defaultAction(Node n, Object arg) { + final var parent = node.getParentNode(); + if (parent.isPresent()) { + final var childNodes = parent.get().getChildNodes(); + Assertions.assertFalse(childNodes.isEmpty()); + Truth.assertThat(childNodes).contains(node); + } + } + }, null); } private boolean isBlocked(Path it) { diff --git a/jmlparser-jml-tests/src/test/java/com/github/jml/resolution/NameResolutionTest.java b/jmlparser-jml-tests/src/test/java/com/github/jml/resolution/NameResolutionTest.java index fb7ee98a33..1e5894efe8 100644 --- a/jmlparser-jml-tests/src/test/java/com/github/jml/resolution/NameResolutionTest.java +++ b/jmlparser-jml-tests/src/test/java/com/github/jml/resolution/NameResolutionTest.java @@ -12,6 +12,7 @@ import com.github.javaparser.symbolsolver.JavaRefersToJmlException; import com.github.javaparser.symbolsolver.JavaSymbolSolver; import com.github.javaparser.symbolsolver.resolution.typesolvers.ClassLoaderTypeSolver; +import com.github.javaparser.symbolsolver.resolution.typesolvers.TypeSolverBuilder; import com.google.common.truth.Truth; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; @@ -133,7 +134,6 @@ private void loadAndResolveAll(String name) throws IOException { Assertions.fail("Errors during parsing"); } - final ResolveAllVisitor v = new ResolveAllVisitor(); cu.getResult().get().accept(v, null);