From 6dd1c7e08043aae6a1e4cee65df7d88765240dd5 Mon Sep 17 00:00:00 2001 From: Tobias Date: Tue, 12 Dec 2023 19:35:19 +0100 Subject: [PATCH 01/22] add interface and classes for properties to ignore during equivalence check --- .../uka/ilkd/key/logic/EqualsModProperty.java | 34 +++ .../logic/IrrelevantTermLabelsProperty.java | 57 +++++ .../key/logic/ProofIrrelevancyProperty.java | 17 ++ .../ilkd/key/logic/RenamingTermProperty.java | 198 ++++++++++++++++++ .../main/java/de/uka/ilkd/key/logic/Term.java | 2 +- .../ilkd/key/logic/TermLabelsProperty.java | 40 ++++ .../de/uka/ilkd/key/logic/TermProperty.java | 37 ++++ 7 files changed, 384 insertions(+), 1 deletion(-) create mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/EqualsModProperty.java create mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/IrrelevantTermLabelsProperty.java create mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java create mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/RenamingTermProperty.java create mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/TermLabelsProperty.java create mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/TermProperty.java diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/EqualsModProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/EqualsModProperty.java new file mode 100644 index 00000000000..653009ce466 --- /dev/null +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/EqualsModProperty.java @@ -0,0 +1,34 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic; + +/** + * Interface to check for equality ignoring given properties and to compute according hash codes. + * + * @author Tobias Reinhold + */ +public interface EqualsModProperty { + + /** + * Checks whether this object is equal to o modulo the property described by + * property + * + * @param property the property to be ignored in the equality check + * @param o the object that is checked for equality + * @return whether this object is equal to o + */ + default Boolean equalsModProperty(TermProperty property, Object o) { + return property.equalsModThisProperty(this, o); + } + + /** + * Computes the hash code according to the given ignored property. + * + * @param property the ignored property according to which the hash code is computed + * @return the hash code of this object + */ + default int hashCodeModProperty(TermProperty property) { + return property.hashCodeModThisProperty(this); + } +} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/IrrelevantTermLabelsProperty.java new file mode 100644 index 00000000000..05c04f67845 --- /dev/null +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/IrrelevantTermLabelsProperty.java @@ -0,0 +1,57 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic; + +import de.uka.ilkd.key.logic.label.TermLabel; + +import org.key_project.util.collection.ImmutableArray; + +public class IrrelevantTermLabelsProperty implements TermProperty { + @Override + public Boolean equalsModThisProperty(Term term, Object o) { + if (o == term) { + return true; + } + + if (!(o instanceof Term other)) { + return false; + } + + if (!(term.op().equals(other.op()) && term.boundVars().equals(other.boundVars()) + && term.javaBlock().equals(other.javaBlock()))) { + return false; + } + + ImmutableArray termLabels = term.getLabels(); + ImmutableArray otherLabels = other.getLabels(); + for (TermLabel label : termLabels) { + if (label.isProofRelevant() && !otherLabels.contains(label)) { + return false; + } + } + + for (TermLabel label : otherLabels) { + if (label.isProofRelevant() && !termLabels.contains(label)) { + return false; + } + } + + ImmutableArray termSubs = term.subs(); + ImmutableArray otherSubs = other.subs(); + final int numOfSubs = termSubs.size(); + for (int i = 0; i < numOfSubs; ++i) { + if (!termSubs.get(i).equalsModIrrelevantTermLabels(otherSubs.get(i))) { + return false; + } + } + + return true; + } + + @Override + public int hashCodeModThisProperty(Term term) { + throw new UnsupportedOperationException( + "Hashing of terms modulo irrelevant term labels not yet implemented!"); + } +} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java new file mode 100644 index 00000000000..387a710fdba --- /dev/null +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java @@ -0,0 +1,17 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic; + +public class ProofIrrelevancyProperty implements TermProperty { + @Override + public Boolean equalsModThisProperty(Term term, Object o) { + return null; + } + + @Override + public int hashCodeModThisProperty(Term term) { + throw new UnsupportedOperationException( + "Hashing of terms modulo proof irrelevancy not yet implemented!"); + } +} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/RenamingTermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/RenamingTermProperty.java new file mode 100644 index 00000000000..b6683e5faf9 --- /dev/null +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/RenamingTermProperty.java @@ -0,0 +1,198 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic; + +import de.uka.ilkd.key.java.NameAbstractionTable; +import de.uka.ilkd.key.logic.op.Operator; +import de.uka.ilkd.key.logic.op.ProgramVariable; +import de.uka.ilkd.key.logic.op.QuantifiableVariable; +import de.uka.ilkd.key.logic.op.SchemaVariable; + +import org.key_project.util.collection.ImmutableList; +import org.key_project.util.collection.ImmutableSLList; + + +public class RenamingTermProperty implements TermProperty { + @Override + public Boolean equalsModThisProperty(Term term, Object o) { + if (o == term) { + return true; + } + if (!(o instanceof Term t)) { + return false; + } + return unifyHelp(term, t, ImmutableSLList.nil(), + ImmutableSLList.nil(), null); + } + + @Override + public int hashCodeModThisProperty(Term term) { + throw new UnsupportedOperationException( + "Hashing of terms modulo renaming not yet implemented!"); + } + + // + // equals modulo renaming logic + + + /** + * compare two quantifiable variables if they are equal modulo renaming + * + * @param ownVar first QuantifiableVariable to be compared + * @param cmpVar second QuantifiableVariable to be compared + * @param ownBoundVars variables bound above the current position + * @param cmpBoundVars variables bound above the current position + */ + private static boolean compareBoundVariables(QuantifiableVariable ownVar, + QuantifiableVariable cmpVar, ImmutableList ownBoundVars, + ImmutableList cmpBoundVars) { + + final int ownNum = indexOf(ownVar, ownBoundVars); + final int cmpNum = indexOf(cmpVar, cmpBoundVars); + + if (ownNum == -1 && cmpNum == -1) { + // if both variables are not bound the variables have to be the + // same object + return ownVar == cmpVar; + } + + // otherwise the variables have to be bound at the same point (and both + // be bound) + return ownNum == cmpNum; + } + + /** + * @return the index of the first occurrence of var in list, or + * -1 if the variable is not an element of the list + */ + private static int indexOf(QuantifiableVariable var, ImmutableList list) { + int res = 0; + while (!list.isEmpty()) { + if (list.head() == var) { + return res; + } + ++res; + list = list.tail(); + } + return -1; + } + + /** + * Compares two terms modulo bound renaming + * + * @param t0 the first term + * @param t1 the second term + * @param ownBoundVars variables bound above the current position + * @param cmpBoundVars variables bound above the current position + * @return true is returned iff the terms are equal modulo bound renaming + */ + private boolean unifyHelp(Term t0, Term t1, ImmutableList ownBoundVars, + ImmutableList cmpBoundVars, NameAbstractionTable nat) { + + if (t0 == t1 && ownBoundVars.equals(cmpBoundVars)) { + return true; + } + + final Operator op0 = t0.op(); + + if (op0 instanceof QuantifiableVariable) { + return handleQuantifiableVariable(t0, t1, ownBoundVars, cmpBoundVars); + } + + final Operator op1 = t1.op(); + + if (!(op0 instanceof ProgramVariable) && op0 != op1) { + return false; + } + + if (t0.sort() != t1.sort() || t0.arity() != t1.arity()) { + return false; + } + + nat = handleJava(t0, t1, nat); + if (nat == FAILED) { + return false; + } + + return descendRecursively(t0, t1, ownBoundVars, cmpBoundVars, nat); + } + + private boolean handleQuantifiableVariable(Term t0, Term t1, + ImmutableList ownBoundVars, + ImmutableList cmpBoundVars) { + return (t1.op() instanceof QuantifiableVariable) + && compareBoundVariables((QuantifiableVariable) t0.op(), + (QuantifiableVariable) t1.op(), ownBoundVars, cmpBoundVars); + } + + /** + * used to encode that handleJava results in an unsatisfiable constraint (faster than + * using exceptions) + */ + private static final NameAbstractionTable FAILED = new NameAbstractionTable(); + + private static NameAbstractionTable handleJava(Term t0, Term t1, NameAbstractionTable nat) { + + if (!t0.javaBlock().isEmpty() || !t1.javaBlock().isEmpty()) { + nat = checkNat(nat); + if (!t0.javaBlock().equalsModRenaming(t1.javaBlock(), nat)) { + return FAILED; + } + } + + if (!(t0.op() instanceof SchemaVariable) && t0.op() instanceof ProgramVariable) { + if (!(t1.op() instanceof ProgramVariable)) { + return FAILED; + } + nat = checkNat(nat); + if (!((ProgramVariable) t0.op()).equalsModRenaming((ProgramVariable) t1.op(), nat)) { + return FAILED; + } + } + + return nat; + } + + private boolean descendRecursively(Term t0, Term t1, + ImmutableList ownBoundVars, + ImmutableList cmpBoundVars, NameAbstractionTable nat) { + + for (int i = 0; i < t0.arity(); i++) { + ImmutableList subOwnBoundVars = ownBoundVars; + ImmutableList subCmpBoundVars = cmpBoundVars; + + if (t0.varsBoundHere(i).size() != t1.varsBoundHere(i).size()) { + return false; + } + for (int j = 0; j < t0.varsBoundHere(i).size(); j++) { + final QuantifiableVariable ownVar = t0.varsBoundHere(i).get(j); + final QuantifiableVariable cmpVar = t1.varsBoundHere(i).get(j); + if (ownVar.sort() != cmpVar.sort()) { + return false; + } + + subOwnBoundVars = subOwnBoundVars.prepend(ownVar); + subCmpBoundVars = subCmpBoundVars.prepend(cmpVar); + } + + boolean newConstraint = + unifyHelp(t0.sub(i), t1.sub(i), subOwnBoundVars, subCmpBoundVars, nat); + + if (!newConstraint) { + return false; + } + } + + return true; + } + + private static NameAbstractionTable checkNat(NameAbstractionTable nat) { + if (nat == null) { + return new NameAbstractionTable(); + } + return nat; + } + // end of equals modulo renaming logic + +} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java index 35ab6425c61..a3841ff2bc6 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java @@ -39,7 +39,7 @@ * Term supports the {@link Visitor} pattern. Two different visit strategies are currently * supported: {@link Term#execPostOrder(Visitor)} and {@link Term#execPreOrder(Visitor)}. */ -public interface Term extends SVSubstitute, Sorted, EqualsModProofIrrelevancy { +public interface Term extends SVSubstitute, Sorted, EqualsModProperty, EqualsModProofIrrelevancy { /** * The top operator (e.g., in "A and B" this is "and", in f(x,y) it is "f"). diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermLabelsProperty.java new file mode 100644 index 00000000000..c71320971bc --- /dev/null +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermLabelsProperty.java @@ -0,0 +1,40 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic; + +import org.key_project.util.collection.ImmutableArray; + +public class TermLabelsProperty implements TermProperty { + @Override + public Boolean equalsModThisProperty(Term term, Object o) { + if (o == term) { + return true; + } + + if (!(o instanceof Term other)) { + return false; + } + + if (!(term.op().equals(other.op()) && term.boundVars().equals(other.boundVars()) + && term.javaBlock().equals(other.javaBlock()))) { + return false; + } + + final ImmutableArray termSubs = term.subs(); + final ImmutableArray otherSubs = other.subs(); + final int numOfSubs = termSubs.size(); + for (int i = 0; i < numOfSubs; ++i) { + if (!termSubs.get(i).equalsModTermLabels(otherSubs.get(i))) { + return false; + } + } + return true; + } + + @Override + public int hashCodeModThisProperty(Term term) { + throw new UnsupportedOperationException( + "Hashing of terms modulo term labels not yet implemented!"); + } +} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermProperty.java new file mode 100644 index 00000000000..da647ec9ad3 --- /dev/null +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermProperty.java @@ -0,0 +1,37 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic; + +/** + *

+ * This interface is used for equality checks and hashing modulo a certain property. + *

+ * Objects of classes implementing this interface are given to the methods in + * {@link EqualsModProperty} as parameters + * to unify equality checks and hashing modulo different properties. + * + * @author Tobias Reinhold + */ +public interface TermProperty { + /** + * Checks term and other for equality ignoring a certain property. + * + * @param term the term to check for equality with other + * @param other the object to check for equality with term + * @return whether term and other are equal ignoring a certain + * property + */ + Boolean equalsModThisProperty(Term term, Object o); + + /** + * Computes the hash code of the term> in a context where + * {@link this#equalsModThisProperty(Term, Object)} is used as an equality check, so that it can + * be used in, e.g., + * a HashMap. + * + * @param term the term to compute the hash code for + * @return the hash code of term + */ + int hashCodeModThisProperty(Term term); +} From e817c66420335fbfd2cd873dbeaf8fb90e9b0ae9 Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Tue, 12 Dec 2023 23:46:07 +0100 Subject: [PATCH 02/22] move classes concerning equality checks to new package and create singleton access pattern --- .../key/logic/ProofIrrelevancyProperty.java | 17 ---- .../IrrelevantTermLabelsProperty.java | 27 ++++-- .../equality/ProofIrrelevancyProperty.java | 88 +++++++++++++++++++ .../{ => equality}/RenamingTermProperty.java | 22 +++-- .../TermEqualsModProperty.java} | 17 ++-- .../{ => equality}/TermLabelsProperty.java | 17 +++- .../logic/{ => equality}/TermProperty.java | 22 ++--- 7 files changed, 160 insertions(+), 50 deletions(-) delete mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java rename key.core/src/main/java/de/uka/ilkd/key/logic/{ => equality}/IrrelevantTermLabelsProperty.java (63%) create mode 100644 key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java rename key.core/src/main/java/de/uka/ilkd/key/logic/{ => equality}/RenamingTermProperty.java (90%) rename key.core/src/main/java/de/uka/ilkd/key/logic/{EqualsModProperty.java => equality/TermEqualsModProperty.java} (67%) rename key.core/src/main/java/de/uka/ilkd/key/logic/{ => equality}/TermLabelsProperty.java (68%) rename key.core/src/main/java/de/uka/ilkd/key/logic/{ => equality}/TermProperty.java (60%) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java deleted file mode 100644 index 387a710fdba..00000000000 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/ProofIrrelevancyProperty.java +++ /dev/null @@ -1,17 +0,0 @@ -/* This file is part of KeY - https://key-project.org - * KeY is licensed under the GNU General Public License Version 2 - * SPDX-License-Identifier: GPL-2.0-only */ -package de.uka.ilkd.key.logic; - -public class ProofIrrelevancyProperty implements TermProperty { - @Override - public Boolean equalsModThisProperty(Term term, Object o) { - return null; - } - - @Override - public int hashCodeModThisProperty(Term term) { - throw new UnsupportedOperationException( - "Hashing of terms modulo proof irrelevancy not yet implemented!"); - } -} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java similarity index 63% rename from key.core/src/main/java/de/uka/ilkd/key/logic/IrrelevantTermLabelsProperty.java rename to key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index 05c04f67845..a5d9fe42b5c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -1,13 +1,29 @@ /* This file is part of KeY - https://key-project.org * KeY is licensed under the GNU General Public License Version 2 * SPDX-License-Identifier: GPL-2.0-only */ -package de.uka.ilkd.key.logic; +package de.uka.ilkd.key.logic.equality; +import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.label.TermLabel; import org.key_project.util.collection.ImmutableArray; public class IrrelevantTermLabelsProperty implements TermProperty { + /** + * The single instance of this property. + */ + public static final IrrelevantTermLabelsProperty IRRELEVANT_TERM_LABELS_PROPERTY = + new IrrelevantTermLabelsProperty(); + + /** + * This constructor is private as a single instance of this class should be shared. The instance + * can be accessed + * through {@link IrrelevantTermLabelsProperty#IRRELEVANT_TERM_LABELS_PROPERTY} and is used as a + * parameter for + * {@link TermProperty#equalsModThisProperty(Term, Object)}. + */ + private IrrelevantTermLabelsProperty() {} + @Override public Boolean equalsModThisProperty(Term term, Object o) { if (o == term) { @@ -23,22 +39,21 @@ public Boolean equalsModThisProperty(Term term, Object o) { return false; } - ImmutableArray termLabels = term.getLabels(); - ImmutableArray otherLabels = other.getLabels(); + final ImmutableArray termLabels = term.getLabels(); + final ImmutableArray otherLabels = other.getLabels(); for (TermLabel label : termLabels) { if (label.isProofRelevant() && !otherLabels.contains(label)) { return false; } } - for (TermLabel label : otherLabels) { if (label.isProofRelevant() && !termLabels.contains(label)) { return false; } } - ImmutableArray termSubs = term.subs(); - ImmutableArray otherSubs = other.subs(); + final ImmutableArray termSubs = term.subs(); + final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { if (!termSubs.get(i).equalsModIrrelevantTermLabels(otherSubs.get(i))) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java new file mode 100644 index 00000000000..7c301b178a1 --- /dev/null +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -0,0 +1,88 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic.equality; + +import java.util.Objects; + +import de.uka.ilkd.key.logic.Term; +import de.uka.ilkd.key.logic.label.TermLabel; + +import org.key_project.util.EqualsModProofIrrelevancyUtil; +import org.key_project.util.collection.ImmutableArray; + +public class ProofIrrelevancyProperty implements TermProperty { + /** + * The single instance of this property. + */ + public static final ProofIrrelevancyProperty PROOF_IRRELEVANCY_PROPERTY = + new ProofIrrelevancyProperty(); + + /** + * This constructor is private as a single instance of this class should be shared. The instance + * can be accessed + * through {@link ProofIrrelevancyProperty#PROOF_IRRELEVANCY_PROPERTY} and is used as a + * parameter for + * {@link TermProperty#equalsModThisProperty(Term, Object)}. + */ + private ProofIrrelevancyProperty() {} + + @Override + public Boolean equalsModThisProperty(Term term, Object o) { + if (o == term) { + return true; + } + + if (!(o instanceof Term other)) { + return false; + } + + final boolean opResult = term.op().equalsModProofIrrelevancy(other.op()); + if (!(opResult + && EqualsModProofIrrelevancyUtil.compareImmutableArrays(term.boundVars(), + other.boundVars()) + && term.javaBlock().equalsModProofIrrelevancy(other.javaBlock()))) { + return false; + } + + final ImmutableArray termLabels = term.getLabels(); + final ImmutableArray otherLabels = other.getLabels(); + for (TermLabel label : termLabels) { + if (label.isProofRelevant() && !otherLabels.contains(label)) { + return false; + } + } + for (TermLabel label : otherLabels) { + if (label.isProofRelevant() && !termLabels.contains(label)) { + return false; + } + } + + final ImmutableArray termSubs = term.subs(); + final ImmutableArray otherSubs = other.subs(); + final int numOfSubs = termSubs.size(); + for (int i = 0; i < numOfSubs; ++i) { + if (!termSubs.get(i).equalsModProofIrrelevancy(otherSubs.get(i))) { + return false; + } + } + + return true; + } + + @Override + public int hashCodeModThisProperty(Term term) { + int hashcode2 = -1; // this line is just so the code compiles + if (hashcode2 == -1) { + // compute into local variable first to be thread-safe. + hashcode2 = Objects.hash(term.op(), + EqualsModProofIrrelevancyUtil + .hashCodeIterable(term.subs()), + EqualsModProofIrrelevancyUtil.hashCodeIterable(term.boundVars()), term.javaBlock()); + if (hashcode2 == -1) { + hashcode2 = 0; + } + } + return hashcode2; + } +} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/RenamingTermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java similarity index 90% rename from key.core/src/main/java/de/uka/ilkd/key/logic/RenamingTermProperty.java rename to key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java index b6683e5faf9..ecbd7423260 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/RenamingTermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java @@ -1,9 +1,10 @@ /* This file is part of KeY - https://key-project.org * KeY is licensed under the GNU General Public License Version 2 * SPDX-License-Identifier: GPL-2.0-only */ -package de.uka.ilkd.key.logic; +package de.uka.ilkd.key.logic.equality; import de.uka.ilkd.key.java.NameAbstractionTable; +import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.logic.op.ProgramVariable; import de.uka.ilkd.key.logic.op.QuantifiableVariable; @@ -14,6 +15,19 @@ public class RenamingTermProperty implements TermProperty { + /** + * The single instance of this property. + */ + public static final RenamingTermProperty RENAMING_TERM_PROPERTY = new RenamingTermProperty(); + + /** + * This constructor is private as a single instance of this class should be shared. The instance + * can be accessed + * through {@link RenamingTermProperty#RENAMING_TERM_PROPERTY} and is used as a parameter for + * {@link TermProperty#equalsModThisProperty(Term, Object)}. + */ + private RenamingTermProperty() {} + @Override public Boolean equalsModThisProperty(Term term, Object o) { if (o == term) { @@ -32,12 +46,10 @@ public int hashCodeModThisProperty(Term term) { "Hashing of terms modulo renaming not yet implemented!"); } - // // equals modulo renaming logic - /** - * compare two quantifiable variables if they are equal modulo renaming + * Compare two quantifiable variables if they are equal modulo renaming. * * @param ownVar first QuantifiableVariable to be compared * @param cmpVar second QuantifiableVariable to be compared @@ -79,7 +91,7 @@ private static int indexOf(QuantifiableVariable var, ImmutableListo modulo the property described by - * property + * property. * * @param property the property to be ignored in the equality check * @param o the object that is checked for equality * @return whether this object is equal to o */ - default Boolean equalsModProperty(TermProperty property, Object o) { - return property.equalsModThisProperty(this, o); - } + boolean equalsModProperty(TermProperty property, Object o); /** * Computes the hash code according to the given ignored property. @@ -28,7 +27,5 @@ default Boolean equalsModProperty(TermProperty property, Object o) { * @param property the ignored property according to which the hash code is computed * @return the hash code of this object */ - default int hashCodeModProperty(TermProperty property) { - return property.hashCodeModThisProperty(this); - } + int hashCodeModProperty(TermProperty property); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java similarity index 68% rename from key.core/src/main/java/de/uka/ilkd/key/logic/TermLabelsProperty.java rename to key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java index c71320971bc..484930d3692 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java @@ -1,11 +1,26 @@ /* This file is part of KeY - https://key-project.org * KeY is licensed under the GNU General Public License Version 2 * SPDX-License-Identifier: GPL-2.0-only */ -package de.uka.ilkd.key.logic; +package de.uka.ilkd.key.logic.equality; + +import de.uka.ilkd.key.logic.Term; import org.key_project.util.collection.ImmutableArray; public class TermLabelsProperty implements TermProperty { + /** + * The single instance of this property. + */ + public static final TermLabelsProperty TERM_LABELS_PROPERTY = new TermLabelsProperty(); + + /** + * This constructor is private as a single instance of this class should be shared. The instance + * can be accessed + * through {@link TermLabelsProperty#TERM_LABELS_PROPERTY} and is used as a parameter for + * {@link TermProperty#equalsModThisProperty(Term, Object)}. + */ + private TermLabelsProperty() {} + @Override public Boolean equalsModThisProperty(Term term, Object o) { if (o == term) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java similarity index 60% rename from key.core/src/main/java/de/uka/ilkd/key/logic/TermProperty.java rename to key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java index da647ec9ad3..4b1e1563883 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java @@ -1,15 +1,17 @@ /* This file is part of KeY - https://key-project.org * KeY is licensed under the GNU General Public License Version 2 * SPDX-License-Identifier: GPL-2.0-only */ -package de.uka.ilkd.key.logic; +package de.uka.ilkd.key.logic.equality; + +import de.uka.ilkd.key.logic.Term; /** *

- * This interface is used for equality checks and hashing modulo a certain property. + * This interface is used for equality checks and hashing modulo a certain property on terms. *

* Objects of classes implementing this interface are given to the methods in - * {@link EqualsModProperty} as parameters - * to unify equality checks and hashing modulo different properties. + * {@link TermEqualsModProperty} as parameters to unify equality checks and hashing modulo different + * properties. * * @author Tobias Reinhold */ @@ -17,21 +19,19 @@ public interface TermProperty { /** * Checks term and other for equality ignoring a certain property. * - * @param term the term to check for equality with other - * @param other the object to check for equality with term - * @return whether term and other are equal ignoring a certain - * property + * @param term the term to check for equality with o + * @param o the object to check for equality with term + * @return whether term and o are equal ignoring a certain property */ Boolean equalsModThisProperty(Term term, Object o); /** * Computes the hash code of the term> in a context where * {@link this#equalsModThisProperty(Term, Object)} is used as an equality check, so that it can - * be used in, e.g., - * a HashMap. + * be used in, e.g., a HashMap. * * @param term the term to compute the hash code for - * @return the hash code of term + * @return the hash code of term ignoring a certain property */ int hashCodeModThisProperty(Term term); } From 34d49286ffec2a9ffb93a8e72b5a7a1f9239a240 Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Tue, 12 Dec 2023 23:47:57 +0100 Subject: [PATCH 03/22] start adding new equality check method to Term and TermImpl --- .../src/main/java/de/uka/ilkd/key/logic/Term.java | 4 +++- .../src/main/java/de/uka/ilkd/key/logic/TermImpl.java | 11 +++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java index a3841ff2bc6..8594448d0ff 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java @@ -3,6 +3,7 @@ * SPDX-License-Identifier: GPL-2.0-only */ package de.uka.ilkd.key.logic; +import de.uka.ilkd.key.logic.equality.TermEqualsModProperty; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.logic.op.QuantifiableVariable; @@ -39,7 +40,8 @@ * Term supports the {@link Visitor} pattern. Two different visit strategies are currently * supported: {@link Term#execPostOrder(Visitor)} and {@link Term#execPreOrder(Visitor)}. */ -public interface Term extends SVSubstitute, Sorted, EqualsModProperty, EqualsModProofIrrelevancy { +public interface Term + extends SVSubstitute, Sorted, TermEqualsModProperty, EqualsModProofIrrelevancy { /** * The top operator (e.g., in "A and B" this is "and", in f(x,y) it is "f"). diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java index 66b8d9de5e3..73017b8ff42 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java @@ -8,6 +8,7 @@ import de.uka.ilkd.key.java.NameAbstractionTable; import de.uka.ilkd.key.java.PositionInfo; +import de.uka.ilkd.key.logic.equality.TermProperty; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.op.Modality; import de.uka.ilkd.key.logic.op.Operator; @@ -494,6 +495,16 @@ public boolean equals(Object o) { && boundVars.equals(t.boundVars) && javaBlock.equals(t.javaBlock); } + @Override + public boolean equalsModProperty(TermProperty property, Object o) { + return property.equalsModThisProperty(this, o); + } + + @Override + public int hashCodeModProperty(TermProperty property) { + return property.hashCodeModThisProperty(this); + } + @Override public boolean equalsModIrrelevantTermLabels(Object o) { if (o == this) { From 65b04354f5375c65bbc8243eb58ec509b71dcfea Mon Sep 17 00:00:00 2001 From: Tobias Date: Sat, 16 Dec 2023 15:44:32 +0100 Subject: [PATCH 04/22] remove equals methods from Term and move their doc to respective classes --- .../main/java/de/uka/ilkd/key/logic/Term.java | 32 +------------------ .../IrrelevantTermLabelsProperty.java | 10 ++++++ .../logic/equality/RenamingTermProperty.java | 8 +++++ .../logic/equality/TermLabelsProperty.java | 9 ++++++ 4 files changed, 28 insertions(+), 31 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java index 8594448d0ff..eb0cdf3c9dc 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java @@ -10,7 +10,6 @@ import de.uka.ilkd.key.logic.op.SVSubstitute; import de.uka.ilkd.key.logic.sort.Sort; -import org.key_project.util.EqualsModProofIrrelevancy; import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; @@ -41,7 +40,7 @@ * supported: {@link Term#execPostOrder(Visitor)} and {@link Term#execPreOrder(Visitor)}. */ public interface Term - extends SVSubstitute, Sorted, TermEqualsModProperty, EqualsModProofIrrelevancy { + extends SVSubstitute, Sorted, TermEqualsModProperty { /** * The top operator (e.g., in "A and B" this is "and", in f(x,y) it is "f"). @@ -122,15 +121,6 @@ public interface Term */ void execPreOrder(Visitor visitor); - /** - * Compares if two terms are equal modulo bound renaming - * - * @param o another term, - * @return true iff the given term has the same values in operator, sort, arity, varsBoundHere - * and javaBlock as this object modulo bound renaming - */ - boolean equalsModRenaming(Term o); - /** * returns true if the term is labeled */ @@ -173,26 +163,6 @@ public interface Term */ boolean containsJavaBlockRecursive(); - /** - * Checks if {@code o} is a term syntactically equal to this one, except for some irrelevant - * labels. - * - * @param o an object - * @return {@code true} iff {@code o} is a term syntactically equal to this one, except for - * their labels. - * @see TermLabel#isProofRelevant() isStrategyRelevant - */ - boolean equalsModIrrelevantTermLabels(Object o); - - /** - * Checks if {@code o} is a term syntactically equal to this one, ignoring all term - * labels. - * - * @param o an object - * @return {@code true} iff {@code o} is a term syntactically equal to this ignoring term labels - */ - boolean equalsModTermLabels(Object o); - /** * Returns a human-readable source of this term. For example the filename with line and offset. */ diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index a5d9fe42b5c..8a67e658340 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -24,6 +24,16 @@ public class IrrelevantTermLabelsProperty implements TermProperty { */ private IrrelevantTermLabelsProperty() {} + /** + * Checks if {@code o} is a term syntactically equal to {@code term}, except for some irrelevant + * labels. + * + * @param term a term + * @param o the object compared to {@code term} + * @return {@code true} iff {@code o} is a term syntactically equal to {@code term}, except for + * their labels. + * @see TermLabel#isProofRelevant() isStrategyRelevant + */ @Override public Boolean equalsModThisProperty(Term term, Object o) { if (o == term) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java index ecbd7423260..e0525abe29b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java @@ -28,6 +28,14 @@ public class RenamingTermProperty implements TermProperty { */ private RenamingTermProperty() {} + /** + * Checks if {@code o} is a term syntactically equal to {@code term} modulo bound renaming. + * + * @param term a term + * @param o the object compared to {@code term} + * @return true iff {@code o} has the same values in operator, sort, arity, varsBoundHere + * and javaBlock as {@code term} modulo bound renaming + */ @Override public Boolean equalsModThisProperty(Term term, Object o) { if (o == term) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java index 484930d3692..be7414b81ef 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java @@ -21,6 +21,15 @@ public class TermLabelsProperty implements TermProperty { */ private TermLabelsProperty() {} + /** + * Checks if {@code o} is a term syntactically equal to {@code term}, ignoring all term + * labels. + * + * @param term a term + * @param o the object compared to {@code term} + * @return {@code true} iff {@code o} is a term syntactically equal to this ignoring all + * term labels + */ @Override public Boolean equalsModThisProperty(Term term, Object o) { if (o == term) { From c82306d4277235df3eaf4dd71f3f3453eaf8831c Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Fri, 22 Dec 2023 12:11:43 +0100 Subject: [PATCH 05/22] replace equalsModIrrelevantTermLabels with equalsModProperty (wip) --- .../java/de/uka/ilkd/key/logic/TermImpl.java | 314 +----------------- .../IrrelevantTermLabelsProperty.java | 2 +- .../equality/ProofIrrelevancyProperty.java | 18 +- .../logic/equality/TermLabelsProperty.java | 2 +- .../ilkd/key/logic/equality/TermProperty.java | 12 +- .../ilkd/key/macros/scripts/RuleCommand.java | 3 +- .../key/rule/AbstractLoopInvariantRule.java | 12 +- .../key/rule/AuxiliaryContractBuilders.java | 3 +- .../key/rule/UseDependencyContractRule.java | 3 +- .../uka/ilkd/key/rule/WhileInvariantRule.java | 9 +- .../ilkd/key/rule/inst/SVInstantiations.java | 5 +- .../rule/metaconstruct/CreateFrameCond.java | 3 +- .../metaconstruct/CreateHeapAnonUpdate.java | 3 +- .../rule/metaconstruct/IntroAtPreDefsOp.java | 5 +- .../key/speclang/WellDefinednessCheck.java | 15 +- .../jml/translation/JMLSpecFactory.java | 5 +- .../key/strategy/FindTacletAppContainer.java | 3 +- .../DiffFindAndReplacewithFeature.java | 3 +- .../NonDuplicateAppModPositionFeature.java | 4 +- .../key/strategy/feature/QueryExpandCost.java | 3 +- .../quantifierHeuristics/HandleArith.java | 3 +- .../PredictCostProver.java | 4 +- .../termgenerator/RootsGenerator.java | 3 +- .../java/de/uka/ilkd/key/logic/TestTerm.java | 13 +- 24 files changed, 99 insertions(+), 351 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java index 73017b8ff42..b9baeb5fc0d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java @@ -34,7 +34,7 @@ * The currently only class implementing the Term interface. TermFactory should be the only class * dealing directly with the TermImpl class. */ -class TermImpl implements Term, EqualsModProofIrrelevancy { +class TermImpl implements Term { /** * A static empty list of terms used for memory reasons. @@ -78,7 +78,7 @@ private enum ThreeValuedTruth { */ private int hashcode = -1; /** - * Cached {@link #hashCodeModProofIrrelevancy()} value. + * Cached hash value. */ private int hashcode2 = -1; @@ -301,181 +301,6 @@ public void execPreOrder(Visitor visitor) { visitor.subtreeLeft(this); } - - @Override - public final boolean equalsModRenaming(Term o) { - if (o == this) { - return true; - } - return unifyHelp(this, o, ImmutableSLList.nil(), - ImmutableSLList.nil(), null); - } - - // - // equals modulo renaming logic - - - /** - * compare two quantifiable variables if they are equal modulo renaming - * - * @param ownVar first QuantifiableVariable to be compared - * @param cmpVar second QuantifiableVariable to be compared - * @param ownBoundVars variables bound above the current position - * @param cmpBoundVars variables bound above the current position - */ - private static boolean compareBoundVariables(QuantifiableVariable ownVar, - QuantifiableVariable cmpVar, ImmutableList ownBoundVars, - ImmutableList cmpBoundVars) { - - final int ownNum = indexOf(ownVar, ownBoundVars); - final int cmpNum = indexOf(cmpVar, cmpBoundVars); - - if (ownNum == -1 && cmpNum == -1) { - // if both variables are not bound the variables have to be the - // same object - return ownVar == cmpVar; - } - - // otherwise the variables have to be bound at the same point (and both - // be bound) - return ownNum == cmpNum; - } - - /** - * @return the index of the first occurrence of var in list, or - * -1 if the variable is not an element of the list - */ - private static int indexOf(QuantifiableVariable var, ImmutableList list) { - int res = 0; - while (!list.isEmpty()) { - if (list.head() == var) { - return res; - } - ++res; - list = list.tail(); - } - return -1; - } - - /** - * Compares two terms modulo bound renaming - * - * @param t0 the first term - * @param t1 the second term - * @param ownBoundVars variables bound above the current position - * @param cmpBoundVars variables bound above the current position - * @return true is returned iff the terms are equal modulo bound renaming - */ - private boolean unifyHelp(Term t0, Term t1, ImmutableList ownBoundVars, - ImmutableList cmpBoundVars, NameAbstractionTable nat) { - - if (t0 == t1 && ownBoundVars.equals(cmpBoundVars)) { - return true; - } - - final Operator op0 = t0.op(); - - if (op0 instanceof QuantifiableVariable) { - return handleQuantifiableVariable(t0, t1, ownBoundVars, cmpBoundVars); - } - - final Operator op1 = t1.op(); - - if (!(op0 instanceof ProgramVariable) && op0 != op1) { - return false; - } - - if (t0.sort() != t1.sort() || t0.arity() != t1.arity()) { - return false; - } - - nat = handleJava(t0, t1, nat); - if (nat == FAILED) { - return false; - } - - return descendRecursively(t0, t1, ownBoundVars, cmpBoundVars, nat); - } - - private boolean handleQuantifiableVariable(Term t0, Term t1, - ImmutableList ownBoundVars, - ImmutableList cmpBoundVars) { - return (t1.op() instanceof QuantifiableVariable) - && compareBoundVariables((QuantifiableVariable) t0.op(), - (QuantifiableVariable) t1.op(), ownBoundVars, cmpBoundVars); - } - - /** - * used to encode that handleJava results in an unsatisfiable constraint (faster than - * using exceptions) - */ - private static final NameAbstractionTable FAILED = new NameAbstractionTable(); - - private static NameAbstractionTable handleJava(Term t0, Term t1, NameAbstractionTable nat) { - - if (!t0.javaBlock().isEmpty() || !t1.javaBlock().isEmpty()) { - nat = checkNat(nat); - if (!t0.javaBlock().equalsModRenaming(t1.javaBlock(), nat)) { - return FAILED; - } - } - - if (!(t0.op() instanceof SchemaVariable) && t0.op() instanceof ProgramVariable) { - if (!(t1.op() instanceof ProgramVariable)) { - return FAILED; - } - nat = checkNat(nat); - if (!((ProgramVariable) t0.op()).equalsModRenaming((ProgramVariable) t1.op(), nat)) { - return FAILED; - } - } - - return nat; - } - - private boolean descendRecursively(Term t0, Term t1, - ImmutableList ownBoundVars, - ImmutableList cmpBoundVars, NameAbstractionTable nat) { - - for (int i = 0; i < t0.arity(); i++) { - ImmutableList subOwnBoundVars = ownBoundVars; - ImmutableList subCmpBoundVars = cmpBoundVars; - - if (t0.varsBoundHere(i).size() != t1.varsBoundHere(i).size()) { - return false; - } - for (int j = 0; j < t0.varsBoundHere(i).size(); j++) { - final QuantifiableVariable ownVar = t0.varsBoundHere(i).get(j); - final QuantifiableVariable cmpVar = t1.varsBoundHere(i).get(j); - if (ownVar.sort() != cmpVar.sort()) { - return false; - } - - subOwnBoundVars = subOwnBoundVars.prepend(ownVar); - subCmpBoundVars = subCmpBoundVars.prepend(cmpVar); - } - - boolean newConstraint = - unifyHelp(t0.sub(i), t1.sub(i), subOwnBoundVars, subCmpBoundVars, nat); - - if (!newConstraint) { - return false; - } - } - - return true; - } - - private static NameAbstractionTable checkNat(NameAbstractionTable nat) { - if (nat == null) { - return new NameAbstractionTable(); - } - return nat; - } - - // end of equals modulo renaming logic - - /** * true iff o is syntactically equal to this term */ @@ -495,130 +320,6 @@ public boolean equals(Object o) { && boundVars.equals(t.boundVars) && javaBlock.equals(t.javaBlock); } - @Override - public boolean equalsModProperty(TermProperty property, Object o) { - return property.equalsModThisProperty(this, o); - } - - @Override - public int hashCodeModProperty(TermProperty property) { - return property.hashCodeModThisProperty(this); - } - - @Override - public boolean equalsModIrrelevantTermLabels(Object o) { - if (o == this) { - return true; - } - - if (!(o instanceof TermImpl t)) { - return false; - } - - if (!(op.equals(t.op) && boundVars.equals(t.boundVars) && javaBlock.equals(t.javaBlock))) { - return false; - } - - Term other = (Term) o; - - for (TermLabel label : getLabels()) { - if (label.isProofRelevant() && !other.getLabels().contains(label)) { - return false; - } - } - - for (TermLabel label : other.getLabels()) { - if (label.isProofRelevant() && !getLabels().contains(label)) { - return false; - } - } - - for (int i = 0; i < subs.size(); ++i) { - if (!subs.get(i).equalsModIrrelevantTermLabels(t.subs.get(i))) { - return false; - } - } - - return true; - } - - @Override - public boolean equalsModTermLabels(Object o) { - if (o == this) { - return true; - } - - if (!(o instanceof TermImpl t)) { - return false; - } - - if (!(op.equals(t.op) && boundVars.equals(t.boundVars) && javaBlock.equals(t.javaBlock))) { - return false; - } - - for (int i = 0; i < subs.size(); ++i) { - if (!subs.get(i).equalsModTermLabels(t.subs.get(i))) { - return false; - } - } - return true; - } - - @Override - public boolean equalsModProofIrrelevancy(Object o) { - if (o == this) { - return true; - } - - if (!(o instanceof TermImpl t)) { - return false; - } - - boolean opResult = op.equalsModProofIrrelevancy(t.op); - if (!(opResult - && EqualsModProofIrrelevancyUtil.compareImmutableArrays(boundVars, t.boundVars) - && javaBlock.equalsModProofIrrelevancy(t.javaBlock))) { - return false; - } - - Term other = (Term) o; - - for (TermLabel label : getLabels()) { - if (label.isProofRelevant() && !other.getLabels().contains(label)) { - return false; - } - } - - for (TermLabel label : other.getLabels()) { - if (label.isProofRelevant() && !getLabels().contains(label)) { - return false; - } - } - - for (int i = 0; i < subs.size(); ++i) { - if (!subs.get(i).equalsModProofIrrelevancy(t.subs.get(i))) { - return false; - } - } - - return true; - } - - @Override - public int hashCodeModProofIrrelevancy() { - if (hashcode2 == -1) { - // compute into local variable first to be thread-safe. - this.hashcode2 = Objects.hash(op(), - EqualsModProofIrrelevancyUtil - .hashCodeIterable(subs()), - EqualsModProofIrrelevancyUtil.hashCodeIterable(boundVars()), javaBlock()); - if (hashcode2 == -1) { - hashcode2 = 0; - } - } - return hashcode2; - } - @Override public final int hashCode() { if (hashcode == -1) { @@ -628,7 +329,6 @@ public final int hashCode() { return hashcode; } - /** * Performs the actual computation of the hashcode and can be overwritten by subclasses if * necessary @@ -646,6 +346,16 @@ protected int computeHashCode() { return hashcode; } + @Override + public boolean equalsModProperty(TermProperty property, Object o) { + return property.equalsModThisProperty(this, o); + } + + @Override + public int hashCodeModProperty(TermProperty property) { + return property.hashCodeModThisProperty(this); + } + /** * returns a linearized textual representation of this term diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index 8a67e658340..db1f5010f7d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -66,7 +66,7 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModIrrelevantTermLabels(otherSubs.get(i))) { + if (!termSubs.get(i).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, otherSubs.get(i))) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index 7c301b178a1..ab8781f993d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -27,6 +27,14 @@ public class ProofIrrelevancyProperty implements TermProperty { */ private ProofIrrelevancyProperty() {} + /** + * Checks if {@code o} is a term syntactically equal to {@code term}, except for attributes that are not relevant + * for the purpose of these terms in the proof. + * + * @param term a term + * @param o the object compared to {@code term} + * @return true iff {@code o} is a term syntactically equal to {@code term}, except for proof-irrelevant attributes. + */ @Override public Boolean equalsModThisProperty(Term term, Object o) { if (o == term) { @@ -62,7 +70,7 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProofIrrelevancy(otherSubs.get(i))) { + if (!termSubs.get(i).equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, otherSubs.get(i))) { return false; } } @@ -70,6 +78,12 @@ public Boolean equalsModThisProperty(Term term, Object o) { return true; } + /** + * Computes a hashcode that represents the proof-relevant fields of {@code term}. + * + * @param term the term to compute the hashcode for + * @return the hashcode + */ @Override public int hashCodeModThisProperty(Term term) { int hashcode2 = -1; // this line is just so the code compiles @@ -84,5 +98,7 @@ public int hashCodeModThisProperty(Term term) { } } return hashcode2; +// throw new UnsupportedOperationException("Hashing of terms modulo term proof-irrelevancy not yet implemented!"); + } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java index be7414b81ef..0eebfaf1886 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java @@ -49,7 +49,7 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModTermLabels(otherSubs.get(i))) { + if (!termSubs.get(i).equalsModProperty(TERM_LABELS_PROPERTY, otherSubs.get(i))) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java index 4b1e1563883..ef4b7fb6909 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java @@ -17,21 +17,21 @@ */ public interface TermProperty { /** - * Checks term and other for equality ignoring a certain property. + * Checks {@code term} and {@code o} for equality ignoring a certain property. * - * @param term the term to check for equality with o - * @param o the object to check for equality with term - * @return whether term and o are equal ignoring a certain property + * @param term the term to check for equality with {@code o} + * @param o the object to check for equality with {@code term} + * @return whether {@code term} and {@code o} are equal ignoring a certain property */ Boolean equalsModThisProperty(Term term, Object o); /** - * Computes the hash code of the term> in a context where + * Computes the hash code of the {@code term} in a context where * {@link this#equalsModThisProperty(Term, Object)} is used as an equality check, so that it can * be used in, e.g., a HashMap. * * @param term the term to compute the hash code for - * @return the hash code of term ignoring a certain property + * @return the hash code of {@code term} ignoring a certain property */ int hashCodeModThisProperty(Term term); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java index 69777cc1305..3ab0e8e39b6 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java @@ -8,6 +8,7 @@ import de.uka.ilkd.key.control.AbstractUserInterfaceControl; import de.uka.ilkd.key.java.Services; import de.uka.ilkd.key.logic.*; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.SchemaVariable; import de.uka.ilkd.key.macros.scripts.meta.Option; import de.uka.ilkd.key.macros.scripts.meta.Varargs; @@ -353,7 +354,7 @@ private List filterList(Parameters p, ImmutableList list) Object ptaInst = pta.instantiations().getInstantiationEntry(sv).getInstantiation(); - add &= userInst == null || userInst.equalsModIrrelevantTermLabels(ptaInst); + add &= userInst == null || userInst.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ptaInst); } if (add) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java index 9fe56d2aa02..a1179d618ab 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java @@ -28,6 +28,8 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * An abstract super class for loop invariant rules. Extending rules should usually call * {@link #doPreparations(Goal, Services, RuleApp)} directly at the beginning of the @@ -438,7 +440,7 @@ protected static AnonUpdateData createAnonUpdate(LocationVariable heap, Term mod // check for strictly pure loops final Term anonUpdate; - if (tb.strictlyNothing().equalsModIrrelevantTermLabels(mod)) { + if (tb.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { anonUpdate = tb.skip(); } else { anonUpdate = tb.anonUpd(heap, mod, anonHeapTerm); @@ -502,14 +504,14 @@ protected static AdditionalHeapTerms createAdditionalHeapTerms(Services services final Term freeMod = freeMods.get(heap); final Term strictlyNothing = tb.strictlyNothing(); final Term currentFrame; - if (strictlyNothing.equalsModIrrelevantTermLabels(mod)) { - if (strictlyNothing.equalsModIrrelevantTermLabels(freeMod)) { + if (strictlyNothing.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + if (strictlyNothing.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { currentFrame = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoop.get(heap)); } else { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), freeMod); } } else { - if (strictlyNothing.equalsModIrrelevantTermLabels(freeMod)) { + if (strictlyNothing.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), mod); } else { currentFrame = tb.frame( @@ -543,7 +545,7 @@ protected record AdditionalHeapTerms(Term anonUpdate, Term wellFormedAnon, Term /** * A container for an instantiation of this {@link LoopScopeInvariantRule} application; contains * the update, the program with post condition, the {@link While} loop the - * {@link LoopScopeInvariantRule} should be applied to, the {@link LoopSpecification}, the the + * {@link LoopScopeInvariantRule} should be applied to, the {@link LoopSpecification}, the * self {@link Term}. * * @param innermostExecutionContext TODO Removed this field; was however used in old invariant rule. Could be needed for the information flow validity goal. diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java index de242101c9c..44997ab0e68 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java @@ -19,6 +19,7 @@ import de.uka.ilkd.key.java.visitor.OuterBreakContinueAndReturnReplacer; import de.uka.ilkd.key.java.visitor.ProgramElementReplacer; import de.uka.ilkd.key.logic.*; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.label.TermLabelManager; @@ -649,7 +650,7 @@ public Term buildAnonOutUpdate(final Set vars, .entrySet()) { Term anonymisationUpdate = skip(); final Term modifiesClause = modifiesClauses.get(anonymisationHeap.getKey()); - if (!modifiesClause.equalsModIrrelevantTermLabels(strictlyNothing())) { + if (!modifiesClause.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, strictlyNothing())) { anonymisationUpdate = anonUpd(anonymisationHeap.getKey(), modifiesClause, services.getTermBuilder().label( services.getTermBuilder().func(anonymisationHeap.getValue()), diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java index ee696836f89..1abf95d6610 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java @@ -13,6 +13,7 @@ import de.uka.ilkd.key.ldt.HeapLDT; import de.uka.ilkd.key.ldt.LocSetLDT; import de.uka.ilkd.key.logic.*; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.*; import de.uka.ilkd.key.logic.sort.NullSort; import de.uka.ilkd.key.proof.Goal; @@ -207,7 +208,7 @@ public static boolean isBaseOcc(Term focus, Term candidate) { return false; } for (int i = 1, n = candidate.arity(); i < n; i++) { - if (!(candidate.sub(i).equalsModIrrelevantTermLabels(focus.sub(i)) + if (!(candidate.sub(i).equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, focus.sub(i)) || candidate.sub(i).op() instanceof LogicVariable)) { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java index 871ceaf6448..312c2c5b281 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java @@ -38,6 +38,7 @@ import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; import de.uka.ilkd.key.logic.TermServices; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.label.TermLabelManager; @@ -269,7 +270,7 @@ private static AnonUpdateData createAnonUpdate(LocationVariable heap, Term mod, // check for strictly pure loops final Term anonUpdate; - if (tb.strictlyNothing().equalsModIrrelevantTermLabels(mod)) { + if (tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { anonUpdate = tb.skip(); } else { anonUpdate = tb.anonUpd(heap, mod, anonHeapTerm); @@ -828,14 +829,14 @@ public ImmutableList apply(Goal goal, Services services, final RuleApp rul final Term freeMod = freeMods.get(heap); final Term strictlyNothing = tb.strictlyNothing(); final Term currentFrame; - if (strictlyNothing.equalsModIrrelevantTermLabels(mod)) { - if (strictlyNothing.equalsModIrrelevantTermLabels(freeMod)) { + if (strictlyNothing.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + if (strictlyNothing.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { currentFrame = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoop.get(heap)); } else { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), freeMod); } } else { - if (strictlyNothing.equalsModIrrelevantTermLabels(freeMod)) { + if (strictlyNothing.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), mod); } else { currentFrame = tb.frame( diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java index 8494913ea35..5b2684d7ccc 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java @@ -12,6 +12,7 @@ import de.uka.ilkd.key.logic.PosInProgram; import de.uka.ilkd.key.logic.ProgramElementName; import de.uka.ilkd.key.logic.Term; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.op.ModalOperatorSV; import de.uka.ilkd.key.logic.op.Operator; @@ -544,7 +545,7 @@ public boolean equals(Object obj) { final Object inst = e.value().getInstantiation(); assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { - if (!instAsTerm.equalsModIrrelevantTermLabels(cmp.getInstantiation(e.key()))) { + if (!instAsTerm.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, cmp.getInstantiation(e.key()))) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { @@ -574,7 +575,7 @@ public boolean equalsModProofIrrelevancy(Object obj) { final Object inst = e.value().getInstantiation(); assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { - if (!instAsTerm.equalsModProofIrrelevancy(cmp.getInstantiation(e.key()))) { + if (!instAsTerm.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, cmp.getInstantiation(e.key()))) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java index b213c770edf..1f7f61f6540 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java @@ -13,6 +13,7 @@ import de.uka.ilkd.key.logic.Name; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.LocationVariable; import de.uka.ilkd.key.logic.op.Modality; @@ -91,7 +92,7 @@ private static Term createFrameCondition(final LoopSpecification loopSpec, final Term mod = mods.get(heap); final Term fc; - if (tb.strictlyNothing().equalsModIrrelevantTermLabels(mod)) { + if (tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { fc = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoopMap.get(heap)); } else { fc = tb.frame(tb.var(heap), heapToBeforeLoopMap.get(heap), mod); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java index d260b6b73f8..63ada4c878d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java @@ -13,6 +13,7 @@ import de.uka.ilkd.key.logic.Name; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.LocationVariable; @@ -124,7 +125,7 @@ private static Term createElementaryAnonUpdate(LocationVariable heap, Term anonH final Term anonHeapTerm = tb.label(anonHeap, ParameterlessTermLabel.ANON_HEAP_LABEL); - return tb.strictlyNothing().equalsModIrrelevantTermLabels(mod) ? tb.skip() + return tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod) ? tb.skip() : tb.anonUpd(heap, mod, anonHeapTerm); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java index 420150a5ff9..0aad6c5323b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java @@ -25,6 +25,7 @@ import de.uka.ilkd.key.logic.Name; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.LocationVariable; import de.uka.ilkd.key.rule.inst.SVInstantiations; @@ -221,7 +222,7 @@ public void performActionOnLoopInvariant(final LoopSpecification spec) { final Term freeTerm = spec.getInternalFreeModifies().getOrDefault( services.getTypeConverter().getHeapLDT().getHeap(), tb.strictlyNothing()); if (heap != services.getTypeConverter().getHeapLDT().getSavedHeap() - || !tb.strictlyNothing().equalsModIrrelevantTermLabels(term)) { + || !tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, term)) { final Term m = spec.getModifies(heap, self, atPres, services); final ImmutableList infFlowSpecs = spec.getInfFlowSpecs(heap, self, atPres, services); @@ -235,7 +236,7 @@ public void performActionOnLoopInvariant(final LoopSpecification spec) { newInfFlowSpecs.put(heap, infFlowSpecs); } if (heap != services.getTypeConverter().getHeapLDT().getSavedHeap() - || !tb.strictlyNothing().equalsModIrrelevantTermLabels(freeTerm)) { + || !tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, freeTerm)) { final Term m = spec.getFreeModifies(heap, selfTerm, atPres, services); final ImmutableList infFlowSpecs = spec.getInfFlowSpecs(heap, selfTerm, atPres, services); diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java index 5517964de1a..d64fa682e48 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java @@ -15,6 +15,7 @@ import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; import de.uka.ilkd.key.logic.TermServices; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.op.Function; import de.uka.ilkd.key.logic.op.IObserverFunction; @@ -397,7 +398,7 @@ private String getText(boolean includeHtmlMarkup, Services services) { final boolean showSig = !isInv && !modelField(); if (getAssignable() != null && showSig) { String printMods = LogicPrinter.quickPrintTerm( - getAssignable(null).equalsModIrrelevantTermLabels(TB.strictlyNothing()) ? TB.empty() + getAssignable(null).equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, TB.strictlyNothing()) ? TB.empty() : this.getAssignable(null), services); mods = mods + (includeHtmlMarkup ? "
" : "\n") + "mod" @@ -729,19 +730,19 @@ final void setRequires(Term req) { final void setAssignable(Term ass, TermServices services) { this.assignable = ass; - if (ass == null || TB.strictlyNothing().equalsModIrrelevantTermLabels(ass) - || TB.FALSE().equalsModIrrelevantTermLabels(ass)) { + if (ass == null || TB.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass) + || TB.FALSE().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { this.assignable = TB.strictlyNothing(); - } else if (TB.tt().equalsModIrrelevantTermLabels(ass) - || TB.TRUE().equalsModIrrelevantTermLabels(ass)) { + } else if (TB.tt().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass) + || TB.TRUE().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { this.assignable = TB.allLocs(); } } final void combineAssignable(Term ass1, Term ass2, TermServices services) { - if (ass1 == null || TB.strictlyNothing().equalsModIrrelevantTermLabels(ass1)) { + if (ass1 == null || TB.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass1)) { setAssignable(ass2, services); - } else if (ass2 == null || TB.strictlyNothing().equalsModIrrelevantTermLabels(ass2)) { + } else if (ass2 == null || TB.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass2)) { setAssignable(ass1, services); } else { setAssignable(TB.union(ass1, ass2), services); diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java index 5653bfbb809..06fa49bb4b6 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java @@ -51,6 +51,7 @@ import org.jspecify.annotations.NonNull; import org.jspecify.annotations.Nullable; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.DIVERGES; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.SIGNALS; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.ClauseHd.ENSURES; @@ -625,7 +626,7 @@ private Term translateUnionClauses(Context context, ImmutableList 1) { throw new SLTranslationException( "\"assignable \\less_than_nothing\" does not go with other " @@ -768,7 +769,7 @@ private boolean translateStrictlyPure(Context context, ImmutableList maxRepetitionsOnSameTerm) { break; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java index 630b820714d..2d094e4b358 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java @@ -8,6 +8,7 @@ import de.uka.ilkd.key.ldt.IntegerLDT; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.Equality; import de.uka.ilkd.key.logic.op.Function; import de.uka.ilkd.key.logic.op.Junctor; @@ -52,7 +53,7 @@ public static Term provedByArith(Term problem, Services services) { final Term falseT = tb.ff(); final Term arithTerm = formatArithTerm(problem, tb, integerLDT, services.getCaches()); - if (arithTerm.equalsModIrrelevantTermLabels(falseT)) { + if (arithTerm.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, falseT)) { result = provedArithEqual(problem, tb, services); putInTermCache(provedByArithCache, problem, result); return result; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java index 1631242a033..ade995863a5 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java @@ -17,6 +17,8 @@ import org.key_project.util.collection.DefaultImmutableSet; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * TODO: rewrite, this seems pretty inefficient ... */ @@ -343,7 +345,7 @@ public boolean selfRefine(ImmutableSet lits) { if (op == Junctor.TRUE) { return true; } - if (op == Junctor.FALSE && terms[0].equalsModIrrelevantTermLabels(terms[j])) { + if (op == Junctor.FALSE && terms[0].equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, terms[j])) { next = next.remove(terms[j]); literals = literals.remove(terms[j]); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java index 09beab67408..404a674795e 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java @@ -12,6 +12,7 @@ import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; import de.uka.ilkd.key.logic.TermServices; +import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.Equality; import de.uka.ilkd.key.logic.op.Operator; @@ -90,7 +91,7 @@ private Iterator emptyIterator() { } private Iterator toIterator(Term res) { - if (res.equalsModIrrelevantTermLabels(tb.ff())) { + if (res.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, tb.ff())) { return emptyIterator(); } return ImmutableSLList.nil().prepend(res).iterator(); diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java index b2210702607..3e0a2d83e0c 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java @@ -5,6 +5,7 @@ import de.uka.ilkd.key.java.StatementBlock; import de.uka.ilkd.key.java.declaration.LocalVariableDeclaration; +import de.uka.ilkd.key.logic.equality.RenamingTermProperty; import de.uka.ilkd.key.logic.op.*; import de.uka.ilkd.key.logic.sort.Sort; import de.uka.ilkd.key.logic.sort.SortImpl; @@ -108,9 +109,9 @@ public void testFreeVars4() { public void testProgramElementEqualsModRenaming() { Term match1 = TacletForTests.parseTerm("\\<{ int i; }\\>true & \\<{ int i; }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ int i; }\\>true "); - assertTrue(match1.sub(0).equalsModRenaming(match2), + assertTrue(match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), "Terms should be equalModRenaming (0)."); - assertTrue(match1.sub(0).equalsModRenaming(match1.sub(1)), + assertTrue(match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match1.sub(1)), "Terms should be equalModRenaming (1)."); Term match3 = TacletForTests.parseTerm("\\<{ int j = 0; }\\>true "); assertNotEquals(match1, match3, "Terms should not be equal."); @@ -121,13 +122,13 @@ public void testProgramElementEqualsModRenaming() { public void testEqualsModRenamingWithLabels() { Term match1 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); - assertTrue(match1.equalsModRenaming(match2), "Terms should be equalModRenaming."); + assertTrue(match1.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), "Terms should be equalModRenaming."); Term match3 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match4 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int j = 0; } } }\\>true"); - assertTrue(match3.equalsModRenaming(match4), "Terms should be equalModRenaming."); + assertTrue(match3.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match4), "Terms should be equalModRenaming."); Term match5 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match6 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); - assertTrue(match5.equalsModRenaming(match6), "Terms should be equalModRenaming."); + assertTrue(match5.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match6), "Terms should be equalModRenaming."); } @Test @@ -139,7 +140,7 @@ public void testEqualsModRenaming() { final Term pz = tf.createTerm(p, new Term[] { tf.createTerm(z) }, null, null); final Term quant2 = tb.all(z, tb.all(z, tb.all(z, pz))); - assertTrue(quant1.equalsModRenaming(quant2), + assertTrue(quant1.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, quant2), "Terms " + quant1 + " and " + quant2 + " should be equal mod renaming"); } From 94bd484bda2de604eb8a35479e712ee71545f8eb Mon Sep 17 00:00:00 2001 From: Tobias Date: Sat, 23 Dec 2023 16:39:03 +0100 Subject: [PATCH 06/22] finish replacing equalsModIrrelevantTermLabels with equalsModProperty --- .../java/de/uka/ilkd/key/logic/TermImpl.java | 8 ----- .../IrrelevantTermLabelsProperty.java | 3 +- .../equality/ProofIrrelevancyProperty.java | 9 +++-- .../ilkd/key/macros/scripts/RuleCommand.java | 6 ++-- .../key/rule/AuxiliaryContractBuilders.java | 6 ++-- .../key/rule/UseDependencyContractRule.java | 5 +-- .../uka/ilkd/key/rule/WhileInvariantRule.java | 14 +++++--- .../ilkd/key/rule/inst/SVInstantiations.java | 10 ++++-- .../rule/metaconstruct/CreateFrameCond.java | 5 +-- .../metaconstruct/CreateHeapAnonUpdate.java | 6 ++-- .../rule/metaconstruct/IntroAtPreDefsOp.java | 10 ++++-- .../key/speclang/WellDefinednessCheck.java | 35 ++++++++++++------- .../jml/translation/JMLSpecFactory.java | 6 ++-- .../key/strategy/FindTacletAppContainer.java | 6 ++-- .../DiffFindAndReplacewithFeature.java | 6 ++-- .../NonDuplicateAppModPositionFeature.java | 1 - .../key/strategy/feature/QueryExpandCost.java | 6 ++-- .../quantifierHeuristics/HandleArith.java | 5 +-- .../PredictCostProver.java | 3 +- .../termgenerator/RootsGenerator.java | 6 ++-- .../java/de/uka/ilkd/key/logic/TestTerm.java | 16 ++++++--- 21 files changed, 108 insertions(+), 64 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java index b9baeb5fc0d..c60af5eef15 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java @@ -3,27 +3,19 @@ * SPDX-License-Identifier: GPL-2.0-only */ package de.uka.ilkd.key.logic; -import java.util.Objects; import java.util.concurrent.atomic.AtomicInteger; -import de.uka.ilkd.key.java.NameAbstractionTable; import de.uka.ilkd.key.java.PositionInfo; import de.uka.ilkd.key.logic.equality.TermProperty; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.op.Modality; import de.uka.ilkd.key.logic.op.Operator; -import de.uka.ilkd.key.logic.op.ProgramVariable; import de.uka.ilkd.key.logic.op.QuantifiableVariable; -import de.uka.ilkd.key.logic.op.SchemaVariable; import de.uka.ilkd.key.logic.sort.Sort; -import org.key_project.util.EqualsModProofIrrelevancy; -import org.key_project.util.EqualsModProofIrrelevancyUtil; import org.key_project.util.Strings; import org.key_project.util.collection.DefaultImmutableSet; import org.key_project.util.collection.ImmutableArray; -import org.key_project.util.collection.ImmutableList; -import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.collection.ImmutableSet; import org.jspecify.annotations.NonNull; diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index db1f5010f7d..c97c95b2699 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -66,7 +66,8 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, otherSubs.get(i))) { + if (!termSubs.get(i).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + otherSubs.get(i))) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index ab8781f993d..751c9e1413c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -28,12 +28,14 @@ public class ProofIrrelevancyProperty implements TermProperty { private ProofIrrelevancyProperty() {} /** - * Checks if {@code o} is a term syntactically equal to {@code term}, except for attributes that are not relevant + * Checks if {@code o} is a term syntactically equal to {@code term}, except for attributes that + * are not relevant * for the purpose of these terms in the proof. * * @param term a term * @param o the object compared to {@code term} - * @return true iff {@code o} is a term syntactically equal to {@code term}, except for proof-irrelevant attributes. + * @return true iff {@code o} is a term syntactically equal to {@code term}, except for + * proof-irrelevant attributes. */ @Override public Boolean equalsModThisProperty(Term term, Object o) { @@ -98,7 +100,8 @@ public int hashCodeModThisProperty(Term term) { } } return hashcode2; -// throw new UnsupportedOperationException("Hashing of terms modulo term proof-irrelevancy not yet implemented!"); + // throw new UnsupportedOperationException("Hashing of terms modulo term proof-irrelevancy + // not yet implemented!"); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java index 3ab0e8e39b6..90763179ed7 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java @@ -8,7 +8,6 @@ import de.uka.ilkd.key.control.AbstractUserInterfaceControl; import de.uka.ilkd.key.java.Services; import de.uka.ilkd.key.logic.*; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.SchemaVariable; import de.uka.ilkd.key.macros.scripts.meta.Option; import de.uka.ilkd.key.macros.scripts.meta.Varargs; @@ -23,6 +22,8 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * Command that applies a calculus rule All parameters are passed as strings and converted by the * command. The parameters are: @@ -354,7 +355,8 @@ private List filterList(Parameters p, ImmutableList list) Object ptaInst = pta.instantiations().getInstantiationEntry(sv).getInstantiation(); - add &= userInst == null || userInst.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ptaInst); + add &= userInst == null + || userInst.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, ptaInst); } if (add) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java index 44997ab0e68..d31ab07e4d0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java @@ -19,7 +19,6 @@ import de.uka.ilkd.key.java.visitor.OuterBreakContinueAndReturnReplacer; import de.uka.ilkd.key.java.visitor.ProgramElementReplacer; import de.uka.ilkd.key.logic.*; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.label.TermLabelManager; @@ -47,6 +46,8 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * This contains various builders used in building formulae and terms for block and loop contracts. * @@ -650,7 +651,8 @@ public Term buildAnonOutUpdate(final Set vars, .entrySet()) { Term anonymisationUpdate = skip(); final Term modifiesClause = modifiesClauses.get(anonymisationHeap.getKey()); - if (!modifiesClause.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, strictlyNothing())) { + if (!modifiesClause.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + strictlyNothing())) { anonymisationUpdate = anonUpd(anonymisationHeap.getKey(), modifiesClause, services.getTermBuilder().label( services.getTermBuilder().func(anonymisationHeap.getValue()), diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java index 1abf95d6610..22fbbbdb7a5 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java @@ -13,7 +13,6 @@ import de.uka.ilkd.key.ldt.HeapLDT; import de.uka.ilkd.key.ldt.LocSetLDT; import de.uka.ilkd.key.logic.*; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.*; import de.uka.ilkd.key.logic.sort.NullSort; import de.uka.ilkd.key.proof.Goal; @@ -32,6 +31,8 @@ import org.jspecify.annotations.NonNull; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + public final class UseDependencyContractRule implements BuiltInRule { @@ -208,7 +209,7 @@ public static boolean isBaseOcc(Term focus, Term candidate) { return false; } for (int i = 1, n = candidate.arity(); i < n; i++) { - if (!(candidate.sub(i).equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, focus.sub(i)) + if (!(candidate.sub(i).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, focus.sub(i)) || candidate.sub(i).op() instanceof LogicVariable)) { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java index 312c2c5b281..4870631f39d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java @@ -38,7 +38,6 @@ import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; import de.uka.ilkd.key.logic.TermServices; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.label.TermLabelManager; @@ -72,6 +71,8 @@ import org.jspecify.annotations.NonNull; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + public final class WhileInvariantRule implements BuiltInRule { /** * The hint used to refactor the initial invariant. @@ -270,7 +271,7 @@ private static AnonUpdateData createAnonUpdate(LocationVariable heap, Term mod, // check for strictly pure loops final Term anonUpdate; - if (tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + if (tb.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { anonUpdate = tb.skip(); } else { anonUpdate = tb.anonUpd(heap, mod, anonHeapTerm); @@ -829,14 +830,17 @@ public ImmutableList apply(Goal goal, Services services, final RuleApp rul final Term freeMod = freeMods.get(heap); final Term strictlyNothing = tb.strictlyNothing(); final Term currentFrame; - if (strictlyNothing.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { - if (strictlyNothing.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { + if (strictlyNothing.equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + if (strictlyNothing.equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { currentFrame = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoop.get(heap)); } else { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), freeMod); } } else { - if (strictlyNothing.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { + if (strictlyNothing.equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), mod); } else { currentFrame = tb.frame( diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java index 5b2684d7ccc..132fe7a1d1d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java @@ -12,7 +12,6 @@ import de.uka.ilkd.key.logic.PosInProgram; import de.uka.ilkd.key.logic.ProgramElementName; import de.uka.ilkd.key.logic.Term; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.op.ModalOperatorSV; import de.uka.ilkd.key.logic.op.Operator; @@ -30,6 +29,8 @@ import org.key_project.util.collection.ImmutableMapEntry; import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * This class wraps an {@link ImmutableMap} from {@link SchemaVariable} to * {@link InstantiationEntry} @@ -545,7 +546,8 @@ public boolean equals(Object obj) { final Object inst = e.value().getInstantiation(); assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { - if (!instAsTerm.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, cmp.getInstantiation(e.key()))) { + if (!instAsTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + cmp.getInstantiation(e.key()))) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { @@ -575,7 +577,9 @@ public boolean equalsModProofIrrelevancy(Object obj) { final Object inst = e.value().getInstantiation(); assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { - if (!instAsTerm.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, cmp.getInstantiation(e.key()))) { + if (!instAsTerm.equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, + cmp.getInstantiation(e.key()))) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java index 1f7f61f6540..21d01eb7098 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateFrameCond.java @@ -13,7 +13,6 @@ import de.uka.ilkd.key.logic.Name; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.LocationVariable; import de.uka.ilkd.key.logic.op.Modality; @@ -23,6 +22,8 @@ import de.uka.ilkd.key.speclang.LoopSpecification; import de.uka.ilkd.key.util.MiscTools; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * Creates the frame condition (aka "assignable clause") for the given loop. Also accepts the * pre-state update and extracts the symbols from there. New symbols in the pre-state update (like @@ -92,7 +93,7 @@ private static Term createFrameCondition(final LoopSpecification loopSpec, final Term mod = mods.get(heap); final Term fc; - if (tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + if (tb.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { fc = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoopMap.get(heap)); } else { fc = tb.frame(tb.var(heap), heapToBeforeLoopMap.get(heap), mod); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java index 63ada4c878d..5d170f28481 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/CreateHeapAnonUpdate.java @@ -13,7 +13,6 @@ import de.uka.ilkd.key.logic.Name; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.LocationVariable; @@ -23,6 +22,8 @@ import de.uka.ilkd.key.speclang.LoopSpecification; import de.uka.ilkd.key.util.MiscTools; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * Creates the anonymizing update for the heap. Expects as arguments the loop formula (for * determining the relevant heap contexts) and three Skolem terms for the currently implemented @@ -125,7 +126,8 @@ private static Term createElementaryAnonUpdate(LocationVariable heap, Term anonH final Term anonHeapTerm = tb.label(anonHeap, ParameterlessTermLabel.ANON_HEAP_LABEL); - return tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, mod) ? tb.skip() + return tb.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod) + ? tb.skip() : tb.anonUpd(heap, mod, anonHeapTerm); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java index 0aad6c5323b..cf184b0d49e 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java @@ -25,7 +25,6 @@ import de.uka.ilkd.key.logic.Name; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.LocationVariable; import de.uka.ilkd.key.rule.inst.SVInstantiations; @@ -43,6 +42,8 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * Transformer that introduces concrete prestate variables */ @@ -222,7 +223,8 @@ public void performActionOnLoopInvariant(final LoopSpecification spec) { final Term freeTerm = spec.getInternalFreeModifies().getOrDefault( services.getTypeConverter().getHeapLDT().getHeap(), tb.strictlyNothing()); if (heap != services.getTypeConverter().getHeapLDT().getSavedHeap() - || !tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, term)) { + || !tb.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + term)) { final Term m = spec.getModifies(heap, self, atPres, services); final ImmutableList infFlowSpecs = spec.getInfFlowSpecs(heap, self, atPres, services); @@ -236,7 +238,9 @@ public void performActionOnLoopInvariant(final LoopSpecification spec) { newInfFlowSpecs.put(heap, infFlowSpecs); } if (heap != services.getTypeConverter().getHeapLDT().getSavedHeap() - || !tb.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, freeTerm)) { + || !tb.strictlyNothing().equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, + freeTerm)) { final Term m = spec.getFreeModifies(heap, selfTerm, atPres, services); final ImmutableList infFlowSpecs = spec.getInfFlowSpecs(heap, selfTerm, atPres, services); diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java index d64fa682e48..a60cb3aea4d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java @@ -15,7 +15,6 @@ import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; import de.uka.ilkd.key.logic.TermServices; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.label.ParameterlessTermLabel; import de.uka.ilkd.key.logic.op.Function; import de.uka.ilkd.key.logic.op.IObserverFunction; @@ -43,6 +42,8 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * A contract for checking the well-definedness of a jml specification element (i.e. a class * invariant, a method contract, a model field or any jml statement), consisting of precondition, @@ -398,8 +399,9 @@ private String getText(boolean includeHtmlMarkup, Services services) { final boolean showSig = !isInv && !modelField(); if (getAssignable() != null && showSig) { String printMods = LogicPrinter.quickPrintTerm( - getAssignable(null).equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, TB.strictlyNothing()) ? TB.empty() - : this.getAssignable(null), + getAssignable(null).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + TB.strictlyNothing()) ? TB.empty() + : this.getAssignable(null), services); mods = mods + (includeHtmlMarkup ? "
" : "\n") + "mod" + (includeHtmlMarkup ? " " : ": ") @@ -730,19 +732,26 @@ final void setRequires(Term req) { final void setAssignable(Term ass, TermServices services) { this.assignable = ass; - if (ass == null || TB.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass) - || TB.FALSE().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { + if (ass == null + || TB.strictlyNothing().equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, ass) + || TB.FALSE().equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { this.assignable = TB.strictlyNothing(); - } else if (TB.tt().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass) - || TB.TRUE().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { + } else if (TB.tt().equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, ass) + || TB.TRUE().equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { this.assignable = TB.allLocs(); } } final void combineAssignable(Term ass1, Term ass2, TermServices services) { - if (ass1 == null || TB.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass1)) { + if (ass1 == null || TB.strictlyNothing().equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, ass1)) { setAssignable(ass2, services); - } else if (ass2 == null || TB.strictlyNothing().equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, ass2)) { + } else if (ass2 == null || TB.strictlyNothing().equalsModProperty( + IRRELEVANT_TERM_LABELS_PROPERTY, ass2)) { setAssignable(ass1, services); } else { setAssignable(TB.union(ass1, ass2), services); @@ -1003,9 +1012,11 @@ public final Term getPost(final Condition post, ParsableVariable result, public final Term getUpdates(Term mod, LocationVariable heap, ProgramVariable heapAtPre, Term anonHeap, TermServices services) { assert mod != null; - assert anonHeap != null || TB.strictlyNothing().equalsModIrrelevantTermLabels(mod); - final Term havocUpd = TB.strictlyNothing().equalsModIrrelevantTermLabels(mod) ? TB.skip() - : TB.elementary(heap, TB.anon(TB.var(heap), mod, anonHeap)); + assert anonHeap != null + || TB.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod); + final Term havocUpd = + TB.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod) ? TB.skip() + : TB.elementary(heap, TB.anon(TB.var(heap), mod, anonHeap)); final Term oldUpd = heapAtPre != heap ? TB.elementary(TB.var(heapAtPre), TB.var(heap)) : TB.skip(); return TB.parallel(oldUpd, havocUpd); diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java index 06fa49bb4b6..269f4e70ea7 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java @@ -626,7 +626,8 @@ private Term translateUnionClauses(Context context, ImmutableList 1) { throw new SLTranslationException( "\"assignable \\less_than_nothing\" does not go with other " @@ -769,7 +770,8 @@ private boolean translateStrictlyPure(Context context, ImmutableList maxRepetitionsOnSameTerm) { break; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java index 2d094e4b358..b40eaac454f 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java @@ -8,7 +8,6 @@ import de.uka.ilkd.key.ldt.IntegerLDT; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.Equality; import de.uka.ilkd.key.logic.op.Function; import de.uka.ilkd.key.logic.op.Junctor; @@ -18,6 +17,8 @@ import org.key_project.util.LRUCache; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * This class is used to prove some simple arithmetic problem which are {@code a==b}, {@code a>=b}, * {@code a<=b}; Besides it can be used to prove that {@code a>=b} or {@code a<=b} by @@ -53,7 +54,7 @@ public static Term provedByArith(Term problem, Services services) { final Term falseT = tb.ff(); final Term arithTerm = formatArithTerm(problem, tb, integerLDT, services.getCaches()); - if (arithTerm.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, falseT)) { + if (arithTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, falseT)) { result = provedArithEqual(problem, tb, services); putInTermCache(provedByArithCache, problem, result); return result; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java index ade995863a5..723d19535b3 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java @@ -345,7 +345,8 @@ public boolean selfRefine(ImmutableSet lits) { if (op == Junctor.TRUE) { return true; } - if (op == Junctor.FALSE && terms[0].equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, terms[j])) { + if (op == Junctor.FALSE + && terms[0].equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, terms[j])) { next = next.remove(terms[j]); literals = literals.remove(terms[j]); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java index 404a674795e..5fb326c5063 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java @@ -12,7 +12,6 @@ import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.TermBuilder; import de.uka.ilkd.key.logic.TermServices; -import de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty; import de.uka.ilkd.key.logic.op.AbstractTermTransformer; import de.uka.ilkd.key.logic.op.Equality; import de.uka.ilkd.key.logic.op.Operator; @@ -24,6 +23,8 @@ import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; + /** * Term generator for inferring the range of values that a variable can have from a given non-linear @@ -91,7 +92,8 @@ private Iterator emptyIterator() { } private Iterator toIterator(Term res) { - if (res.equalsModProperty(IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY, tb.ff())) { + if (res.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + tb.ff())) { return emptyIterator(); } return ImmutableSLList.nil().prepend(res).iterator(); diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java index 3e0a2d83e0c..a5d9cd1ad8c 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java @@ -109,9 +109,12 @@ public void testFreeVars4() { public void testProgramElementEqualsModRenaming() { Term match1 = TacletForTests.parseTerm("\\<{ int i; }\\>true & \\<{ int i; }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ int i; }\\>true "); - assertTrue(match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), + assertTrue( + match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), "Terms should be equalModRenaming (0)."); - assertTrue(match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match1.sub(1)), + assertTrue( + match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, + match1.sub(1)), "Terms should be equalModRenaming (1)."); Term match3 = TacletForTests.parseTerm("\\<{ int j = 0; }\\>true "); assertNotEquals(match1, match3, "Terms should not be equal."); @@ -122,13 +125,16 @@ public void testProgramElementEqualsModRenaming() { public void testEqualsModRenamingWithLabels() { Term match1 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); - assertTrue(match1.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), "Terms should be equalModRenaming."); + assertTrue(match1.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), + "Terms should be equalModRenaming."); Term match3 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match4 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int j = 0; } } }\\>true"); - assertTrue(match3.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match4), "Terms should be equalModRenaming."); + assertTrue(match3.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match4), + "Terms should be equalModRenaming."); Term match5 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match6 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); - assertTrue(match5.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match6), "Terms should be equalModRenaming."); + assertTrue(match5.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match6), + "Terms should be equalModRenaming."); } @Test From 7aa78deaa2f3550642c00e544f82565c41463ed1 Mon Sep 17 00:00:00 2001 From: Tobias Date: Sat, 23 Dec 2023 18:29:12 +0100 Subject: [PATCH 07/22] replace equalsModTermLabels and equalsModRenaming with equalsModProperty --- .../StartAuxiliaryBlockComputationMacro.java | 4 +++- .../StartAuxiliaryLoopComputationMacro.java | 4 +++- .../StartAuxiliaryMethodComputationMacro.java | 4 +++- .../uka/ilkd/key/logic/BoundVariableTools.java | 6 ++++-- .../java/de/uka/ilkd/key/logic/Semisequent.java | 5 ++++- .../de/uka/ilkd/key/logic/SequentFormula.java | 8 ++++---- .../ilkd/key/logic/label/TermLabelManager.java | 5 ++++- .../ilkd/key/macros/scripts/FocusCommand.java | 8 ++++++-- .../ilkd/key/macros/scripts/HideCommand.java | 4 +++- .../key/macros/scripts/InstantiateCommand.java | 11 ++++++++--- .../ilkd/key/macros/scripts/RewriteCommand.java | 8 ++++++-- .../ilkd/key/macros/scripts/RuleCommand.java | 6 ++++-- .../ilkd/key/macros/scripts/SelectCommand.java | 4 +++- .../java/de/uka/ilkd/key/proof/OpReplacer.java | 4 +++- .../ilkd/key/proof/join/JoinIsApplicable.java | 6 ++++-- .../de/uka/ilkd/key/rule/OneStepSimplifier.java | 7 +++++-- .../conditions/ApplyUpdateOnRigidCondition.java | 4 +++- .../key/rule/match/legacy/ElementMatcher.java | 4 +++- .../ilkd/key/rule/match/vm/VMTacletMatcher.java | 4 +++- .../MatchSchemaVariableInstruction.java | 4 +++- .../de/uka/ilkd/key/rule/merge/MergeRule.java | 3 ++- .../uka/ilkd/key/smt/AbstractSMTTranslator.java | 17 ++++++++++------- .../uka/ilkd/key/smt/newsmt2/SeqDefHandler.java | 4 +++- .../ilkd/key/smt/newsmt2/SumProdHandler.java | 6 ++++-- .../uka/ilkd/key/speclang/ContractFactory.java | 3 ++- .../FunctionalOperationContractImpl.java | 15 +++++++++------ .../jml/translation/JMLSpecFactory.java | 6 ++++-- .../strategy/feature/ContainsTermFeature.java | 4 +++- .../feature/DependencyContractFeature.java | 5 ++++- ...IsSubFormulaOfInfFlowContractAppFeature.java | 4 +++- .../quantifierHeuristics/PredictCostProver.java | 5 +++-- .../key/strategy/termfeature/EqTermFeature.java | 4 +++- .../ilkd/key/util/mergerule/MergeRuleUtils.java | 6 ++++-- 33 files changed, 133 insertions(+), 59 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java index 5438464d94c..9f927722325 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java @@ -24,6 +24,8 @@ import org.key_project.util.collection.ImmutableList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * @@ -78,7 +80,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_BLOCK_WITH_PRE_RELATION); - return posInOcc.subTerm().equalsModRenaming(selfComposedExec); + return posInOcc.subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, selfComposedExec); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java index 2d8087f9aee..f5a229c2348 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java @@ -25,6 +25,8 @@ import org.key_project.util.collection.ImmutableList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + public class StartAuxiliaryLoopComputationMacro extends AbstractProofMacro implements StartSideProofMacro { @@ -75,7 +77,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_LOOP_WITH_INV_RELATION); - return posInOcc.subTerm().equalsModRenaming(selfComposedExec); + return posInOcc.subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, selfComposedExec); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java index bac101e8534..81af3b4b44e 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java @@ -22,6 +22,8 @@ import org.key_project.util.collection.ImmutableList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * * @author christoph @@ -67,7 +69,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_EXECUTION_WITH_PRE_RELATION); - return posInOcc.subTerm().equalsModRenaming(selfComposedExec); + return posInOcc.subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, selfComposedExec); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java index b985dcdf7a7..47182521581 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java @@ -13,6 +13,8 @@ import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * Some generally useful tools for dealing with arrays of bound variables @@ -206,7 +208,7 @@ public boolean equalsModRenaming(ImmutableArray vars0, Ter return false; } if (vars0.size() == 0) { - return term0.equalsModRenaming(term1); + return term0.equalsModProperty(RENAMING_TERM_PROPERTY, term1); } final ImmutableArray unifiedVars = unifyVariableArrays(vars0, vars1, @@ -215,7 +217,7 @@ public boolean equalsModRenaming(ImmutableArray vars0, Ter final Term renamedTerm0 = renameVariables(term0, vars0, unifiedVars, services); final Term renamedTerm1 = renameVariables(term1, vars1, unifiedVars, services); - return renamedTerm0.equalsModRenaming(renamedTerm1); + return renamedTerm0.equalsModProperty(RENAMING_TERM_PROPERTY, renamedTerm1); } /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java index 0a210bd3c57..40bb4ed5679 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java @@ -8,6 +8,8 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * This class represents the succedent or antecendent part of a sequent. It is more or less a list @@ -157,7 +159,8 @@ private SemisequentChangeInfo insertAndRemoveRedundancyHelper(int idx, searchList = searchList.tail(); if (sequentFormula != null - && cf.formula().equalsModRenaming(sequentFormula.formula())) { + && cf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, + sequentFormula.formula())) { semiCI.rejectedFormula(sequentFormula); return semiCI; // semisequent already contains formula diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java b/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java index 493059c1af8..ef63cee629e 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java @@ -8,6 +8,8 @@ import org.key_project.util.EqualsModProofIrrelevancy; +import static de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty.PROOF_IRRELEVANCY_PROPERTY; + /** * A sequent formula is a wrapper around a formula that occurs as top level formula in a sequent. @@ -41,7 +43,7 @@ public SequentFormula(Term term) { } this.term = term; this.hashCode = term.hashCode() * 13; - this.hashCode2 = term.hashCodeModProofIrrelevancy(); + this.hashCode2 = term.hashCodeModProperty(PROOF_IRRELEVANCY_PROPERTY); } /** @return the stored Term */ @@ -75,9 +77,7 @@ public boolean equalsModProofIrrelevancy(Object obj) { return true; } if (obj instanceof SequentFormula cmp) { - if (term.equalsModProofIrrelevancy(cmp.formula())) { - return true; - } + return term.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, cmp.formula()); } return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java index e52cead7707..96e817e25ec 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java @@ -29,6 +29,8 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.java.CollectionUtil; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** *

* This class provides access to the functionality of term labels. @@ -2010,7 +2012,8 @@ protected void mergeLabels(SequentChangeInfo currentSequent, Services services, // Search existing SequentFormula Semisequent s = currentSequent.getSemisequentChangeInfo(inAntecedent).semisequent(); SequentFormula existingSF = CollectionUtil.search(s, - element -> element.formula().equalsModRenaming(rejectedTerm)); + element -> element.formula().equalsModProperty(RENAMING_TERM_PROPERTY, + rejectedTerm)); if (existingSF != null) { // Create list of new labels Term existingTerm = existingSF.formula(); diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java index 9f36f0212cd..045f08b5ca9 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java @@ -18,6 +18,8 @@ import org.key_project.util.collection.ImmutableList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * The command "focus" allows you to select formulas from the current sequent * to focus verification on. This means that all other formulas are discarded @@ -75,7 +77,8 @@ private void hideAll(Sequent toKeep) throws ScriptException { for (SequentFormula seqFormula : ante) { // This means "!keepAnte.contains(seqFormula.formula)" but with equality mod renaming! - if (!keepAnte.exists(it -> it.equalsModRenaming(seqFormula.formula()))) { + if (!keepAnte.exists( + it -> it.equalsModProperty(RENAMING_TERM_PROPERTY, seqFormula.formula()))) { Taclet tac = getHideTaclet("left"); makeTacletApp(goal, seqFormula, tac, true); } @@ -84,7 +87,8 @@ private void hideAll(Sequent toKeep) throws ScriptException { ImmutableList keepSucc = toKeep.succedent().asList().map(SequentFormula::formula); ImmutableList succ = goal.sequent().succedent().asList(); for (SequentFormula seqFormula : succ) { - if (!keepSucc.exists(it -> it.equalsModRenaming(seqFormula.formula()))) { + if (!keepSucc.exists( + it -> it.equalsModProperty(RENAMING_TERM_PROPERTY, seqFormula.formula()))) { Taclet tac = getHideTaclet("right"); makeTacletApp(goal, seqFormula, tac, false); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java index b8e9371060a..24055e2ae3c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java @@ -18,6 +18,8 @@ import de.uka.ilkd.key.rule.Taclet; import de.uka.ilkd.key.rule.TacletApp; +import static de.uka.ilkd.key.logic.equality.TermLabelsProperty.TERM_LABELS_PROPERTY; + /** * Proof script command to hide a formula from the sequent. * @@ -78,7 +80,7 @@ public void execute(Parameters args) throws ScriptException, InterruptedExceptio private SequentFormula find(SequentFormula sf, Semisequent semiseq) throws ScriptException { for (SequentFormula s : semiseq) { - if (s.formula().equalsModTermLabels(sf.formula())) { + if (s.formula().equalsModProperty(TERM_LABELS_PROPERTY, sf.formula())) { return s; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java index c10e64e1cd2..8cb4844c4c8 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java @@ -24,6 +24,8 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * instantiate var=a occ=2 with="a_8" hide *

@@ -107,7 +109,8 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta ImmutableList allApps = ImmutableSLList.nil(); for (SequentFormula sf : g.node().sequent().antecedent()) { - if (p.formula != null && !sf.formula().equalsModRenaming(p.formula)) { + if (p.formula != null + && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -115,7 +118,8 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta } for (SequentFormula sf : g.node().sequent().succedent()) { - if (p.formula != null && !sf.formula().equalsModRenaming(p.formula)) { + if (p.formula != null + && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -131,7 +135,8 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta private TacletApp filterList(Parameters p, ImmutableList list) { for (TacletApp tacletApp : list) { if (tacletApp instanceof PosTacletApp pta) { - if (pta.posInOccurrence().subTerm().equalsModRenaming(p.formula)) { + if (pta.posInOccurrence().subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, + p.formula)) { return pta; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java index 24a820da811..3c267ad0265 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java @@ -22,6 +22,8 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * This class provides the command rewrite. *

@@ -111,7 +113,8 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta // filter taclets that are applicable on the given formula in the antecedent for (SequentFormula sf : g.node().sequent().antecedent()) { - if (p.formula != null && !sf.formula().equalsModRenaming(p.formula)) { + if (p.formula != null + && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -120,7 +123,8 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta // filter taclets that are applicable on the given formula in the succedent for (SequentFormula sf : g.node().sequent().succedent()) { - if (p.formula != null && !sf.formula().equalsModRenaming(p.formula)) { + if (p.formula != null + && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java index 90763179ed7..7eafa9f5b6e 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java @@ -23,6 +23,7 @@ import org.key_project.util.collection.ImmutableSLList; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; /** * Command that applies a calculus rule All parameters are passed as strings and converted by the @@ -316,7 +317,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta private boolean isFormulaSearchedFor(Parameters p, SequentFormula sf, Services services) throws ScriptException { final boolean satisfiesFormulaParameter = - p.formula != null && sf.formula().equalsModRenaming(p.formula); + p.formula != null && sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula); final boolean satisfiesMatchesParameter = p.matches != null && formatTermString(LogicPrinter.quickPrintTerm(sf.formula(), services)) @@ -346,7 +347,8 @@ private List filterList(Parameters p, ImmutableList list) for (TacletApp tacletApp : list) { if (tacletApp instanceof PosTacletApp pta) { boolean add = - p.on == null || pta.posInOccurrence().subTerm().equalsModRenaming(p.on); + p.on == null || pta.posInOccurrence().subTerm() + .equalsModProperty(RENAMING_TERM_PROPERTY, p.on); Iterator it = pta.instantiations().svIterator(); while (it.hasNext()) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java index 0fb1b181bad..77c44d820b3 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java @@ -20,6 +20,8 @@ import org.key_project.util.collection.ImmutableList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + public class SelectCommand extends AbstractCommand { public SelectCommand() { super(Parameters.class); @@ -133,7 +135,7 @@ private boolean contains(Sequent seq, Term formula) { private boolean contains(Semisequent semiseq, Term formula) { for (SequentFormula sf : semiseq.asList()) { - if (sf.formula().equalsModRenaming(formula)) { + if (sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, formula)) { return true; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java b/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java index 3cc4f7c5e01..6bf1d49781b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java +++ b/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java @@ -19,6 +19,8 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.TermLabelsProperty.TERM_LABELS_PROPERTY; + /** * Replaces operators in a term by other operators with the same signature, or subterms of the term @@ -233,7 +235,7 @@ public Term replace(Term term) { } for (SVSubstitute svs : map.keySet()) { - if (term.equalsModTermLabels(svs)) { + if (term.equalsModProperty(TERM_LABELS_PROPERTY, svs)) { return (Term) map.get(svs); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java index 8cf5534c20c..b54e54aabbc 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java +++ b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java @@ -13,6 +13,8 @@ import de.uka.ilkd.key.logic.op.UpdateApplication; import de.uka.ilkd.key.proof.Goal; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * Methods for checking the applicability of a join for a given selection and thereby computing the * prospective join partners. @@ -89,13 +91,13 @@ private ProspectivePartner areProspectivePartners(Goal g1, PosInOccurrence pio, Term formula = sf.formula(); Term update2 = tb.skip(); if (formula.op() instanceof UpdateApplication - && !formula.equalsModRenaming(referenceFormula)) { + && !formula.equalsModProperty(RENAMING_TERM_PROPERTY, referenceFormula)) { update2 = formula.sub(0);// don't change the order of this and // the following line. formula = formula.sub(1); } - if (formula.equalsModRenaming(referenceFormula)) { + if (formula.equalsModProperty(RENAMING_TERM_PROPERTY, referenceFormula)) { return new ProspectivePartner(referenceFormula, g1.node(), pio.sequentFormula(), update1, g2.node(), sf, update2); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java index 2e39d09875b..66ca9b690f9 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java @@ -46,6 +46,8 @@ import org.jspecify.annotations.NonNull; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + public final class OneStepSimplifier implements BuiltInRule { @@ -747,8 +749,9 @@ public boolean equals(Object obj) { obj = ((TermReplacementKey) obj).term; } if (obj instanceof Term t) { - return term.equalsModRenaming(t); // Ignore naming and term labels in the way a - // taclet rule does. + return term.equalsModProperty(RENAMING_TERM_PROPERTY, t); // Ignore naming and term + // labels in the way a + // taclet rule does. } else { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java index 03b005fbb9f..e2288ca14ed 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java @@ -15,6 +15,8 @@ import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * This variable condition can be used to check whether an update can be performed on a formula or @@ -212,7 +214,7 @@ public MatchConditions check(SchemaVariable var, SVSubstitute instCandidate, Mat if (resultInst == null) { svInst = svInst.add(result, properResultInst, services); return mc.setInstantiations(svInst); - } else if (resultInst.equalsModRenaming(properResultInst)) { + } else if (resultInst.equalsModProperty(RENAMING_TERM_PROPERTY, properResultInst)) { return mc; } else { return null; diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java index 8fe75e0e53d..bb709c74e68 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java @@ -17,6 +17,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + public abstract class ElementMatcher { public static final Logger LOGGER = LoggerFactory.getLogger(ElementMatcher.class); @@ -123,7 +125,7 @@ protected final MatchConditions addInstantiation(AbstractSV op, Term term, final Term t = inst.getTermInstantiation(op, inst.getExecutionContext(), services); if (t != null) { - if (!t.equalsModRenaming(term)) { + if (!t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { LOGGER.debug( "FAILED. Adding instantiations leads to unsatisfiable constraint. {} {}", op, term); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java index 416f0b58201..e2dbf7c3932 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java @@ -35,6 +35,8 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** *

* Matching algorithm using a virtual machine based approach inspired by Voronkonv et al. It matches @@ -165,7 +167,7 @@ private Term matchUpdateContext(ImmutableList context, Term for if (formula.op() instanceof UpdateApplication) { final Term update = UpdateApplication.getUpdate(formula); final UpdateLabelPair ulp = curContext.head(); - if (ulp.update().equalsModRenaming(update) + if (ulp.update().equalsModProperty(RENAMING_TERM_PROPERTY, update) && ulp.updateApplicationlabels().equals(update.getLabels())) { curContext = curContext.tail(); formula = UpdateApplication.getTarget(formula); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java index 596df54df81..78313afd9ad 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java @@ -14,6 +14,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + public abstract class MatchSchemaVariableInstruction extends Instruction { private static final Logger LOGGER = @@ -40,7 +42,7 @@ protected final MatchConditions addInstantiation(Term term, MatchConditions matc final Term t = inst.getTermInstantiation(op, inst.getExecutionContext(), services); if (t != null) { - if (!t.equalsModRenaming(term)) { + if (!t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { return null; } else { return matchCond; diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java index a246ee47aea..272561b7c82 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java @@ -49,6 +49,7 @@ import org.jspecify.annotations.NonNull; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.clearSemisequent; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.closeMergePartnerGoal; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.getConjunctiveElementsFor; @@ -356,7 +357,7 @@ protected Triple, LinkedHashSet qu Services services) throws IllegalFormulaException { // check, if the modality was already translated. for (Term toMatch : modalityPredicates.keySet()) { - if (toMatch.equalsModRenaming(t)) { + if (toMatch.equalsModProperty(RENAMING_TERM_PROPERTY, t)) { return modalityPredicates.get(toMatch); } } @@ -2249,7 +2252,7 @@ protected final StringBuilder translateBsumFunction(Term bsumterm, ArrayList sub) { StringBuilder name = null; for (Term t : usedBsumTerms.keySet()) { - if (t.equalsModRenaming(bsumterm)) { + if (t.equalsModProperty(RENAMING_TERM_PROPERTY, bsumterm)) { name = usedBsumTerms.get(t); } } @@ -2287,7 +2290,7 @@ protected final StringBuilder translateBprodFunction(Term bprodterm, ArrayList sub) { StringBuilder name = null; for (Term t : usedBprodTerms.keySet()) { - if (t.equalsModRenaming(bprodterm)) { + if (t.equalsModProperty(RENAMING_TERM_PROPERTY, bprodterm)) { name = usedBprodTerms.get(t); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java index 4044e03f155..15f7d9d7176 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java @@ -29,6 +29,8 @@ import org.key_project.util.collection.DefaultImmutableSet; import org.key_project.util.collection.ImmutableSet; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * This handler handles the seqDef binder function specially. * @@ -78,7 +80,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti (Map) state.computeIfAbsent("SEQDEF_MAP", x -> new LinkedHashMap<>()); for (Entry entry : seqDefMap.entrySet()) { - if (entry.getKey().equalsModRenaming(term)) { + if (entry.getKey().equalsModProperty(RENAMING_TERM_PROPERTY, term)) { return entry.getValue(); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java index 2b636e81103..ac9dbb940bb 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java @@ -11,6 +11,8 @@ import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.smt.SMTTranslationException; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + // W I P public class SumProdHandler implements SMTHandler { @@ -41,7 +43,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti Operator op = term.op(); if (op == bsumOp) { for (Term t : usedBsumTerms.keySet()) { - if (t.equalsModRenaming(term)) { + if (t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { return usedBsumTerms.get(t); } } @@ -55,7 +57,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti return ret; } else if (op == bprodOp) { for (Term t : usedBprodTerms.keySet()) { - if (t.equalsModRenaming(term)) { + if (t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { return usedBprodTerms.get(t); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java index 1ac725e4ecb..fbf3162abbe 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java @@ -27,6 +27,7 @@ import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableList; +import static de.uka.ilkd.key.logic.equality.TermLabelsProperty.TERM_LABELS_PROPERTY; import static de.uka.ilkd.key.logic.label.OriginTermLabel.*; /** @@ -453,7 +454,7 @@ private static void combineModifies(FunctionalOperationContractImpl t, // check if the other mod is the same as the one in the uniform store. // To obtain meaningful results, check for equality ignoring all term labels! if (uniformMod.containsKey(h)) { - if (!uniformMod.get(h).equalsModTermLabels(m2)) { + if (!uniformMod.get(h).equalsModProperty(TERM_LABELS_PROPERTY, m2)) { uniformMod.remove(h); } else { // merge term labels (in particular origin labels) of both modifies diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java index a34b12930fc..8652f6565d4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java @@ -33,6 +33,7 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.java.MapUtil; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.util.Assert.assertEqualSort; import static de.uka.ilkd.key.util.Assert.assertSubSort; @@ -1365,14 +1366,16 @@ public String toString() { ((Services) services).getTypeConverter().getHeapLDT().getHeap(); return (globalDefs == null ? "" : "defs: " + globalDefs + "; ") + "pre: " + originalPres + (originalFreePres.get(heap) != null - && !originalFreePres.get(heap).equalsModRenaming(tb.tt()) - ? "free pre: " + originalFreePres - : "") + && !originalFreePres.get(heap).equalsModProperty(RENAMING_TERM_PROPERTY, + tb.tt()) + ? "free pre: " + originalFreePres + : "") + "; mby: " + originalMby + "; post: " + originalPosts + (originalFreePosts.get(heap) != null - && !originalFreePosts.get(heap).equalsModRenaming(tb.tt()) - ? "free post: " + originalFreePosts - : "") + && !originalFreePosts.get(heap).equalsModProperty(RENAMING_TERM_PROPERTY, + tb.tt()) + ? "free post: " + originalFreePosts + : "") + "; mods: " + originalMods + "; hasMod: " + hasRealModifiesClause + (originalAxioms != null && originalAxioms.size() > 0 ? ("; axioms: " + originalAxioms) : "") diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java index 269f4e70ea7..237db934aa8 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java @@ -52,6 +52,7 @@ import org.jspecify.annotations.Nullable; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.DIVERGES; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.SIGNALS; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.ClauseHd.ENSURES; @@ -971,13 +972,14 @@ private ImmutableSet createDependencyOperationContract(IProgramMethod boolean createContract = true; for (LocationVariable heap : HeapContext.getModHeaps(services, false)) { - if (clauses.accessibles.get(heap).equalsModRenaming(tb.allLocs())) { + if (clauses.accessibles.get(heap).equalsModProperty(RENAMING_TERM_PROPERTY, + tb.allLocs())) { createContract = false; break; } if (pm.isModel() && pm.getStateCount() > 1) { if (clauses.accessibles.get(progVars.atPreVars.get(heap)) - .equalsModRenaming(tb.allLocs())) { + .equalsModProperty(RENAMING_TERM_PROPERTY, tb.allLocs())) { createContract = false; break; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java index c28f79d270a..61457b019b9 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java @@ -13,6 +13,8 @@ import de.uka.ilkd.key.strategy.TopRuleAppCost; import de.uka.ilkd.key.strategy.termProjection.ProjectionToTerm; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * Feature for checking if the term of the first projection contains the term of the second @@ -81,7 +83,7 @@ public boolean visitSubtree(Term visited) { @Override public void visit(Term visited) { - found = found || visited.equalsModRenaming(term); + found = found || visited.equalsModProperty(RENAMING_TERM_PROPERTY, term); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java index cdbe4d79f9b..1158049e24c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java @@ -17,12 +17,15 @@ import org.key_project.util.collection.ImmutableSLList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + public final class DependencyContractFeature extends BinaryFeature { private void removePreviouslyUsedSteps(Term focus, Goal goal, List steps) { for (RuleApp app : goal.appliedRuleApps()) { if (app.rule() instanceof UseDependencyContractRule - && app.posInOccurrence().subTerm().equalsModRenaming(focus)) { + && app.posInOccurrence().subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, + focus)) { final IBuiltInRuleApp bapp = (IBuiltInRuleApp) app; for (PosInOccurrence ifInst : bapp.ifInsts()) { steps.remove(ifInst); diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java index 485ab6c93c7..e96f9aabf3a 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java @@ -16,6 +16,8 @@ import org.key_project.util.collection.ImmutableList; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * Checks whether the focus of the ruleApp is contained in one of the formulas added by information @@ -82,7 +84,7 @@ public SubFormulaVisitor(Term potentialSub) { @Override public void visit(Term visited) { - isSubFormula |= visited.equalsModRenaming(potentialSub); + isSubFormula |= visited.equalsModProperty(RENAMING_TERM_PROPERTY, potentialSub); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java index 723d19535b3..c17d11dcf8a 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java @@ -18,6 +18,7 @@ import org.key_project.util.collection.ImmutableSet; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; /** * TODO: rewrite, this seems pretty inefficient ... @@ -104,7 +105,7 @@ private Term provedBySelf(Term problem) { op = pro.op(); } if ((op == Equality.EQUALS || op == Equality.EQV) - && pro.sub(0).equalsModRenaming(pro.sub(1))) { + && pro.sub(0).equalsModProperty(RENAMING_TERM_PROPERTY, pro.sub(1))) { return negated ? falseT : trueT; } Term arithRes = HandleArith.provedByArith(pro, services); @@ -132,7 +133,7 @@ private Term directConsequenceOrContradictionOfAxiom(Term problem, Term axiom) { ax = ax.sub(0); negated = !negated; } - if (pro.equalsModRenaming(ax)) { + if (pro.equalsModProperty(RENAMING_TERM_PROPERTY, ax)) { return negated ? falseT : trueT; } return problem; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java index b5ea4a4938c..b1f5f5c69af 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java @@ -8,6 +8,8 @@ import de.uka.ilkd.key.strategy.feature.MutableState; import de.uka.ilkd.key.strategy.termProjection.TermBuffer; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * Term feature for testing equality of two terms. The feature returns zero iff it is invoked on a * term that is equal to the current value of pattern. @@ -29,6 +31,6 @@ private EqTermFeature(TermBuffer pattern) { @Override protected boolean filter(Term term, MutableState mState, Services services) { - return term.equalsModRenaming(pattern.getContent(mState)); + return term.equalsModProperty(RENAMING_TERM_PROPERTY, pattern.getContent(mState)); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java b/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java index 0d023fa3d02..7ca290362bb 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java +++ b/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java @@ -40,6 +40,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * This class encapsulates static methods used in the MergeRule implementation. The methods are * organized into different sections (see comments): @@ -1689,7 +1691,7 @@ static class TermWrapperFactory { public TermWrapper wrapTerm(Term term) { for (Term existingTerm : wrappedTerms) { - if (existingTerm.equalsModRenaming(term)) { + if (existingTerm.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { return new TermWrapper(term, existingTerm.hashCode()); } } @@ -1720,7 +1722,7 @@ record TermWrapper(Term term, int hashcode) { @Override public boolean equals(Object obj) { return obj instanceof TermWrapper - && term.equalsModRenaming(((TermWrapper) obj).term()); + && term.equalsModProperty(RENAMING_TERM_PROPERTY, ((TermWrapper) obj).term()); } @Override From 220724722ff5b86d2c6e06b86533235a26e6cbff Mon Sep 17 00:00:00 2001 From: Tobias Date: Mon, 25 Dec 2023 17:26:05 +0100 Subject: [PATCH 08/22] remove EqualsModProofIrrelevancy from LabeledTermImpl --- .../uka/ilkd/key/logic/LabeledTermImpl.java | 60 ++++++------------- .../equality/ProofIrrelevancyProperty.java | 59 ++++++++++++------ 2 files changed, 59 insertions(+), 60 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java index a81f9cfa635..fcd82e6402c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java @@ -6,6 +6,9 @@ import java.util.Objects; import java.util.stream.Collectors; +import de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty; +import de.uka.ilkd.key.logic.equality.RenamingTermProperty; +import de.uka.ilkd.key.logic.equality.TermProperty; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.logic.op.QuantifiableVariable; @@ -15,16 +18,26 @@ import org.key_project.util.java.CollectionUtil; /** + *

* The labeled term class is used for terms that have a label attached. + *

+ * + * Two labeled terms are equal if they have equal term structure and equal annotations. In contrast, + * the method {@link Term#equalsModProperty(TermProperty, Object)} can be used to compare terms + * while ignoring certain + * given properties. E.g. by using {@link RenamingTermProperty#RENAMING_TERM_PROPERTY}, just the + * term structures modulo + * renaming are compared whilst ignoring annotations. + *

+ * Prior implementations of {@link EqualsModProofIrrelevancy} are now in + * {@link ProofIrrelevancyProperty}. + *

* - * Two labeled terms are equal if they have equal term structure and equal annotations. In contrast - * the method {@link Term#equalsModRenaming(Term)} does not care about annotations and will just - * compare the term structure alone modula renaming. * * @see Term * @see TermImpl */ -class LabeledTermImpl extends TermImpl implements EqualsModProofIrrelevancy { +class LabeledTermImpl extends TermImpl { /** * @see #getLabels() @@ -38,7 +51,7 @@ class LabeledTermImpl extends TermImpl implements EqualsModProofIrrelevancy { * @param subs the Term that are the subterms of this term * @param boundVars logic variables bound by the operator * @param javaBlock contains the program part of the term (if any) - * @param labels the terms labels (must not be null or empty) + * @param labels the term's labels (must not be null or empty) * @param origin a String with origin information */ public LabeledTermImpl(Operator op, ImmutableArray subs, @@ -144,43 +157,6 @@ public int computeHashCode() { return hash; } - @Override - public boolean equalsModProofIrrelevancy(Object o) { - if (!super.equalsModProofIrrelevancy(o)) { - return false; - } - - if (o instanceof LabeledTermImpl cmp) { - if (labels.size() == cmp.labels.size()) { - for (int i = 0, sz = labels.size(); i < sz; i++) { - // skip irrelevant (origin) labels that differ for no real reason - if (!labels.get(i).isProofRelevant()) { - continue; - } - // this is not optimal, but as long as number of labels limited ok - if (!cmp.labels.contains(labels.get(i))) { - return false; - } - } - return true; - } - return false; - } else { - return o.getClass() == TermImpl.class; - } - } - - @Override - public int hashCodeModProofIrrelevancy() { - int hash = super.hashCodeModProofIrrelevancy(); - for (int i = 0, sz = labels.size(); i < sz; i++) { - if (labels.get(i).isProofRelevant()) { - hash += 7 * labels.get(i).hashCode(); - } - } - return hash; - } - @Override public String toString() { StringBuilder result = new StringBuilder(super.toString()); diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index 751c9e1413c..25ba006db2c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -3,11 +3,11 @@ * SPDX-License-Identifier: GPL-2.0-only */ package de.uka.ilkd.key.logic.equality; -import java.util.Objects; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.label.TermLabel; +import org.key_project.util.EqualsModProofIrrelevancy; import org.key_project.util.EqualsModProofIrrelevancyUtil; import org.key_project.util.collection.ImmutableArray; @@ -29,8 +29,11 @@ private ProofIrrelevancyProperty() {} /** * Checks if {@code o} is a term syntactically equal to {@code term}, except for attributes that - * are not relevant - * for the purpose of these terms in the proof. + * are not relevant for the purpose of these terms in the proof. + *

+ * Combines the prior implementations of {@link EqualsModProofIrrelevancy} in TermImpl and + * LabeledTermImpl. + *

* * @param term a term * @param o the object compared to {@code term} @@ -77,31 +80,51 @@ public Boolean equalsModThisProperty(Term term, Object o) { } } + // This would be the only new thing from LabeledTermImpl, but this doesn't seem right + if (term.hasLabels() && other.hasLabels()) { + if (other.getLabels().size() != term.getLabels().size()) { + return false; + } + } + return true; } /** + *

* Computes a hashcode that represents the proof-relevant fields of {@code term}. + *

+ * Combines the prior implementations of {@link EqualsModProofIrrelevancy} in TermImpl and + * LabeledTermImpl. * * @param term the term to compute the hashcode for * @return the hashcode */ @Override public int hashCodeModThisProperty(Term term) { - int hashcode2 = -1; // this line is just so the code compiles - if (hashcode2 == -1) { - // compute into local variable first to be thread-safe. - hashcode2 = Objects.hash(term.op(), - EqualsModProofIrrelevancyUtil - .hashCodeIterable(term.subs()), - EqualsModProofIrrelevancyUtil.hashCodeIterable(term.boundVars()), term.javaBlock()); - if (hashcode2 == -1) { - hashcode2 = 0; - } - } - return hashcode2; - // throw new UnsupportedOperationException("Hashing of terms modulo term proof-irrelevancy - // not yet implemented!"); - + // int hashcode2 = -1; // this line is just so the code compiles + // // part from TermImpl + // if (hashcode2 == -1) { + // // compute into local variable first to be thread-safe. + // hashcode2 = Objects.hash(term.op(), + // EqualsModProofIrrelevancyUtil + // .hashCodeIterable(term.subs()), + // EqualsModProofIrrelevancyUtil.hashCodeIterable(term.boundVars()), term.javaBlock()); + // if (hashcode2 == -1) { + // hashcode2 = 0; + // } + // } + // // part from LabeledTermImpl + // final ImmutableArray labels = term.getLabels(); + // final int numOfLabels = labels.size(); + // for (int i = 0; i < numOfLabels; i++) { + // final TermLabel currentLabel = labels.get(i); + // if (currentLabel.isProofRelevant()) { + // hashcode2 += 7 * currentLabel.hashCode(); + // } + // } + // return hashcode2; + throw new UnsupportedOperationException( + "Hashing of terms modulo term proof-irrelevancy not yet implemented!"); } } From 6bba0cc9c73337b64b7e4f4be597265f2ef9407c Mon Sep 17 00:00:00 2001 From: Tobias Date: Thu, 28 Dec 2023 13:38:57 +0100 Subject: [PATCH 09/22] add last calls of equalsModProperty that slipped through --- .../util/SymbolicExecutionUtil.java | 56 ++++++++++++------- .../uka/ilkd/key/parser/TestTermParser.java | 4 +- .../de/uka/ilkd/key/rule/TestApplyTaclet.java | 3 +- .../TestApplyUpdateOnRigidCondition.java | 17 +++--- .../key/smt/newsmt2/ProveSMTLemmasTest.java | 4 +- .../key/speclang/jml/TestJMLTranslator.java | 15 ++--- 6 files changed, 63 insertions(+), 36 deletions(-) diff --git a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java index 705ca8f16cd..2994e453544 100644 --- a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java +++ b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java @@ -71,6 +71,9 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * Provides utility methods for symbolic execution with KeY. * @@ -387,7 +390,7 @@ else if (term.op() == Junctor.NOT) { * @return true if the term represents the one */ private static boolean isOne(Term subOne, IntegerLDT integerLDT) { - return subOne.equalsModIrrelevantTermLabels(integerLDT.one()); + return subOne.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, integerLDT.one()); } /** @@ -1976,13 +1979,16 @@ private static void collectSpecifcationCasesPreconditions(Term normalExcDefiniti List exceptinalConditions) throws ProofInputException { if (term.op() == Junctor.AND) { Term lastChild = term.sub(term.arity() - 1); - if (lastChild.equalsModIrrelevantTermLabels(normalExcDefinition) - || lastChild.equalsModIrrelevantTermLabels(exceptionalExcDefinition)) { + if (lastChild.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, normalExcDefinition) + || lastChild.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + exceptionalExcDefinition)) { // Nothing to do, condition is just true } else { Term firstChild = term.sub(0); - if (firstChild.equalsModIrrelevantTermLabels(normalExcDefinition) - || firstChild.equalsModIrrelevantTermLabels(exceptionalExcDefinition)) { + if (firstChild + .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, normalExcDefinition) + || firstChild.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + exceptionalExcDefinition)) { // Nothing to do, condition is just true } else { for (int i = 0; i < term.arity(); i++) { @@ -1994,27 +2000,32 @@ private static void collectSpecifcationCasesPreconditions(Term normalExcDefiniti } } else if (term.op() == Junctor.IMP) { Term leftTerm = term.sub(0); - if (leftTerm.equalsModIrrelevantTermLabels(normalExcDefinition) - || leftTerm.equalsModIrrelevantTermLabels(exceptionalExcDefinition)) { + if (leftTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, normalExcDefinition) + || leftTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + exceptionalExcDefinition)) { // Nothing to do, condition is just true } else { Term rightTerm = term.sub(1); // Deal with heavy weight specification cases if (rightTerm.op() == Junctor.AND && rightTerm.sub(0).op() == Junctor.IMP && rightTerm.sub(0).sub(0) - .equalsModIrrelevantTermLabels(normalExcDefinition)) { + .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + normalExcDefinition)) { normalConditions.add(leftTerm); } else if (rightTerm.op() == Junctor.AND && rightTerm.sub(1).op() == Junctor.IMP && rightTerm.sub(1).sub(0) - .equalsModIrrelevantTermLabels(exceptionalExcDefinition)) { + .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + exceptionalExcDefinition)) { exceptinalConditions.add(leftTerm); } // Deal with light weight specification cases else if (rightTerm.op() == Junctor.IMP - && rightTerm.sub(0).equalsModIrrelevantTermLabels(normalExcDefinition)) { + && rightTerm.sub(0).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + normalExcDefinition)) { normalConditions.add(leftTerm); } else if (rightTerm.op() == Junctor.IMP && rightTerm.sub(0) - .equalsModIrrelevantTermLabels(exceptionalExcDefinition)) { + .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + exceptionalExcDefinition)) { exceptinalConditions.add(leftTerm); } else { Term excCondition = rightTerm; @@ -2022,19 +2033,23 @@ else if (rightTerm.op() == Junctor.IMP if (excCondition.op() == Junctor.AND) { excCondition = excCondition.sub(excCondition.arity() - 1); } - if (excCondition.equalsModIrrelevantTermLabels(normalExcDefinition)) { + if (excCondition.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + normalExcDefinition)) { normalConditions.add(leftTerm); } else if (excCondition - .equalsModIrrelevantTermLabels(exceptionalExcDefinition)) { + .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + exceptionalExcDefinition)) { exceptinalConditions.add(leftTerm); } else { // Check if left child is exception definition if (rightTerm.op() == Junctor.AND) { excCondition = rightTerm.sub(0); - if (excCondition.equalsModIrrelevantTermLabels(normalExcDefinition)) { + if (excCondition.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + normalExcDefinition)) { normalConditions.add(leftTerm); } else if (excCondition - .equalsModIrrelevantTermLabels(exceptionalExcDefinition)) { + .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + exceptionalExcDefinition)) { exceptinalConditions.add(leftTerm); } else { throw new ProofInputException("Exeptional condition expected, " @@ -2661,7 +2676,7 @@ private static boolean checkReplaceTerm(Term toCheck, PosInOccurrence posInOccur Term replaceTerm) { Term termAtPio = followPosInOccurrence(posInOccurrence, toCheck); if (termAtPio != null) { - return termAtPio.equalsModRenaming(replaceTerm); + return termAtPio.equalsModProperty(RENAMING_TERM_PROPERTY, replaceTerm); } else { return false; } @@ -3407,11 +3422,13 @@ private static List findSkolemReplacements(Sequent sequent, Term skolemCon if (term != skolemEquality) { int skolemCheck = checkSkolemEquality(term); if (skolemCheck == -1) { - if (term.sub(0).equalsModIrrelevantTermLabels(skolemConstant)) { + if (term.sub(0).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + skolemConstant)) { result.add(term.sub(1)); } } else if (skolemCheck == 1) { - if (term.sub(1).equalsModIrrelevantTermLabels(skolemConstant)) { + if (term.sub(1).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + skolemConstant)) { result.add(term.sub(0)); } } @@ -3501,7 +3518,8 @@ public static Term computePathCondition(Node parentNode, Node childNode, boolean } childNode = parent; } - if (services.getTermBuilder().ff().equalsModIrrelevantTermLabels(pathCondition)) { + if (services.getTermBuilder().ff().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, + pathCondition)) { throw new ProofInputException( "Path condition computation failed because the result is false."); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java index 995705cf2b0..0b795e6b072 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java +++ b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java @@ -21,6 +21,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static org.junit.jupiter.api.Assertions.*; public class TestTermParser extends AbstractTestTermParser { @@ -255,7 +256,8 @@ public void test13() throws Exception { Term t4 = parseTerm("\\exists int_sort ci; (\\<{ int p_y = 1;" + " {int s = 2;} }\\>" + " true ->" + "\\<{ int p_y = 1;boolean p_x = 2<1;" + "while(p_x){ int s=3 ;} }\\>" + " true)"); - assertTrue(t3.equalsModRenaming(t4), "Terms should be equalModRenaming"); + assertTrue(t3.equalsModProperty(RENAMING_TERM_PROPERTY, t4), + "Terms should be equalModRenaming"); } @Test diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java index 130a18a5f21..12b4912366a 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java @@ -25,6 +25,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static org.junit.jupiter.api.Assertions.*; @@ -738,7 +739,7 @@ private void doTestCatchList(int p_proof) { Term resultFormula = goals.head().sequent().getFormulabyNr(1).formula(); Term correctFormula = correctSeq.getFormulabyNr(1).formula(); - assertTrue(resultFormula.equalsModRenaming(correctFormula), + assertTrue(resultFormula.equalsModProperty(RENAMING_TERM_PROPERTY, correctFormula), "Wrong result. Expected:" + ProofSaver.printAnything(correctFormula, TacletForTests.services()) + " But was:" + ProofSaver.printAnything(resultFormula, TacletForTests.services())); diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java index 17d74dd72ea..745bdd57ebc 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java @@ -15,6 +15,8 @@ import org.junit.jupiter.api.Test; +import static de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty.PROOF_IRRELEVANCY_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static org.junit.jupiter.api.Assertions.*; public class TestApplyUpdateOnRigidCondition { @@ -23,7 +25,7 @@ void updateWithoutVariables() { Term term = TacletForTests.parseTerm("{i:=0}\\forall int a; a = i"); Term result = applyUpdateOnFormula(term); Term expected = TacletForTests.parseTerm("\\forall int a; {i:=0}(a = i)"); - assertTrue(expected.equalsModRenaming(result), + assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), "Update without free variables was not properly applied on formula!"); term = TacletForTests.parseTerm("{i:=0}(i = 0)"); @@ -35,7 +37,7 @@ void updateWithoutVariables() { term = TacletForTests.parseTerm("{i:=0} f(const)"); result = applyUpdateOnTerm(term); expected = TacletForTests.parseTerm("f({i:=0} const)"); - assertTrue(expected.equalsModRenaming(result), + assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), "Update without free variables was not properly applied on term!"); } @@ -49,21 +51,21 @@ void updateWithVariablesNoClash() { Term result = tb.all(b, applyUpdateOnFormula(term.sub(0))); Term expected = TacletForTests.parseTerm("\\forall int b; \\forall java.lang.Object a; {i:=b} (a = i)"); - assertTrue(expected.equalsModRenaming(result), + assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), "Update is not simply pulled over quantification!"); term = TacletForTests.parseTerm("\\forall int b; {i:=b} (0 = i)"); b = term.boundVars().get(0); result = tb.all(b, applyUpdateOnFormula(term.sub(0))); expected = TacletForTests.parseTerm("\\forall int b; {i:=b} 0 = {i:=b} i"); - assertTrue(expected.equalsModRenaming(result), + assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), "Update is not simply pulled over equality!"); term = TacletForTests.parseTerm("\\forall int b; {i:=b} f(const) = 0"); b = term.boundVars().get(0); result = tb.all(b, tb.equals(applyUpdateOnTerm(term.sub(0).sub(0)), term.sub(0).sub(1))); expected = TacletForTests.parseTerm("\\forall int b; f({i:=b} const) = 0"); - assertTrue(expected.equalsModRenaming(result), + assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), "Update is not simply pulled over function symbol!"); } @@ -77,7 +79,8 @@ void updateWithVariablesAndClash() { Term result = tb.all(a, applyUpdateOnFormula(term.sub(0))); Term expected = TacletForTests .parseTerm("\\forall int a; \\forall java.lang.Object a1; {i:=a} (a1 = i)"); - assertTrue(expected.equalsModRenaming(result), "Renaming or applying update afterwards !"); + assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + "Renaming or applying update afterwards !"); term = TacletForTests.parseTerm( "\\forall int a1; \\forall int a; {i:=a}\\forall java.lang.Object a; i = a1"); @@ -86,7 +89,7 @@ void updateWithVariablesAndClash() { result = tb.all(a, tb.all(a1, applyUpdateOnFormula(term.sub(0).sub(0)))); expected = TacletForTests.parseTerm( "\\forall int a1; \\forall int a; \\forall java.lang.Object a2; {i:=a} (i = a1)"); - assertTrue(expected.equalsModProofIrrelevancy(result), + assertTrue(expected.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, result), "Counter appended to stem was not increased high enough!"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java index 4021eeebf0d..ba4bce31b03 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java +++ b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java @@ -33,6 +33,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; + /** * This test case makes sure that all KeY formulas which are translated to axioms in SMT can * actually be proved in KeY. @@ -90,7 +92,7 @@ public void testSMTLemmaSoundness(String name, String lemmaString) throws Except KeyIO io = new KeyIO(loadedProof.getServices()); Term parsedLemma = io.parseExpression(lemmaString); Term actual = loadedProof.root().sequent().succedent().get(0).formula(); - if (!actual.equalsModRenaming(parsedLemma)) { + if (!actual.equalsModProperty(RENAMING_TERM_PROPERTY, parsedLemma)) { LOGGER.info("Stored : {}", parsedLemma); LOGGER.warn("Proven : {}", actual); Assertions.fail("The proven lemma is different from the stored one."); diff --git a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java index 7dbebc230ee..539397f6757 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java +++ b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java @@ -26,6 +26,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static java.lang.String.format; import static org.junit.jupiter.api.Assertions.*; @@ -179,7 +180,7 @@ public void testForAll() { services.getNamespaces().sorts().lookup(new Name("int"))); Term expected = TB.all(i, TB.imp(TB.inInt(TB.var(i)), TB.and(TB.leq(TB.zTerm("0"), TB.var(i)), TB.leq(TB.var(i), TB.zTerm("2147483647"))))); - assertTrue(result.equalsModRenaming(expected), + assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), "Result was: " + result + "; \nExpected was: " + expected); } @@ -195,7 +196,7 @@ public void testForEx() { services.getNamespaces().sorts().lookup(new Name("int"))); Term expected = TB.ex(i, TB.and(TB.inInt(TB.var(i)), TB.and(TB.leq(TB.zTerm("0"), TB.var(i)), TB.leq(TB.var(i), TB.zTerm("2147483647"))))); - assertTrue(result.equalsModRenaming(expected), + assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), "Result was: " + result + "; \nExpected was: " + expected); } @@ -211,7 +212,7 @@ public void testBsumInt() { TB.bsum(i, TB.zTerm("0"), TB.zTerm("2147483647"), TB.var(i))); assertNotNull(result); Assertions.assertSame(q, result.sub(0).op()); - assertTrue(result.equalsModRenaming(expected), + assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), "Result was: " + result + "; \nExpected was: " + expected); } @@ -225,7 +226,7 @@ public void testBsumBigInt() { Term expected = TB.bsum(i, TB.zTerm("0"), TB.zTerm("2147483647"), TB.var(i)); assertNotNull(result); Assertions.assertSame(q, result.op()); - assertTrue(result.equalsModRenaming(expected), + assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), "Result was: " + result + "; \nExpected was: " + expected); } @@ -242,7 +243,7 @@ public void testInfiniteUnion() { TB.not(TB.equals(TB.var(o), TB.NULL()))); Term expected = TB.infiniteUnion(new QuantifiableVariable[] { o }, TB.ife(guard, TB.empty(), TB.empty())); - assertTrue(result.equalsModRenaming(expected), + assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), "Result was: " + result + "; \nExpected was: " + expected); } @@ -260,7 +261,7 @@ public void testInfiniteUnion2() { TB.or(TB.convertToFormula(TB.created(TB.var(o))), TB.equals(TB.var(o), TB.NULL())); Term expected = TB.infiniteUnion(new QuantifiableVariable[] { o }, TB.ife(guard, TB.empty(), TB.empty())); - assertTrue(result.equalsModRenaming(expected), + assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), "Result was: " + result + "; \nExpected was: " + expected); } @@ -439,7 +440,7 @@ public void testCorrectImplicitThisResolution() { TB.not(TB.equals(TB.var(qv), TB.NULL()))), // implicit non null TB.equals(TB.var(qv), TB.var(selfVar)))); - final boolean condition = result.equalsModRenaming(expected); + final boolean condition = result.equalsModProperty(RENAMING_TERM_PROPERTY, expected); assertTrue(condition, format("Expected:%s\n Was:%s", ProofSaver.printTerm(expected, services), ProofSaver.printTerm(result, services))); } From 29be061cd6bcbf2eceb871930daacd09635be59a Mon Sep 17 00:00:00 2001 From: Tobias Date: Thu, 28 Dec 2023 13:40:24 +0100 Subject: [PATCH 10/22] add utility method to ProofIrrelevancyProperty --- .../equality/ProofIrrelevancyProperty.java | 72 ++++++++++++------- 1 file changed, 48 insertions(+), 24 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index 25ba006db2c..b30b1cf4f5f 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -11,6 +11,8 @@ import org.key_project.util.EqualsModProofIrrelevancyUtil; import org.key_project.util.collection.ImmutableArray; +import java.util.Objects; + public class ProofIrrelevancyProperty implements TermProperty { /** * The single instance of this property. @@ -102,29 +104,51 @@ public Boolean equalsModThisProperty(Term term, Object o) { */ @Override public int hashCodeModThisProperty(Term term) { - // int hashcode2 = -1; // this line is just so the code compiles - // // part from TermImpl - // if (hashcode2 == -1) { - // // compute into local variable first to be thread-safe. - // hashcode2 = Objects.hash(term.op(), - // EqualsModProofIrrelevancyUtil - // .hashCodeIterable(term.subs()), - // EqualsModProofIrrelevancyUtil.hashCodeIterable(term.boundVars()), term.javaBlock()); - // if (hashcode2 == -1) { - // hashcode2 = 0; - // } - // } - // // part from LabeledTermImpl - // final ImmutableArray labels = term.getLabels(); - // final int numOfLabels = labels.size(); - // for (int i = 0; i < numOfLabels; i++) { - // final TermLabel currentLabel = labels.get(i); - // if (currentLabel.isProofRelevant()) { - // hashcode2 += 7 * currentLabel.hashCode(); - // } - // } - // return hashcode2; - throw new UnsupportedOperationException( - "Hashing of terms modulo term proof-irrelevancy not yet implemented!"); + int hashcode2 = -1; // this line is just so the code compiles + // part from TermImpl + if (hashcode2 == -1) { + // compute into local variable first to be thread-safe. + hashcode2 = Objects.hash(term.op(), hashCodeIterable(term.subs()), + EqualsModProofIrrelevancyUtil.hashCodeIterable(term.boundVars()), term.javaBlock()); + if (hashcode2 == -1) { + hashcode2 = 0; + } + } + // part from LabeledTermImpl + final ImmutableArray labels = term.getLabels(); + final int numOfLabels = labels.size(); + for (int i = 0; i < numOfLabels; i++) { + final TermLabel currentLabel = labels.get(i); + if (currentLabel.isProofRelevant()) { + hashcode2 += 7 * currentLabel.hashCode(); + } + } + return hashcode2; + // throw new UnsupportedOperationException( + // "Hashing of terms modulo term proof-irrelevancy not yet implemented!"); + } + + // -------------------------- Utility methods --------------------------------- // + + /** + * Compute the hashcode of an iterable of terms using the elements' {@link TermEqualsModProperty} + * implementation. + * + * @param iter iterable of terms + * @return combined hashcode + */ + public static int hashCodeIterable(Iterable iter) { + // adapted from Arrays.hashCode + if (iter == null) { + return 0; + } + + int result = 1; + + for (Term element : iter) { + result = 31 * result + (element == null ? 0 : element.hashCodeModProperty(PROOF_IRRELEVANCY_PROPERTY)); + } + + return result; } } From 784535d2b5cf703bc5a7a4e32f037e908dc01df3 Mon Sep 17 00:00:00 2001 From: Tobias Date: Fri, 29 Dec 2023 18:33:23 +0100 Subject: [PATCH 11/22] change property used in equals in TestApplyUpdateOnRigidCondition --- .../key/rule/conditions/TestApplyUpdateOnRigidCondition.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java index 745bdd57ebc..9bf876e06d3 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java @@ -15,7 +15,6 @@ import org.junit.jupiter.api.Test; -import static de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty.PROOF_IRRELEVANCY_PROPERTY; import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; import static org.junit.jupiter.api.Assertions.*; @@ -89,7 +88,7 @@ void updateWithVariablesAndClash() { result = tb.all(a, tb.all(a1, applyUpdateOnFormula(term.sub(0).sub(0)))); expected = TacletForTests.parseTerm( "\\forall int a1; \\forall int a; \\forall java.lang.Object a2; {i:=a} (i = a1)"); - assertTrue(expected.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, result), + assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), "Counter appended to stem was not increased high enough!"); } From ea35df3631d4f20081b9e72c56ad0575b3565081 Mon Sep 17 00:00:00 2001 From: Tobias Date: Tue, 2 Jan 2024 14:46:36 +0100 Subject: [PATCH 12/22] add tests for equalsModProperty in TestEqualsModProperty.java --- .../logic/equality/TestEqualsModProperty.java | 287 ++++++++++++++++++ 1 file changed, 287 insertions(+) create mode 100644 key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java new file mode 100644 index 00000000000..fc0745a19fb --- /dev/null +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java @@ -0,0 +1,287 @@ +/* This file is part of KeY - https://key-project.org + * KeY is licensed under the GNU General Public License Version 2 + * SPDX-License-Identifier: GPL-2.0-only */ +package de.uka.ilkd.key.logic.equality; + +import java.util.Arrays; + +import de.uka.ilkd.key.logic.*; +import de.uka.ilkd.key.logic.label.*; +import de.uka.ilkd.key.logic.op.*; +import de.uka.ilkd.key.rule.TacletForTests; +import de.uka.ilkd.key.util.HelperClassForTests; + +import org.key_project.util.collection.ImmutableArray; + +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; +import static de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty.PROOF_IRRELEVANCY_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.TermLabelsProperty.TERM_LABELS_PROPERTY; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for {@link TermEqualsModProperty}. + * + * @author Tobias Reinhold + */ +public class TestEqualsModProperty { + private TermBuilder tb; + + private TermFactory tf; + + final private TermLabel relevantLabel1 = ParameterlessTermLabel.UNDEFINED_VALUE_LABEL; + final private TermLabel relevantLabel2 = ParameterlessTermLabel.SHORTCUT_EVALUATION_LABEL; + private static TermLabel irrelevantLabel = null; + final private static OriginTermLabelFactory factory = new OriginTermLabelFactory(); + + @BeforeAll + public static void setIrrelevantLabel() { + try { + irrelevantLabel = factory.parseInstance(Arrays.stream(new String[] { + "User_Interaction @ node 0 (Test Test)", "[]" }).toList(), + HelperClassForTests.createServices()); + } catch (TermLabelException e) { + fail(e); + } + } + + @BeforeEach + public void setUp() { + tb = TacletForTests.services().getTermBuilder(); + tf = TacletForTests.services().getTermFactory(); + } + + // equalsModProperty(...) with RENAMING_TERM_PROPERTY + @Test + public void equalsModRenaming() { + // ------------ differing terms to begin with + Term term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + Term term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); + assertFalse(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + "Terms are different to begin with, so they shouldn't be equal"); + assertFalse(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + "Terms are different to begin with, so they shouldn't be equal"); + // other tests for equality already in TestTerm.java + + // ------------ comparison with something that is not a term + assertFalse(term1.equalsModProperty(RENAMING_TERM_PROPERTY, 1), + "Should be false as other object is not a term"); + + // ------------ differing labels + term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + ImmutableArray labels1 = new ImmutableArray<>(irrelevantLabel); + term1 = tb.label(term1, labels1); + assertTrue(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + "Should be true as labels do not matter"); + assertTrue(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + "Should be true as labels do not matter"); + + labels1 = new ImmutableArray<>(relevantLabel1); + term1 = tb.label(term1, labels1); + assertTrue(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + "Should be true as labels do not matter"); + assertTrue(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + "Should be true as labels do not matter"); + + ImmutableArray labels2 = new ImmutableArray<>(relevantLabel2); + term2 = tb.label(term2, labels2); + assertTrue(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + "Should be true as labels do not matter"); + assertTrue(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + "Should be true as labels do not matter"); + } + + // equalsModProperty(...) with IRRELEVANT_TERM_LABELS_PROPERTY + @Test + public void equalsModIrrelevantTermLabels() { + // ------------ different terms to begin with + Term term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + Term term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); + assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + "Terms are different to begin with, so they shouldn't be equal"); + assertFalse(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + "Terms are different to begin with, so they shouldn't be equal"); + + // ------------ comparison with something that is not a term + assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, 1), + "Should be false as other object is not a term"); + + // base terms stay the same for the rest of the tests + term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + + // ------------ only one term has labels + ImmutableArray labels1 = + new ImmutableArray<>(relevantLabel1, irrelevantLabel); + term1 = tb.label(term1, labels1); + assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); + assertFalse(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); + + labels1 = new ImmutableArray<>(irrelevantLabel); + term1 = tb.label(term1, labels1); + assertTrue(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + "Should be true as term1 has no relevant term labels and term2 does not have any labels"); + assertTrue(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + "Should be true as term1 has no relevant term labels and term2 does not have any labels"); + + // ------------ same relevant labels + labels1 = new ImmutableArray<>(relevantLabel1, relevantLabel2); + ImmutableArray labels2 = + new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); + term1 = tb.label(term1, labels1); + term2 = tb.label(term2, labels2); + assertTrue(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + "Should be true as both terms have the same relevant term labels"); + assertTrue(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + "Should be true as both terms have the same relevant term labels"); + + // ------------ not the same relevant labels + labels1 = new ImmutableArray<>(relevantLabel1, irrelevantLabel); + labels2 = new ImmutableArray<>(relevantLabel1, relevantLabel2); + term1 = tb.label(term1, labels1); + term2 = tb.label(term2, labels2); + assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + "Should be false as terms do not have the same relevant term labels"); + assertFalse(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + "Should be false as terms do not have the same relevant term labels"); + } + + // equalsModProperty(...) with TERM_LABELS_PROPERTY + @Test + public void equalsModTermLabels() { + // ------------ different terms to begin with + Term term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + Term term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); + assertFalse(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + "Terms are different to begin with, so they shouldn't be equal"); + assertFalse(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + "Terms are different to begin with, so they shouldn't be equal"); + + // ------------ comparison with something that is not a term + assertFalse(term1.equalsModProperty(TERM_LABELS_PROPERTY, 1), + "Should be false as other object is not a term"); + + // base terms stay the same for the rest of the tests + term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + + // ------------ only one term has labels + ImmutableArray labels1 = + new ImmutableArray<>(relevantLabel1, irrelevantLabel); + term1 = tb.label(term1, labels1); + assertTrue(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + "Should be true as underlying terms are equal"); + assertTrue(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + "Should be true as underlying terms are equal"); + + // ------------ same relevant labels + labels1 = new ImmutableArray<>(relevantLabel1, relevantLabel2); + ImmutableArray labels2 = + new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); + term1 = tb.label(term1, labels1); + term2 = tb.label(term2, labels2); + assertTrue(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + "Should be true as underlying terms are equal"); + assertTrue(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + "Should be true as underlying terms are equal"); + + // ------------ not the same relevant labels + labels1 = new ImmutableArray<>(relevantLabel1, irrelevantLabel); + labels2 = new ImmutableArray<>(relevantLabel1, relevantLabel2); + term1 = tb.label(term1, labels1); + term2 = tb.label(term2, labels2); + assertTrue(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + "Should be true as underlying terms are equal"); + assertTrue(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + "Should be true as underlying terms are equal"); + } + + // equalsModProperty(...) with PROOF_IRRELEVANCY_PROPERTY + @Test + public void equalsModProofIrrelevancy() { + // ------------ different terms to begin with + Term term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + Term term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); + assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + "Terms are different to begin with, so they shouldn't be equal"); + assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + "Terms are different to begin with, so they shouldn't be equal"); + + // ------------ comparison with something that is not a term + assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, 1), + "Should be false as other object is not a term"); + + // base terms stay the same for the rest of the tests + term1 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + term2 = + tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); + + // ------------ only one term has labels + ImmutableArray labels1 = + new ImmutableArray<>(relevantLabel1, irrelevantLabel); + term1 = tb.label(term1, labels1); + assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); + assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); + + labels1 = new ImmutableArray<>(irrelevantLabel); + term1 = tb.label(term1, labels1); + assertTrue(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + "Should be true as term1 has no relevant term labels and term2 does not have any labels"); + assertTrue(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + "Should be true as term1 has no relevant term labels and term2 does not have any labels"); + + // ------------ same relevant labels + labels1 = new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); + ImmutableArray labels2 = + new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); + term1 = tb.label(term1, labels1); + term2 = tb.label(term2, labels2); + assertTrue(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + "Should be true as both terms have the same relevant term labels"); + assertTrue(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + "Should be true as both terms have the same relevant term labels"); + + labels1 = new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); + labels2 = new ImmutableArray<>(relevantLabel1, relevantLabel2); + term1 = tb.label(term1, labels1); + term2 = tb.label(term2, labels2); + assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + "Should be false as both terms have a different number of labels"); + assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + "Should be false as both terms have a different number of labels"); + + // ------------ not the same relevant labels + labels1 = new ImmutableArray<>(relevantLabel1); + labels2 = new ImmutableArray<>(relevantLabel2); + term1 = tb.label(term1, labels1); + term2 = tb.label(term2, labels2); + assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + "Should be false as terms do not have the same relevant term labels"); + assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + "Should be false as terms do not have the same relevant term labels"); + } +} From e06a25ea37e3614eff182e0eefa3e1b7f5e64e51 Mon Sep 17 00:00:00 2001 From: Tobias Date: Tue, 2 Jan 2024 21:42:45 +0100 Subject: [PATCH 13/22] add doc to equality properties and change names of tests --- .../equality/IrrelevantTermLabelsProperty.java | 7 ++++++- .../logic/equality/ProofIrrelevancyProperty.java | 16 +++++++++++----- .../key/logic/equality/RenamingTermProperty.java | 6 +++++- .../key/logic/equality/TermLabelsProperty.java | 5 +++++ .../logic/equality/TestEqualsModProperty.java | 8 ++++---- 5 files changed, 31 insertions(+), 11 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index c97c95b2699..96d77707260 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -8,6 +8,11 @@ import org.key_project.util.collection.ImmutableArray; +/** + * A property that can be used in + * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * All irrelevant term labels are ignored in this equality check. + */ public class IrrelevantTermLabelsProperty implements TermProperty { /** * The single instance of this property. @@ -31,7 +36,7 @@ private IrrelevantTermLabelsProperty() {} * @param term a term * @param o the object compared to {@code term} * @return {@code true} iff {@code o} is a term syntactically equal to {@code term}, except for - * their labels. + * their irrelevant labels. * @see TermLabel#isProofRelevant() isStrategyRelevant */ @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index b30b1cf4f5f..f652c25f1c0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -4,6 +4,8 @@ package de.uka.ilkd.key.logic.equality; +import java.util.Objects; + import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.label.TermLabel; @@ -11,8 +13,11 @@ import org.key_project.util.EqualsModProofIrrelevancyUtil; import org.key_project.util.collection.ImmutableArray; -import java.util.Objects; - +/** + * A property that can be used in + * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * All proof irrelevant attributes are ignored in this equality check. + */ public class ProofIrrelevancyProperty implements TermProperty { /** * The single instance of this property. @@ -131,8 +136,8 @@ public int hashCodeModThisProperty(Term term) { // -------------------------- Utility methods --------------------------------- // /** - * Compute the hashcode of an iterable of terms using the elements' {@link TermEqualsModProperty} - * implementation. + * Compute the hashcode mod proof irrelevancy of an iterable of terms using the elements' + * {@link TermEqualsModProperty} implementation. * * @param iter iterable of terms * @return combined hashcode @@ -146,7 +151,8 @@ public static int hashCodeIterable(Iterable iter) { int result = 1; for (Term element : iter) { - result = 31 * result + (element == null ? 0 : element.hashCodeModProperty(PROOF_IRRELEVANCY_PROPERTY)); + result = 31 * result + (element == null ? 0 + : element.hashCodeModProperty(PROOF_IRRELEVANCY_PROPERTY)); } return result; diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java index e0525abe29b..068e0c1cae5 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java @@ -13,7 +13,11 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; - +/** + * A property that can be used in + * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * Renaming of variables is ignored in this equality check. + */ public class RenamingTermProperty implements TermProperty { /** * The single instance of this property. diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java index 0eebfaf1886..a6f1ba57c4f 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java @@ -7,6 +7,11 @@ import org.key_project.util.collection.ImmutableArray; +/** + * A property that can be used in + * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * All term labels are ignored in this equality check. + */ public class TermLabelsProperty implements TermProperty { /** * The single instance of this property. diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java index fc0745a19fb..1075a05dd05 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java @@ -57,7 +57,7 @@ public void setUp() { // equalsModProperty(...) with RENAMING_TERM_PROPERTY @Test - public void equalsModRenaming() { + public void renaming() { // ------------ differing terms to begin with Term term1 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); @@ -102,7 +102,7 @@ public void equalsModRenaming() { // equalsModProperty(...) with IRRELEVANT_TERM_LABELS_PROPERTY @Test - public void equalsModIrrelevantTermLabels() { + public void irrelevantTermLabels() { // ------------ different terms to begin with Term term1 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); @@ -163,7 +163,7 @@ public void equalsModIrrelevantTermLabels() { // equalsModProperty(...) with TERM_LABELS_PROPERTY @Test - public void equalsModTermLabels() { + public void AllTermLabels() { // ------------ different terms to begin with Term term1 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); @@ -217,7 +217,7 @@ public void equalsModTermLabels() { // equalsModProperty(...) with PROOF_IRRELEVANCY_PROPERTY @Test - public void equalsModProofIrrelevancy() { + public void proofIrrelevancy() { // ------------ different terms to begin with Term term1 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); From d5ca289074cb1564df706bcf68265181c424dd00 Mon Sep 17 00:00:00 2001 From: Tobias Date: Fri, 12 Jan 2024 14:30:26 +0100 Subject: [PATCH 14/22] change signature of equalsModProperty in TermEqualsModProperty --- .../util/SymbolicExecutionUtil.java | 66 +++++++------- .../StartAuxiliaryBlockComputationMacro.java | 2 +- .../StartAuxiliaryLoopComputationMacro.java | 2 +- .../StartAuxiliaryMethodComputationMacro.java | 2 +- .../ilkd/key/logic/BoundVariableTools.java | 4 +- .../uka/ilkd/key/logic/LabeledTermImpl.java | 3 +- .../de/uka/ilkd/key/logic/Semisequent.java | 4 +- .../de/uka/ilkd/key/logic/SequentFormula.java | 2 +- .../java/de/uka/ilkd/key/logic/TermImpl.java | 2 +- .../IrrelevantTermLabelsProperty.java | 6 +- .../equality/ProofIrrelevancyProperty.java | 4 +- .../logic/equality/RenamingTermProperty.java | 2 +- .../logic/equality/TermEqualsModProperty.java | 10 +-- .../logic/equality/TermLabelsProperty.java | 4 +- .../key/logic/label/TermLabelManager.java | 4 +- .../ilkd/key/macros/scripts/FocusCommand.java | 4 +- .../ilkd/key/macros/scripts/HideCommand.java | 2 +- .../macros/scripts/InstantiateCommand.java | 8 +- .../key/macros/scripts/RewriteCommand.java | 4 +- .../ilkd/key/macros/scripts/RuleCommand.java | 6 +- .../key/macros/scripts/SelectCommand.java | 2 +- .../de/uka/ilkd/key/proof/OpReplacer.java | 2 +- .../ilkd/key/proof/join/JoinIsApplicable.java | 4 +- .../key/rule/AbstractLoopInvariantRule.java | 8 +- .../key/rule/AuxiliaryContractBuilders.java | 4 +- .../uka/ilkd/key/rule/OneStepSimplifier.java | 2 +- .../key/rule/UseDependencyContractRule.java | 2 +- .../uka/ilkd/key/rule/WhileInvariantRule.java | 8 +- .../ApplyUpdateOnRigidCondition.java | 2 +- .../ilkd/key/rule/inst/SVInstantiations.java | 8 +- .../key/rule/match/legacy/ElementMatcher.java | 2 +- .../key/rule/match/vm/VMTacletMatcher.java | 2 +- .../MatchSchemaVariableInstruction.java | 2 +- .../de/uka/ilkd/key/rule/merge/MergeRule.java | 2 +- .../rule/metaconstruct/CreateFrameCond.java | 2 +- .../metaconstruct/CreateHeapAnonUpdate.java | 2 +- .../rule/metaconstruct/IntroAtPreDefsOp.java | 8 +- .../ilkd/key/smt/AbstractSMTTranslator.java | 14 +-- .../ilkd/key/smt/newsmt2/SeqDefHandler.java | 2 +- .../ilkd/key/smt/newsmt2/SumProdHandler.java | 4 +- .../ilkd/key/speclang/ContractFactory.java | 2 +- .../FunctionalOperationContractImpl.java | 8 +- .../key/speclang/WellDefinednessCheck.java | 20 ++--- .../jml/translation/JMLSpecFactory.java | 14 +-- .../key/strategy/FindTacletAppContainer.java | 4 +- .../strategy/feature/ContainsTermFeature.java | 2 +- .../feature/DependencyContractFeature.java | 4 +- .../DiffFindAndReplacewithFeature.java | 4 +- ...SubFormulaOfInfFlowContractAppFeature.java | 2 +- .../NonDuplicateAppModPositionFeature.java | 2 +- .../key/strategy/feature/QueryExpandCost.java | 4 +- .../quantifierHeuristics/HandleArith.java | 2 +- .../PredictCostProver.java | 6 +- .../strategy/termfeature/EqTermFeature.java | 2 +- .../termgenerator/RootsGenerator.java | 4 +- .../key/util/mergerule/MergeRuleUtils.java | 4 +- .../java/de/uka/ilkd/key/logic/TestTerm.java | 14 +-- .../logic/equality/TestEqualsModProperty.java | 86 +++++++++---------- .../uka/ilkd/key/parser/TestTermParser.java | 2 +- .../de/uka/ilkd/key/rule/TestApplyTaclet.java | 2 +- .../TestApplyUpdateOnRigidCondition.java | 14 +-- .../key/smt/newsmt2/ProveSMTLemmasTest.java | 2 +- .../key/speclang/jml/TestJMLTranslator.java | 14 +-- 63 files changed, 221 insertions(+), 220 deletions(-) diff --git a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java index 2994e453544..47f1d1d3860 100644 --- a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java +++ b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java @@ -390,7 +390,7 @@ else if (term.op() == Junctor.NOT) { * @return true if the term represents the one */ private static boolean isOne(Term subOne, IntegerLDT integerLDT) { - return subOne.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, integerLDT.one()); + return subOne.equalsModProperty(integerLDT.one(), IRRELEVANT_TERM_LABELS_PROPERTY); } /** @@ -1979,16 +1979,16 @@ private static void collectSpecifcationCasesPreconditions(Term normalExcDefiniti List exceptinalConditions) throws ProofInputException { if (term.op() == Junctor.AND) { Term lastChild = term.sub(term.arity() - 1); - if (lastChild.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, normalExcDefinition) - || lastChild.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - exceptionalExcDefinition)) { + if (lastChild.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY) + || lastChild.equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { // Nothing to do, condition is just true } else { Term firstChild = term.sub(0); if (firstChild - .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, normalExcDefinition) - || firstChild.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - exceptionalExcDefinition)) { + .equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY) + || firstChild.equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { // Nothing to do, condition is just true } else { for (int i = 0; i < term.arity(); i++) { @@ -2000,32 +2000,32 @@ private static void collectSpecifcationCasesPreconditions(Term normalExcDefiniti } } else if (term.op() == Junctor.IMP) { Term leftTerm = term.sub(0); - if (leftTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, normalExcDefinition) - || leftTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - exceptionalExcDefinition)) { + if (leftTerm.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY) + || leftTerm.equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { // Nothing to do, condition is just true } else { Term rightTerm = term.sub(1); // Deal with heavy weight specification cases if (rightTerm.op() == Junctor.AND && rightTerm.sub(0).op() == Junctor.IMP && rightTerm.sub(0).sub(0) - .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - normalExcDefinition)) { + .equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { normalConditions.add(leftTerm); } else if (rightTerm.op() == Junctor.AND && rightTerm.sub(1).op() == Junctor.IMP && rightTerm.sub(1).sub(0) - .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - exceptionalExcDefinition)) { + .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { exceptinalConditions.add(leftTerm); } // Deal with light weight specification cases else if (rightTerm.op() == Junctor.IMP - && rightTerm.sub(0).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - normalExcDefinition)) { + && rightTerm.sub(0).equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { normalConditions.add(leftTerm); } else if (rightTerm.op() == Junctor.IMP && rightTerm.sub(0) - .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - exceptionalExcDefinition)) { + .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { exceptinalConditions.add(leftTerm); } else { Term excCondition = rightTerm; @@ -2033,23 +2033,23 @@ else if (rightTerm.op() == Junctor.IMP if (excCondition.op() == Junctor.AND) { excCondition = excCondition.sub(excCondition.arity() - 1); } - if (excCondition.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - normalExcDefinition)) { + if (excCondition.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { normalConditions.add(leftTerm); } else if (excCondition - .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - exceptionalExcDefinition)) { + .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { exceptinalConditions.add(leftTerm); } else { // Check if left child is exception definition if (rightTerm.op() == Junctor.AND) { excCondition = rightTerm.sub(0); - if (excCondition.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - normalExcDefinition)) { + if (excCondition.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { normalConditions.add(leftTerm); } else if (excCondition - .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - exceptionalExcDefinition)) { + .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { exceptinalConditions.add(leftTerm); } else { throw new ProofInputException("Exeptional condition expected, " @@ -2676,7 +2676,7 @@ private static boolean checkReplaceTerm(Term toCheck, PosInOccurrence posInOccur Term replaceTerm) { Term termAtPio = followPosInOccurrence(posInOccurrence, toCheck); if (termAtPio != null) { - return termAtPio.equalsModProperty(RENAMING_TERM_PROPERTY, replaceTerm); + return termAtPio.equalsModProperty(replaceTerm, RENAMING_TERM_PROPERTY); } else { return false; } @@ -3422,13 +3422,13 @@ private static List findSkolemReplacements(Sequent sequent, Term skolemCon if (term != skolemEquality) { int skolemCheck = checkSkolemEquality(term); if (skolemCheck == -1) { - if (term.sub(0).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - skolemConstant)) { + if (term.sub(0).equalsModProperty(skolemConstant, IRRELEVANT_TERM_LABELS_PROPERTY + )) { result.add(term.sub(1)); } } else if (skolemCheck == 1) { - if (term.sub(1).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - skolemConstant)) { + if (term.sub(1).equalsModProperty(skolemConstant, IRRELEVANT_TERM_LABELS_PROPERTY + )) { result.add(term.sub(0)); } } @@ -3518,8 +3518,8 @@ public static Term computePathCondition(Node parentNode, Node childNode, boolean } childNode = parent; } - if (services.getTermBuilder().ff().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - pathCondition)) { + if (services.getTermBuilder().ff().equalsModProperty(pathCondition, IRRELEVANT_TERM_LABELS_PROPERTY + )) { throw new ProofInputException( "Path condition computation failed because the result is false."); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java index 9f927722325..b8f83b1f119 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java @@ -80,7 +80,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_BLOCK_WITH_PRE_RELATION); - return posInOcc.subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, selfComposedExec); + return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_TERM_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java index f5a229c2348..ac99f63d94a 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java @@ -77,7 +77,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_LOOP_WITH_INV_RELATION); - return posInOcc.subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, selfComposedExec); + return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_TERM_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java index 81af3b4b44e..9c2ec5dda28 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java @@ -69,7 +69,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_EXECUTION_WITH_PRE_RELATION); - return posInOcc.subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, selfComposedExec); + return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_TERM_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java index 47182521581..cad52501053 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java @@ -208,7 +208,7 @@ public boolean equalsModRenaming(ImmutableArray vars0, Ter return false; } if (vars0.size() == 0) { - return term0.equalsModProperty(RENAMING_TERM_PROPERTY, term1); + return term0.equalsModProperty(term1, RENAMING_TERM_PROPERTY); } final ImmutableArray unifiedVars = unifyVariableArrays(vars0, vars1, @@ -217,7 +217,7 @@ public boolean equalsModRenaming(ImmutableArray vars0, Ter final Term renamedTerm0 = renameVariables(term0, vars0, unifiedVars, services); final Term renamedTerm1 = renameVariables(term1, vars1, unifiedVars, services); - return renamedTerm0.equalsModProperty(RENAMING_TERM_PROPERTY, renamedTerm1); + return renamedTerm0.equalsModProperty(renamedTerm1, RENAMING_TERM_PROPERTY); } /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java index fcd82e6402c..f8c4a77aba9 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java @@ -8,6 +8,7 @@ import de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty; import de.uka.ilkd.key.logic.equality.RenamingTermProperty; +import de.uka.ilkd.key.logic.equality.TermEqualsModProperty; import de.uka.ilkd.key.logic.equality.TermProperty; import de.uka.ilkd.key.logic.label.TermLabel; import de.uka.ilkd.key.logic.op.Operator; @@ -23,7 +24,7 @@ *

* * Two labeled terms are equal if they have equal term structure and equal annotations. In contrast, - * the method {@link Term#equalsModProperty(TermProperty, Object)} can be used to compare terms + * the method {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)} can be used to compare terms * while ignoring certain * given properties. E.g. by using {@link RenamingTermProperty#RENAMING_TERM_PROPERTY}, just the * term structures modulo diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java index 40bb4ed5679..b168ec3c794 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java @@ -159,8 +159,8 @@ private SemisequentChangeInfo insertAndRemoveRedundancyHelper(int idx, searchList = searchList.tail(); if (sequentFormula != null - && cf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, - sequentFormula.formula())) { + && cf.formula().equalsModProperty(sequentFormula.formula(), RENAMING_TERM_PROPERTY + )) { semiCI.rejectedFormula(sequentFormula); return semiCI; // semisequent already contains formula diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java b/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java index ef63cee629e..682fd774c92 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/SequentFormula.java @@ -77,7 +77,7 @@ public boolean equalsModProofIrrelevancy(Object obj) { return true; } if (obj instanceof SequentFormula cmp) { - return term.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, cmp.formula()); + return term.equalsModProperty(cmp.formula(), PROOF_IRRELEVANCY_PROPERTY); } return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java index c60af5eef15..0fa52f024f2 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java @@ -339,7 +339,7 @@ protected int computeHashCode() { } @Override - public boolean equalsModProperty(TermProperty property, Object o) { + public boolean equalsModProperty(Object o, TermProperty property) { return property.equalsModThisProperty(this, o); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index 96d77707260..5092eacc2e0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -10,7 +10,7 @@ /** * A property that can be used in - * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)}. * All irrelevant term labels are ignored in this equality check. */ public class IrrelevantTermLabelsProperty implements TermProperty { @@ -71,8 +71,8 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - otherSubs.get(i))) { + if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), IRRELEVANT_TERM_LABELS_PROPERTY + )) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index f652c25f1c0..5833f9ffc55 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -15,7 +15,7 @@ /** * A property that can be used in - * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)}. * All proof irrelevant attributes are ignored in this equality check. */ public class ProofIrrelevancyProperty implements TermProperty { @@ -82,7 +82,7 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, otherSubs.get(i))) { + if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), PROOF_IRRELEVANCY_PROPERTY)) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java index 068e0c1cae5..6f0dc65294c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java @@ -15,7 +15,7 @@ /** * A property that can be used in - * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)}. * Renaming of variables is ignored in this equality check. */ public class RenamingTermProperty implements TermProperty { diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java index 88e7373e3c4..251ec239a7b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java @@ -12,17 +12,17 @@ public interface TermEqualsModProperty { /** - * Checks whether this object is equal to o modulo the property described by - * property. + * Checks whether this object is equal to {@code o} modulo the property described by + * {@code property}. * + * @param o the object that is checked for equality * @param property the property to be ignored in the equality check - * @param o the object that is checked for equality * @return whether this object is equal to o */ - boolean equalsModProperty(TermProperty property, Object o); + boolean equalsModProperty(Object o, TermProperty property); /** - * Computes the hash code according to the given ignored property. + * Computes the hash code according to the given ignored {@code property}. * * @param property the ignored property according to which the hash code is computed * @return the hash code of this object diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java index a6f1ba57c4f..6ca8c953a22 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java @@ -9,7 +9,7 @@ /** * A property that can be used in - * {@link TermEqualsModProperty#equalsModProperty(TermProperty, Object)}. + * {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)}. * All term labels are ignored in this equality check. */ public class TermLabelsProperty implements TermProperty { @@ -54,7 +54,7 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(TERM_LABELS_PROPERTY, otherSubs.get(i))) { + if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), TERM_LABELS_PROPERTY)) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java index 96e817e25ec..d030e3fe083 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java @@ -2012,8 +2012,8 @@ protected void mergeLabels(SequentChangeInfo currentSequent, Services services, // Search existing SequentFormula Semisequent s = currentSequent.getSemisequentChangeInfo(inAntecedent).semisequent(); SequentFormula existingSF = CollectionUtil.search(s, - element -> element.formula().equalsModProperty(RENAMING_TERM_PROPERTY, - rejectedTerm)); + element -> element.formula().equalsModProperty(rejectedTerm, RENAMING_TERM_PROPERTY + )); if (existingSF != null) { // Create list of new labels Term existingTerm = existingSF.formula(); diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java index 045f08b5ca9..600decc3a78 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java @@ -78,7 +78,7 @@ private void hideAll(Sequent toKeep) throws ScriptException { for (SequentFormula seqFormula : ante) { // This means "!keepAnte.contains(seqFormula.formula)" but with equality mod renaming! if (!keepAnte.exists( - it -> it.equalsModProperty(RENAMING_TERM_PROPERTY, seqFormula.formula()))) { + it -> it.equalsModProperty(seqFormula.formula(), RENAMING_TERM_PROPERTY))) { Taclet tac = getHideTaclet("left"); makeTacletApp(goal, seqFormula, tac, true); } @@ -88,7 +88,7 @@ private void hideAll(Sequent toKeep) throws ScriptException { ImmutableList succ = goal.sequent().succedent().asList(); for (SequentFormula seqFormula : succ) { if (!keepSucc.exists( - it -> it.equalsModProperty(RENAMING_TERM_PROPERTY, seqFormula.formula()))) { + it -> it.equalsModProperty(seqFormula.formula(), RENAMING_TERM_PROPERTY))) { Taclet tac = getHideTaclet("right"); makeTacletApp(goal, seqFormula, tac, false); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java index 24055e2ae3c..f03d0e43451 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/HideCommand.java @@ -80,7 +80,7 @@ public void execute(Parameters args) throws ScriptException, InterruptedExceptio private SequentFormula find(SequentFormula sf, Semisequent semiseq) throws ScriptException { for (SequentFormula s : semiseq) { - if (s.formula().equalsModProperty(TERM_LABELS_PROPERTY, sf.formula())) { + if (s.formula().equalsModProperty(sf.formula(), TERM_LABELS_PROPERTY)) { return s; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java index 8cb4844c4c8..a5068943243 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java @@ -110,7 +110,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta ImmutableList allApps = ImmutableSLList.nil(); for (SequentFormula sf : g.node().sequent().antecedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -119,7 +119,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta for (SequentFormula sf : g.node().sequent().succedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -135,8 +135,8 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta private TacletApp filterList(Parameters p, ImmutableList list) { for (TacletApp tacletApp : list) { if (tacletApp instanceof PosTacletApp pta) { - if (pta.posInOccurrence().subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, - p.formula)) { + if (pta.posInOccurrence().subTerm().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY + )) { return pta; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java index 3c267ad0265..4695163c98d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java @@ -114,7 +114,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta for (SequentFormula sf : g.node().sequent().antecedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -124,7 +124,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta // filter taclets that are applicable on the given formula in the succedent for (SequentFormula sf : g.node().sequent().succedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java index 7eafa9f5b6e..391f797fd71 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java @@ -317,7 +317,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta private boolean isFormulaSearchedFor(Parameters p, SequentFormula sf, Services services) throws ScriptException { final boolean satisfiesFormulaParameter = - p.formula != null && sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, p.formula); + p.formula != null && sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY); final boolean satisfiesMatchesParameter = p.matches != null && formatTermString(LogicPrinter.quickPrintTerm(sf.formula(), services)) @@ -348,7 +348,7 @@ private List filterList(Parameters p, ImmutableList list) if (tacletApp instanceof PosTacletApp pta) { boolean add = p.on == null || pta.posInOccurrence().subTerm() - .equalsModProperty(RENAMING_TERM_PROPERTY, p.on); + .equalsModProperty(p.on, RENAMING_TERM_PROPERTY); Iterator it = pta.instantiations().svIterator(); while (it.hasNext()) { @@ -358,7 +358,7 @@ private List filterList(Parameters p, ImmutableList list) pta.instantiations().getInstantiationEntry(sv).getInstantiation(); add &= userInst == null - || userInst.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, ptaInst); + || userInst.equalsModProperty(ptaInst, IRRELEVANT_TERM_LABELS_PROPERTY); } if (add) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java index 77c44d820b3..3c8978e0113 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java @@ -135,7 +135,7 @@ private boolean contains(Sequent seq, Term formula) { private boolean contains(Semisequent semiseq, Term formula) { for (SequentFormula sf : semiseq.asList()) { - if (sf.formula().equalsModProperty(RENAMING_TERM_PROPERTY, formula)) { + if (sf.formula().equalsModProperty(formula, RENAMING_TERM_PROPERTY)) { return true; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java b/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java index 6bf1d49781b..a676f26a1e6 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java +++ b/key.core/src/main/java/de/uka/ilkd/key/proof/OpReplacer.java @@ -235,7 +235,7 @@ public Term replace(Term term) { } for (SVSubstitute svs : map.keySet()) { - if (term.equalsModProperty(TERM_LABELS_PROPERTY, svs)) { + if (term.equalsModProperty(svs, TERM_LABELS_PROPERTY)) { return (Term) map.get(svs); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java index b54e54aabbc..2f8c0bb4b34 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java +++ b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java @@ -91,13 +91,13 @@ private ProspectivePartner areProspectivePartners(Goal g1, PosInOccurrence pio, Term formula = sf.formula(); Term update2 = tb.skip(); if (formula.op() instanceof UpdateApplication - && !formula.equalsModProperty(RENAMING_TERM_PROPERTY, referenceFormula)) { + && !formula.equalsModProperty(referenceFormula, RENAMING_TERM_PROPERTY)) { update2 = formula.sub(0);// don't change the order of this and // the following line. formula = formula.sub(1); } - if (formula.equalsModProperty(RENAMING_TERM_PROPERTY, referenceFormula)) { + if (formula.equalsModProperty(referenceFormula, RENAMING_TERM_PROPERTY)) { return new ProspectivePartner(referenceFormula, g1.node(), pio.sequentFormula(), update1, g2.node(), sf, update2); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java index a1179d618ab..61ecc40c527 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/AbstractLoopInvariantRule.java @@ -440,7 +440,7 @@ protected static AnonUpdateData createAnonUpdate(LocationVariable heap, Term mod // check for strictly pure loops final Term anonUpdate; - if (tb.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + if (tb.strictlyNothing().equalsModProperty(mod, IRRELEVANT_TERM_LABELS_PROPERTY)) { anonUpdate = tb.skip(); } else { anonUpdate = tb.anonUpd(heap, mod, anonHeapTerm); @@ -504,14 +504,14 @@ protected static AdditionalHeapTerms createAdditionalHeapTerms(Services services final Term freeMod = freeMods.get(heap); final Term strictlyNothing = tb.strictlyNothing(); final Term currentFrame; - if (strictlyNothing.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { - if (strictlyNothing.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { + if (strictlyNothing.equalsModProperty(mod, IRRELEVANT_TERM_LABELS_PROPERTY)) { + if (strictlyNothing.equalsModProperty(freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { currentFrame = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoop.get(heap)); } else { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), freeMod); } } else { - if (strictlyNothing.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { + if (strictlyNothing.equalsModProperty(freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), mod); } else { currentFrame = tb.frame( diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java index d31ab07e4d0..85b2f41b3f4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java @@ -651,8 +651,8 @@ public Term buildAnonOutUpdate(final Set vars, .entrySet()) { Term anonymisationUpdate = skip(); final Term modifiesClause = modifiesClauses.get(anonymisationHeap.getKey()); - if (!modifiesClause.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - strictlyNothing())) { + if (!modifiesClause.equalsModProperty(strictlyNothing(), IRRELEVANT_TERM_LABELS_PROPERTY + )) { anonymisationUpdate = anonUpd(anonymisationHeap.getKey(), modifiesClause, services.getTermBuilder().label( services.getTermBuilder().func(anonymisationHeap.getValue()), diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java index 66ca9b690f9..d70e6734750 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java @@ -749,7 +749,7 @@ public boolean equals(Object obj) { obj = ((TermReplacementKey) obj).term; } if (obj instanceof Term t) { - return term.equalsModProperty(RENAMING_TERM_PROPERTY, t); // Ignore naming and term + return term.equalsModProperty(t, RENAMING_TERM_PROPERTY); // Ignore naming and term // labels in the way a // taclet rule does. } else { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java index 22fbbbdb7a5..07d4061f67f 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/UseDependencyContractRule.java @@ -209,7 +209,7 @@ public static boolean isBaseOcc(Term focus, Term candidate) { return false; } for (int i = 1, n = candidate.arity(); i < n; i++) { - if (!(candidate.sub(i).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, focus.sub(i)) + if (!(candidate.sub(i).equalsModProperty(focus.sub(i), IRRELEVANT_TERM_LABELS_PROPERTY) || candidate.sub(i).op() instanceof LogicVariable)) { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java index 4870631f39d..cb50fc90005 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java @@ -271,7 +271,7 @@ private static AnonUpdateData createAnonUpdate(LocationVariable heap, Term mod, // check for strictly pure loops final Term anonUpdate; - if (tb.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + if (tb.strictlyNothing().equalsModProperty(mod, IRRELEVANT_TERM_LABELS_PROPERTY)) { anonUpdate = tb.skip(); } else { anonUpdate = tb.anonUpd(heap, mod, anonHeapTerm); @@ -831,16 +831,16 @@ public ImmutableList apply(Goal goal, Services services, final RuleApp rul final Term strictlyNothing = tb.strictlyNothing(); final Term currentFrame; if (strictlyNothing.equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, mod)) { + mod, IRRELEVANT_TERM_LABELS_PROPERTY)) { if (strictlyNothing.equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { + freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { currentFrame = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoop.get(heap)); } else { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), freeMod); } } else { if (strictlyNothing.equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, freeMod)) { + freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), mod); } else { currentFrame = tb.frame( diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java index e2288ca14ed..333b006fc21 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java @@ -214,7 +214,7 @@ public MatchConditions check(SchemaVariable var, SVSubstitute instCandidate, Mat if (resultInst == null) { svInst = svInst.add(result, properResultInst, services); return mc.setInstantiations(svInst); - } else if (resultInst.equalsModProperty(RENAMING_TERM_PROPERTY, properResultInst)) { + } else if (resultInst.equalsModProperty(properResultInst, RENAMING_TERM_PROPERTY)) { return mc; } else { return null; diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java index 132fe7a1d1d..d465f6f2288 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java @@ -546,8 +546,8 @@ public boolean equals(Object obj) { final Object inst = e.value().getInstantiation(); assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { - if (!instAsTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - cmp.getInstantiation(e.key()))) { + if (!instAsTerm.equalsModProperty(cmp.getInstantiation(e.key()), IRRELEVANT_TERM_LABELS_PROPERTY + )) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { @@ -578,8 +578,8 @@ public boolean equalsModProofIrrelevancy(Object obj) { assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { if (!instAsTerm.equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, - cmp.getInstantiation(e.key()))) { + cmp.getInstantiation(e.key()), IRRELEVANT_TERM_LABELS_PROPERTY + )) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java index bb709c74e68..f83c544c76d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java @@ -125,7 +125,7 @@ protected final MatchConditions addInstantiation(AbstractSV op, Term term, final Term t = inst.getTermInstantiation(op, inst.getExecutionContext(), services); if (t != null) { - if (!t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { + if (!t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { LOGGER.debug( "FAILED. Adding instantiations leads to unsatisfiable constraint. {} {}", op, term); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java index e2dbf7c3932..834ef05a284 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java @@ -167,7 +167,7 @@ private Term matchUpdateContext(ImmutableList context, Term for if (formula.op() instanceof UpdateApplication) { final Term update = UpdateApplication.getUpdate(formula); final UpdateLabelPair ulp = curContext.head(); - if (ulp.update().equalsModProperty(RENAMING_TERM_PROPERTY, update) + if (ulp.update().equalsModProperty(update, RENAMING_TERM_PROPERTY) && ulp.updateApplicationlabels().equals(update.getLabels())) { curContext = curContext.tail(); formula = UpdateApplication.getTarget(formula); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java index 78313afd9ad..9ff0c73212c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java @@ -42,7 +42,7 @@ protected final MatchConditions addInstantiation(Term term, MatchConditions matc final Term t = inst.getTermInstantiation(op, inst.getExecutionContext(), services); if (t != null) { - if (!t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { + if (!t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { return null; } else { return matchCond; diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java index 272561b7c82..cad179b7c94 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java @@ -357,7 +357,7 @@ protected Triple, LinkedHashSet infFlowSpecs = spec.getInfFlowSpecs(heap, self, atPres, services); @@ -239,8 +239,8 @@ public void performActionOnLoopInvariant(final LoopSpecification spec) { } if (heap != services.getTypeConverter().getHeapLDT().getSavedHeap() || !tb.strictlyNothing().equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, - freeTerm)) { + freeTerm, IRRELEVANT_TERM_LABELS_PROPERTY + )) { final Term m = spec.getFreeModifies(heap, selfTerm, atPres, services); final ImmutableList infFlowSpecs = spec.getInfFlowSpecs(heap, selfTerm, atPres, services); diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java b/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java index ba9a3d35c59..dd4d0fa3a6d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java @@ -1818,12 +1818,12 @@ private StringBuilder translateAsBindingUninterpretedPredicate(Term term, Functi // the terms only have to match on those positions where functions are defined if (fun.bindVarsAt(i)) { termsMatch = termsMatch - && t.sub(i).equalsModProperty(RENAMING_TERM_PROPERTY, term.sub(i)); + && t.sub(i).equalsModProperty(term.sub(i), RENAMING_TERM_PROPERTY); } } // the terms also match, if the entire sequence matches - termsMatch = (termsMatch || t.equalsModProperty(RENAMING_TERM_PROPERTY, term)); + termsMatch = (termsMatch || t.equalsModProperty(term, RENAMING_TERM_PROPERTY)); if (termsMatch) { used = t; @@ -1928,12 +1928,12 @@ private StringBuilder translateAsBindingUninterpretedFunction(Term term, Functio // the terms only have to match on those positions where functions are defined if (fun.bindVarsAt(i)) { termsMatch = termsMatch - && t.sub(i).equalsModProperty(RENAMING_TERM_PROPERTY, term.sub(i)); + && t.sub(i).equalsModProperty(term.sub(i), RENAMING_TERM_PROPERTY); } } // the terms also match, if the entire terms match - termsMatch = (termsMatch || t.equalsModProperty(RENAMING_TERM_PROPERTY, term)); + termsMatch = (termsMatch || t.equalsModProperty(term, RENAMING_TERM_PROPERTY)); if (termsMatch) { used = t; @@ -2102,7 +2102,7 @@ private StringBuilder getModalityPredicate(Term t, List qu Services services) throws IllegalFormulaException { // check, if the modality was already translated. for (Term toMatch : modalityPredicates.keySet()) { - if (toMatch.equalsModProperty(RENAMING_TERM_PROPERTY, t)) { + if (toMatch.equalsModProperty(t, RENAMING_TERM_PROPERTY)) { return modalityPredicates.get(toMatch); } } @@ -2252,7 +2252,7 @@ protected final StringBuilder translateBsumFunction(Term bsumterm, ArrayList sub) { StringBuilder name = null; for (Term t : usedBsumTerms.keySet()) { - if (t.equalsModProperty(RENAMING_TERM_PROPERTY, bsumterm)) { + if (t.equalsModProperty(bsumterm, RENAMING_TERM_PROPERTY)) { name = usedBsumTerms.get(t); } } @@ -2290,7 +2290,7 @@ protected final StringBuilder translateBprodFunction(Term bprodterm, ArrayList sub) { StringBuilder name = null; for (Term t : usedBprodTerms.keySet()) { - if (t.equalsModProperty(RENAMING_TERM_PROPERTY, bprodterm)) { + if (t.equalsModProperty(bprodterm, RENAMING_TERM_PROPERTY)) { name = usedBprodTerms.get(t); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java index 15f7d9d7176..cbb17d8f795 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java @@ -80,7 +80,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti (Map) state.computeIfAbsent("SEQDEF_MAP", x -> new LinkedHashMap<>()); for (Entry entry : seqDefMap.entrySet()) { - if (entry.getKey().equalsModProperty(RENAMING_TERM_PROPERTY, term)) { + if (entry.getKey().equalsModProperty(term, RENAMING_TERM_PROPERTY)) { return entry.getValue(); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java index ac9dbb940bb..a58ebad7a10 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java @@ -43,7 +43,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti Operator op = term.op(); if (op == bsumOp) { for (Term t : usedBsumTerms.keySet()) { - if (t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { + if (t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { return usedBsumTerms.get(t); } } @@ -57,7 +57,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti return ret; } else if (op == bprodOp) { for (Term t : usedBprodTerms.keySet()) { - if (t.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { + if (t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { return usedBprodTerms.get(t); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java index fbf3162abbe..3ed28c67ed0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/ContractFactory.java @@ -454,7 +454,7 @@ private static void combineModifies(FunctionalOperationContractImpl t, // check if the other mod is the same as the one in the uniform store. // To obtain meaningful results, check for equality ignoring all term labels! if (uniformMod.containsKey(h)) { - if (!uniformMod.get(h).equalsModProperty(TERM_LABELS_PROPERTY, m2)) { + if (!uniformMod.get(h).equalsModProperty(m2, TERM_LABELS_PROPERTY)) { uniformMod.remove(h); } else { // merge term labels (in particular origin labels) of both modifies diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java index 8652f6565d4..036738a9450 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java @@ -1366,14 +1366,14 @@ public String toString() { ((Services) services).getTypeConverter().getHeapLDT().getHeap(); return (globalDefs == null ? "" : "defs: " + globalDefs + "; ") + "pre: " + originalPres + (originalFreePres.get(heap) != null - && !originalFreePres.get(heap).equalsModProperty(RENAMING_TERM_PROPERTY, - tb.tt()) + && !originalFreePres.get(heap).equalsModProperty(tb.tt(), RENAMING_TERM_PROPERTY + ) ? "free pre: " + originalFreePres : "") + "; mby: " + originalMby + "; post: " + originalPosts + (originalFreePosts.get(heap) != null - && !originalFreePosts.get(heap).equalsModProperty(RENAMING_TERM_PROPERTY, - tb.tt()) + && !originalFreePosts.get(heap).equalsModProperty(tb.tt(), RENAMING_TERM_PROPERTY + ) ? "free post: " + originalFreePosts : "") + "; mods: " + originalMods + "; hasMod: " + hasRealModifiesClause diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java index a60cb3aea4d..2e2f4b30e3a 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java @@ -399,8 +399,8 @@ private String getText(boolean includeHtmlMarkup, Services services) { final boolean showSig = !isInv && !modelField(); if (getAssignable() != null && showSig) { String printMods = LogicPrinter.quickPrintTerm( - getAssignable(null).equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - TB.strictlyNothing()) ? TB.empty() + getAssignable(null).equalsModProperty(TB.strictlyNothing(), IRRELEVANT_TERM_LABELS_PROPERTY + ) ? TB.empty() : this.getAssignable(null), services); mods = mods + (includeHtmlMarkup ? "
" : "\n") + "mod" @@ -734,24 +734,24 @@ final void setAssignable(Term ass, TermServices services) { this.assignable = ass; if (ass == null || TB.strictlyNothing().equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, ass) + ass, IRRELEVANT_TERM_LABELS_PROPERTY) || TB.FALSE().equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { + ass, IRRELEVANT_TERM_LABELS_PROPERTY)) { this.assignable = TB.strictlyNothing(); } else if (TB.tt().equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, ass) + ass, IRRELEVANT_TERM_LABELS_PROPERTY) || TB.TRUE().equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, ass)) { + ass, IRRELEVANT_TERM_LABELS_PROPERTY)) { this.assignable = TB.allLocs(); } } final void combineAssignable(Term ass1, Term ass2, TermServices services) { if (ass1 == null || TB.strictlyNothing().equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, ass1)) { + ass1, IRRELEVANT_TERM_LABELS_PROPERTY)) { setAssignable(ass2, services); } else if (ass2 == null || TB.strictlyNothing().equalsModProperty( - IRRELEVANT_TERM_LABELS_PROPERTY, ass2)) { + ass2, IRRELEVANT_TERM_LABELS_PROPERTY)) { setAssignable(ass1, services); } else { setAssignable(TB.union(ass1, ass2), services); @@ -1013,9 +1013,9 @@ public final Term getUpdates(Term mod, LocationVariable heap, ProgramVariable he Term anonHeap, TermServices services) { assert mod != null; assert anonHeap != null - || TB.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod); + || TB.strictlyNothing().equalsModProperty(mod, IRRELEVANT_TERM_LABELS_PROPERTY); final Term havocUpd = - TB.strictlyNothing().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, mod) ? TB.skip() + TB.strictlyNothing().equalsModProperty(mod, IRRELEVANT_TERM_LABELS_PROPERTY) ? TB.skip() : TB.elementary(heap, TB.anon(TB.var(heap), mod, anonHeap)); final Term oldUpd = heapAtPre != heap ? TB.elementary(TB.var(heapAtPre), TB.var(heap)) : TB.skip(); diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java index 237db934aa8..9e8eaadaa03 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java @@ -627,8 +627,8 @@ private Term translateUnionClauses(Context context, ImmutableList 1) { throw new SLTranslationException( "\"assignable \\less_than_nothing\" does not go with other " @@ -771,8 +771,8 @@ private boolean translateStrictlyPure(Context context, ImmutableList createDependencyOperationContract(IProgramMethod boolean createContract = true; for (LocationVariable heap : HeapContext.getModHeaps(services, false)) { - if (clauses.accessibles.get(heap).equalsModProperty(RENAMING_TERM_PROPERTY, - tb.allLocs())) { + if (clauses.accessibles.get(heap).equalsModProperty(tb.allLocs(), RENAMING_TERM_PROPERTY + )) { createContract = false; break; } if (pm.isModel() && pm.getStateCount() > 1) { if (clauses.accessibles.get(progVars.atPreVars.get(heap)) - .equalsModProperty(RENAMING_TERM_PROPERTY, tb.allLocs())) { + .equalsModProperty(tb.allLocs(), RENAMING_TERM_PROPERTY)) { createContract = false; break; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java index aeb8669043d..bf53f72336d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java @@ -132,8 +132,8 @@ private boolean independentSubformulas(PosInOccurrence changePos, SequentFormula changePos.replaceConstrainedFormula(newFormula); final Term afterChangeTerm = afterChangePos.subTerm(); return beforeChangeOp == afterChangeTerm.op() && beforeChangeTerm.sub(0) - .equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - afterChangeTerm.sub(0)); + .equalsModProperty(afterChangeTerm.sub(0), IRRELEVANT_TERM_LABELS_PROPERTY + ); } return false; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java index 61457b019b9..85bc997492d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java @@ -83,7 +83,7 @@ public boolean visitSubtree(Term visited) { @Override public void visit(Term visited) { - found = found || visited.equalsModProperty(RENAMING_TERM_PROPERTY, term); + found = found || visited.equalsModProperty(term, RENAMING_TERM_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java index 1158049e24c..1436995fac8 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java @@ -24,8 +24,8 @@ public final class DependencyContractFeature extends BinaryFeature { private void removePreviouslyUsedSteps(Term focus, Goal goal, List steps) { for (RuleApp app : goal.appliedRuleApps()) { if (app.rule() instanceof UseDependencyContractRule - && app.posInOccurrence().subTerm().equalsModProperty(RENAMING_TERM_PROPERTY, - focus)) { + && app.posInOccurrence().subTerm().equalsModProperty(focus, RENAMING_TERM_PROPERTY + )) { final IBuiltInRuleApp bapp = (IBuiltInRuleApp) app; for (PosInOccurrence ifInst : bapp.ifInsts()) { steps.remove(ifInst); diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java index 1de034ff47e..f4e508b34c4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java @@ -31,8 +31,8 @@ protected boolean filter(TacletApp app, PosInOccurrence pos, Goal goal, MutableS for (TacletGoalTemplate temp : ((Taclet) app.rule()).goalTemplates()) { RewriteTacletGoalTemplate rwtemp = (RewriteTacletGoalTemplate) temp; - if (rwtemp.replaceWith().equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - pos.subTerm())) { + if (rwtemp.replaceWith().equalsModProperty(pos.subTerm(), IRRELEVANT_TERM_LABELS_PROPERTY + )) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java index e96f9aabf3a..dcecdb4e948 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java @@ -84,7 +84,7 @@ public SubFormulaVisitor(Term potentialSub) { @Override public void visit(Term visited) { - isSubFormula |= visited.equalsModProperty(RENAMING_TERM_PROPERTY, potentialSub); + isSubFormula |= visited.equalsModProperty(potentialSub, RENAMING_TERM_PROPERTY); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/NonDuplicateAppModPositionFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/NonDuplicateAppModPositionFeature.java index 3ef82861e60..7ab6c3849e4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/NonDuplicateAppModPositionFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/NonDuplicateAppModPositionFeature.java @@ -24,7 +24,7 @@ protected boolean comparePio(TacletApp newApp, TacletApp oldApp, PosInOccurrence PosInOccurrence oldPio) { final Term newFocus = newPio.subTerm(); final Term oldFocus = oldPio.subTerm(); - if (!newFocus.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, oldFocus)) { + if (!newFocus.equalsModProperty(oldFocus, IRRELEVANT_TERM_LABELS_PROPERTY)) { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java index 2eaf38e0c6d..01d34f03719 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java @@ -181,8 +181,8 @@ protected int queryExpandAlreadyAppliedAtPos(RuleApp app, PosInOccurrence pos, G final Term oldterm = pio.subTerm(); final Term curterm = pos.subTerm(); if (appliedRuleApp.rule().equals(QueryExpand.INSTANCE) - && oldterm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - curterm)) { + && oldterm.equalsModProperty(curterm, IRRELEVANT_TERM_LABELS_PROPERTY + )) { count++; if (count > maxRepetitionsOnSameTerm) { break; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java index b40eaac454f..942d205e239 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/HandleArith.java @@ -54,7 +54,7 @@ public static Term provedByArith(Term problem, Services services) { final Term falseT = tb.ff(); final Term arithTerm = formatArithTerm(problem, tb, integerLDT, services.getCaches()); - if (arithTerm.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, falseT)) { + if (arithTerm.equalsModProperty(falseT, IRRELEVANT_TERM_LABELS_PROPERTY)) { result = provedArithEqual(problem, tb, services); putInTermCache(provedByArithCache, problem, result); return result; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java index c17d11dcf8a..f65cd882f6a 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java @@ -105,7 +105,7 @@ private Term provedBySelf(Term problem) { op = pro.op(); } if ((op == Equality.EQUALS || op == Equality.EQV) - && pro.sub(0).equalsModProperty(RENAMING_TERM_PROPERTY, pro.sub(1))) { + && pro.sub(0).equalsModProperty(pro.sub(1), RENAMING_TERM_PROPERTY)) { return negated ? falseT : trueT; } Term arithRes = HandleArith.provedByArith(pro, services); @@ -133,7 +133,7 @@ private Term directConsequenceOrContradictionOfAxiom(Term problem, Term axiom) { ax = ax.sub(0); negated = !negated; } - if (pro.equalsModProperty(RENAMING_TERM_PROPERTY, ax)) { + if (pro.equalsModProperty(ax, RENAMING_TERM_PROPERTY)) { return negated ? falseT : trueT; } return problem; @@ -347,7 +347,7 @@ public boolean selfRefine(ImmutableSet lits) { return true; } if (op == Junctor.FALSE - && terms[0].equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, terms[j])) { + && terms[0].equalsModProperty(terms[j], IRRELEVANT_TERM_LABELS_PROPERTY)) { next = next.remove(terms[j]); literals = literals.remove(terms[j]); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java index b1f5f5c69af..8b12fd667fd 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java @@ -31,6 +31,6 @@ private EqTermFeature(TermBuffer pattern) { @Override protected boolean filter(Term term, MutableState mState, Services services) { - return term.equalsModProperty(RENAMING_TERM_PROPERTY, pattern.getContent(mState)); + return term.equalsModProperty(pattern.getContent(mState), RENAMING_TERM_PROPERTY); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java index 5fb326c5063..1f3af595cb5 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java @@ -92,8 +92,8 @@ private Iterator emptyIterator() { } private Iterator toIterator(Term res) { - if (res.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, - tb.ff())) { + if (res.equalsModProperty(tb.ff(), IRRELEVANT_TERM_LABELS_PROPERTY + )) { return emptyIterator(); } return ImmutableSLList.nil().prepend(res).iterator(); diff --git a/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java b/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java index 7ca290362bb..8c1f23348e7 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java +++ b/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java @@ -1691,7 +1691,7 @@ static class TermWrapperFactory { public TermWrapper wrapTerm(Term term) { for (Term existingTerm : wrappedTerms) { - if (existingTerm.equalsModProperty(RENAMING_TERM_PROPERTY, term)) { + if (existingTerm.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { return new TermWrapper(term, existingTerm.hashCode()); } } @@ -1722,7 +1722,7 @@ record TermWrapper(Term term, int hashcode) { @Override public boolean equals(Object obj) { return obj instanceof TermWrapper - && term.equalsModProperty(RENAMING_TERM_PROPERTY, ((TermWrapper) obj).term()); + && term.equalsModProperty(((TermWrapper) obj).term(), RENAMING_TERM_PROPERTY); } @Override diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java index a5d9cd1ad8c..cb09af3e1dc 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java @@ -110,11 +110,11 @@ public void testProgramElementEqualsModRenaming() { Term match1 = TacletForTests.parseTerm("\\<{ int i; }\\>true & \\<{ int i; }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ int i; }\\>true "); assertTrue( - match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), + match1.sub(0).equalsModProperty(match2, RenamingTermProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming (0)."); assertTrue( - match1.sub(0).equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, - match1.sub(1)), + match1.sub(0).equalsModProperty(match1.sub(1), RenamingTermProperty.RENAMING_TERM_PROPERTY + ), "Terms should be equalModRenaming (1)."); Term match3 = TacletForTests.parseTerm("\\<{ int j = 0; }\\>true "); assertNotEquals(match1, match3, "Terms should not be equal."); @@ -125,15 +125,15 @@ public void testProgramElementEqualsModRenaming() { public void testEqualsModRenamingWithLabels() { Term match1 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); - assertTrue(match1.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match2), + assertTrue(match1.equalsModProperty(match2, RenamingTermProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming."); Term match3 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match4 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int j = 0; } } }\\>true"); - assertTrue(match3.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match4), + assertTrue(match3.equalsModProperty(match4, RenamingTermProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming."); Term match5 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match6 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); - assertTrue(match5.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, match6), + assertTrue(match5.equalsModProperty(match6, RenamingTermProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming."); } @@ -146,7 +146,7 @@ public void testEqualsModRenaming() { final Term pz = tf.createTerm(p, new Term[] { tf.createTerm(z) }, null, null); final Term quant2 = tb.all(z, tb.all(z, tb.all(z, pz))); - assertTrue(quant1.equalsModProperty(RenamingTermProperty.RENAMING_TERM_PROPERTY, quant2), + assertTrue(quant1.equalsModProperty(quant2, RenamingTermProperty.RENAMING_TERM_PROPERTY), "Terms " + quant1 + " and " + quant2 + " should be equal mod renaming"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java index 1075a05dd05..855f8ba7b9f 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java @@ -63,14 +63,14 @@ public void renaming() { tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); Term term2 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); - assertFalse(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); - assertFalse(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); // other tests for equality already in TestTerm.java // ------------ comparison with something that is not a term - assertFalse(term1.equalsModProperty(RENAMING_TERM_PROPERTY, 1), + assertFalse(term1.equalsModProperty(1, RENAMING_TERM_PROPERTY), "Should be false as other object is not a term"); // ------------ differing labels @@ -80,23 +80,23 @@ public void renaming() { tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); ImmutableArray labels1 = new ImmutableArray<>(irrelevantLabel); term1 = tb.label(term1, labels1); - assertTrue(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), "Should be true as labels do not matter"); - assertTrue(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), "Should be true as labels do not matter"); labels1 = new ImmutableArray<>(relevantLabel1); term1 = tb.label(term1, labels1); - assertTrue(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), "Should be true as labels do not matter"); - assertTrue(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), "Should be true as labels do not matter"); ImmutableArray labels2 = new ImmutableArray<>(relevantLabel2); term2 = tb.label(term2, labels2); - assertTrue(term1.equalsModProperty(RENAMING_TERM_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), "Should be true as labels do not matter"); - assertTrue(term2.equalsModProperty(RENAMING_TERM_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), "Should be true as labels do not matter"); } @@ -108,13 +108,13 @@ public void irrelevantTermLabels() { tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); Term term2 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); - assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, IRRELEVANT_TERM_LABELS_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); - assertFalse(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, IRRELEVANT_TERM_LABELS_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); // ------------ comparison with something that is not a term - assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, 1), + assertFalse(term1.equalsModProperty(1, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be false as other object is not a term"); // base terms stay the same for the rest of the tests @@ -127,16 +127,16 @@ public void irrelevantTermLabels() { ImmutableArray labels1 = new ImmutableArray<>(relevantLabel1, irrelevantLabel); term1 = tb.label(term1, labels1); - assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); - assertFalse(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); labels1 = new ImmutableArray<>(irrelevantLabel); term1 = tb.label(term1, labels1); - assertTrue(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be true as term1 has no relevant term labels and term2 does not have any labels"); - assertTrue(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be true as term1 has no relevant term labels and term2 does not have any labels"); // ------------ same relevant labels @@ -145,9 +145,9 @@ public void irrelevantTermLabels() { new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertTrue(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be true as both terms have the same relevant term labels"); - assertTrue(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be true as both terms have the same relevant term labels"); // ------------ not the same relevant labels @@ -155,27 +155,27 @@ public void irrelevantTermLabels() { labels2 = new ImmutableArray<>(relevantLabel1, relevantLabel2); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertFalse(term1.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be false as terms do not have the same relevant term labels"); - assertFalse(term2.equalsModProperty(IRRELEVANT_TERM_LABELS_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, IRRELEVANT_TERM_LABELS_PROPERTY), "Should be false as terms do not have the same relevant term labels"); } // equalsModProperty(...) with TERM_LABELS_PROPERTY @Test - public void AllTermLabels() { + public void allTermLabels() { // ------------ different terms to begin with Term term1 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); Term term2 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); - assertFalse(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, TERM_LABELS_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); - assertFalse(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, TERM_LABELS_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); // ------------ comparison with something that is not a term - assertFalse(term1.equalsModProperty(TERM_LABELS_PROPERTY, 1), + assertFalse(term1.equalsModProperty(1, TERM_LABELS_PROPERTY), "Should be false as other object is not a term"); // base terms stay the same for the rest of the tests @@ -188,9 +188,9 @@ public void AllTermLabels() { ImmutableArray labels1 = new ImmutableArray<>(relevantLabel1, irrelevantLabel); term1 = tb.label(term1, labels1); - assertTrue(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, TERM_LABELS_PROPERTY), "Should be true as underlying terms are equal"); - assertTrue(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, TERM_LABELS_PROPERTY), "Should be true as underlying terms are equal"); // ------------ same relevant labels @@ -199,9 +199,9 @@ public void AllTermLabels() { new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertTrue(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, TERM_LABELS_PROPERTY), "Should be true as underlying terms are equal"); - assertTrue(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, TERM_LABELS_PROPERTY), "Should be true as underlying terms are equal"); // ------------ not the same relevant labels @@ -209,9 +209,9 @@ public void AllTermLabels() { labels2 = new ImmutableArray<>(relevantLabel1, relevantLabel2); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertTrue(term1.equalsModProperty(TERM_LABELS_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, TERM_LABELS_PROPERTY), "Should be true as underlying terms are equal"); - assertTrue(term2.equalsModProperty(TERM_LABELS_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, TERM_LABELS_PROPERTY), "Should be true as underlying terms are equal"); } @@ -223,13 +223,13 @@ public void proofIrrelevancy() { tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); Term term2 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); - assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); - assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); // ------------ comparison with something that is not a term - assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, 1), + assertFalse(term1.equalsModProperty(1, PROOF_IRRELEVANCY_PROPERTY), "Should be false as other object is not a term"); // base terms stay the same for the rest of the tests @@ -242,16 +242,16 @@ public void proofIrrelevancy() { ImmutableArray labels1 = new ImmutableArray<>(relevantLabel1, irrelevantLabel); term1 = tb.label(term1, labels1); - assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); - assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), "Should be false as term1 has a proof relevant term label, but term2 does not have any labels"); labels1 = new ImmutableArray<>(irrelevantLabel); term1 = tb.label(term1, labels1); - assertTrue(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), "Should be true as term1 has no relevant term labels and term2 does not have any labels"); - assertTrue(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), "Should be true as term1 has no relevant term labels and term2 does not have any labels"); // ------------ same relevant labels @@ -260,18 +260,18 @@ public void proofIrrelevancy() { new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertTrue(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + assertTrue(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), "Should be true as both terms have the same relevant term labels"); - assertTrue(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + assertTrue(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), "Should be true as both terms have the same relevant term labels"); labels1 = new ImmutableArray<>(relevantLabel1, relevantLabel2, irrelevantLabel); labels2 = new ImmutableArray<>(relevantLabel1, relevantLabel2); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), "Should be false as both terms have a different number of labels"); - assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), "Should be false as both terms have a different number of labels"); // ------------ not the same relevant labels @@ -279,9 +279,9 @@ public void proofIrrelevancy() { labels2 = new ImmutableArray<>(relevantLabel2); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertFalse(term1.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term2), + assertFalse(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), "Should be false as terms do not have the same relevant term labels"); - assertFalse(term2.equalsModProperty(PROOF_IRRELEVANCY_PROPERTY, term1), + assertFalse(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), "Should be false as terms do not have the same relevant term labels"); } } diff --git a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java index 0b795e6b072..8bcf58141e3 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java +++ b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java @@ -256,7 +256,7 @@ public void test13() throws Exception { Term t4 = parseTerm("\\exists int_sort ci; (\\<{ int p_y = 1;" + " {int s = 2;} }\\>" + " true ->" + "\\<{ int p_y = 1;boolean p_x = 2<1;" + "while(p_x){ int s=3 ;} }\\>" + " true)"); - assertTrue(t3.equalsModProperty(RENAMING_TERM_PROPERTY, t4), + assertTrue(t3.equalsModProperty(t4, RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java index 12b4912366a..53d2dfea857 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java @@ -739,7 +739,7 @@ private void doTestCatchList(int p_proof) { Term resultFormula = goals.head().sequent().getFormulabyNr(1).formula(); Term correctFormula = correctSeq.getFormulabyNr(1).formula(); - assertTrue(resultFormula.equalsModProperty(RENAMING_TERM_PROPERTY, correctFormula), + assertTrue(resultFormula.equalsModProperty(correctFormula, RENAMING_TERM_PROPERTY), "Wrong result. Expected:" + ProofSaver.printAnything(correctFormula, TacletForTests.services()) + " But was:" + ProofSaver.printAnything(resultFormula, TacletForTests.services())); diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java index 9bf876e06d3..27e57b4fa09 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java @@ -24,7 +24,7 @@ void updateWithoutVariables() { Term term = TacletForTests.parseTerm("{i:=0}\\forall int a; a = i"); Term result = applyUpdateOnFormula(term); Term expected = TacletForTests.parseTerm("\\forall int a; {i:=0}(a = i)"); - assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), "Update without free variables was not properly applied on formula!"); term = TacletForTests.parseTerm("{i:=0}(i = 0)"); @@ -36,7 +36,7 @@ void updateWithoutVariables() { term = TacletForTests.parseTerm("{i:=0} f(const)"); result = applyUpdateOnTerm(term); expected = TacletForTests.parseTerm("f({i:=0} const)"); - assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), "Update without free variables was not properly applied on term!"); } @@ -50,21 +50,21 @@ void updateWithVariablesNoClash() { Term result = tb.all(b, applyUpdateOnFormula(term.sub(0))); Term expected = TacletForTests.parseTerm("\\forall int b; \\forall java.lang.Object a; {i:=b} (a = i)"); - assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), "Update is not simply pulled over quantification!"); term = TacletForTests.parseTerm("\\forall int b; {i:=b} (0 = i)"); b = term.boundVars().get(0); result = tb.all(b, applyUpdateOnFormula(term.sub(0))); expected = TacletForTests.parseTerm("\\forall int b; {i:=b} 0 = {i:=b} i"); - assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), "Update is not simply pulled over equality!"); term = TacletForTests.parseTerm("\\forall int b; {i:=b} f(const) = 0"); b = term.boundVars().get(0); result = tb.all(b, tb.equals(applyUpdateOnTerm(term.sub(0).sub(0)), term.sub(0).sub(1))); expected = TacletForTests.parseTerm("\\forall int b; f({i:=b} const) = 0"); - assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), "Update is not simply pulled over function symbol!"); } @@ -78,7 +78,7 @@ void updateWithVariablesAndClash() { Term result = tb.all(a, applyUpdateOnFormula(term.sub(0))); Term expected = TacletForTests .parseTerm("\\forall int a; \\forall java.lang.Object a1; {i:=a} (a1 = i)"); - assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), "Renaming or applying update afterwards !"); term = TacletForTests.parseTerm( @@ -88,7 +88,7 @@ void updateWithVariablesAndClash() { result = tb.all(a, tb.all(a1, applyUpdateOnFormula(term.sub(0).sub(0)))); expected = TacletForTests.parseTerm( "\\forall int a1; \\forall int a; \\forall java.lang.Object a2; {i:=a} (i = a1)"); - assertTrue(expected.equalsModProperty(RENAMING_TERM_PROPERTY, result), + assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), "Counter appended to stem was not increased high enough!"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java index ba4bce31b03..8c095a11241 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java +++ b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java @@ -92,7 +92,7 @@ public void testSMTLemmaSoundness(String name, String lemmaString) throws Except KeyIO io = new KeyIO(loadedProof.getServices()); Term parsedLemma = io.parseExpression(lemmaString); Term actual = loadedProof.root().sequent().succedent().get(0).formula(); - if (!actual.equalsModProperty(RENAMING_TERM_PROPERTY, parsedLemma)) { + if (!actual.equalsModProperty(parsedLemma, RENAMING_TERM_PROPERTY)) { LOGGER.info("Stored : {}", parsedLemma); LOGGER.warn("Proven : {}", actual); Assertions.fail("The proven lemma is different from the stored one."); diff --git a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java index 539397f6757..aac7e1acdee 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java +++ b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java @@ -180,7 +180,7 @@ public void testForAll() { services.getNamespaces().sorts().lookup(new Name("int"))); Term expected = TB.all(i, TB.imp(TB.inInt(TB.var(i)), TB.and(TB.leq(TB.zTerm("0"), TB.var(i)), TB.leq(TB.var(i), TB.zTerm("2147483647"))))); - assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), + assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -196,7 +196,7 @@ public void testForEx() { services.getNamespaces().sorts().lookup(new Name("int"))); Term expected = TB.ex(i, TB.and(TB.inInt(TB.var(i)), TB.and(TB.leq(TB.zTerm("0"), TB.var(i)), TB.leq(TB.var(i), TB.zTerm("2147483647"))))); - assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), + assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -212,7 +212,7 @@ public void testBsumInt() { TB.bsum(i, TB.zTerm("0"), TB.zTerm("2147483647"), TB.var(i))); assertNotNull(result); Assertions.assertSame(q, result.sub(0).op()); - assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), + assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -226,7 +226,7 @@ public void testBsumBigInt() { Term expected = TB.bsum(i, TB.zTerm("0"), TB.zTerm("2147483647"), TB.var(i)); assertNotNull(result); Assertions.assertSame(q, result.op()); - assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), + assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -243,7 +243,7 @@ public void testInfiniteUnion() { TB.not(TB.equals(TB.var(o), TB.NULL()))); Term expected = TB.infiniteUnion(new QuantifiableVariable[] { o }, TB.ife(guard, TB.empty(), TB.empty())); - assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), + assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -261,7 +261,7 @@ public void testInfiniteUnion2() { TB.or(TB.convertToFormula(TB.created(TB.var(o))), TB.equals(TB.var(o), TB.NULL())); Term expected = TB.infiniteUnion(new QuantifiableVariable[] { o }, TB.ife(guard, TB.empty(), TB.empty())); - assertTrue(result.equalsModProperty(RENAMING_TERM_PROPERTY, expected), + assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -440,7 +440,7 @@ public void testCorrectImplicitThisResolution() { TB.not(TB.equals(TB.var(qv), TB.NULL()))), // implicit non null TB.equals(TB.var(qv), TB.var(selfVar)))); - final boolean condition = result.equalsModProperty(RENAMING_TERM_PROPERTY, expected); + final boolean condition = result.equalsModProperty(expected, RENAMING_TERM_PROPERTY); assertTrue(condition, format("Expected:%s\n Was:%s", ProofSaver.printTerm(expected, services), ProofSaver.printTerm(result, services))); } From c66a91ef32990a6fb5ef4f17c0703141a30cc289 Mon Sep 17 00:00:00 2001 From: Tobias Date: Sat, 13 Jan 2024 16:11:56 +0100 Subject: [PATCH 15/22] move equalsModRenaming from JavaBlock to RenamingProperty --- .../util/SymbolicExecutionUtil.java | 58 +++++++++---------- .../StartAuxiliaryBlockComputationMacro.java | 2 +- .../StartAuxiliaryLoopComputationMacro.java | 2 +- .../StartAuxiliaryMethodComputationMacro.java | 2 +- .../ilkd/key/logic/BoundVariableTools.java | 2 +- .../java/de/uka/ilkd/key/logic/JavaBlock.java | 26 --------- .../uka/ilkd/key/logic/LabeledTermImpl.java | 7 ++- .../de/uka/ilkd/key/logic/Semisequent.java | 6 +- .../IrrelevantTermLabelsProperty.java | 4 +- ...ermProperty.java => RenamingProperty.java} | 28 +++++++-- .../logic/equality/TermEqualsModProperty.java | 2 +- .../key/logic/label/TermLabelManager.java | 6 +- .../ilkd/key/macros/scripts/FocusCommand.java | 2 +- .../macros/scripts/InstantiateCommand.java | 6 +- .../key/macros/scripts/RewriteCommand.java | 2 +- .../ilkd/key/macros/scripts/RuleCommand.java | 2 +- .../key/macros/scripts/SelectCommand.java | 2 +- .../ilkd/key/proof/join/JoinIsApplicable.java | 2 +- .../key/rule/AuxiliaryContractBuilders.java | 4 +- .../uka/ilkd/key/rule/OneStepSimplifier.java | 2 +- .../uka/ilkd/key/rule/WhileInvariantRule.java | 6 +- .../ApplyUpdateOnRigidCondition.java | 2 +- .../ilkd/key/rule/inst/SVInstantiations.java | 7 +-- .../key/rule/match/legacy/ElementMatcher.java | 2 +- .../key/rule/match/vm/VMTacletMatcher.java | 2 +- .../MatchSchemaVariableInstruction.java | 2 +- .../de/uka/ilkd/key/rule/merge/MergeRule.java | 2 +- .../rule/metaconstruct/IntroAtPreDefsOp.java | 7 +-- .../ilkd/key/smt/AbstractSMTTranslator.java | 2 +- .../ilkd/key/smt/newsmt2/SeqDefHandler.java | 2 +- .../ilkd/key/smt/newsmt2/SumProdHandler.java | 2 +- .../FunctionalOperationContractImpl.java | 10 ++-- .../key/speclang/WellDefinednessCheck.java | 16 ++--- .../jml/translation/JMLSpecFactory.java | 14 ++--- .../key/strategy/FindTacletAppContainer.java | 4 +- .../strategy/feature/ContainsTermFeature.java | 2 +- .../feature/DependencyContractFeature.java | 6 +- .../DiffFindAndReplacewithFeature.java | 4 +- ...SubFormulaOfInfFlowContractAppFeature.java | 2 +- .../key/strategy/feature/QueryExpandCost.java | 4 +- .../EqualityConstraint.java | 4 +- .../PredictCostProver.java | 2 +- .../strategy/termfeature/EqTermFeature.java | 2 +- .../termgenerator/RootsGenerator.java | 3 +- .../key/util/mergerule/MergeRuleUtils.java | 2 +- .../java/de/uka/ilkd/key/logic/TestTerm.java | 15 +++-- .../logic/equality/TestEqualsModProperty.java | 2 +- .../uka/ilkd/key/parser/TestTermParser.java | 2 +- .../de/uka/ilkd/key/rule/TestApplyTaclet.java | 2 +- .../TestApplyUpdateOnRigidCondition.java | 2 +- .../key/smt/newsmt2/ProveSMTLemmasTest.java | 2 +- .../key/speclang/jml/TestJMLTranslator.java | 2 +- 52 files changed, 148 insertions(+), 157 deletions(-) rename key.core/src/main/java/de/uka/ilkd/key/logic/equality/{RenamingTermProperty.java => RenamingProperty.java} (87%) diff --git a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java index 47f1d1d3860..40f2d639722 100644 --- a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java +++ b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java @@ -72,7 +72,7 @@ import org.slf4j.LoggerFactory; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * Provides utility methods for symbolic execution with KeY. @@ -1980,15 +1980,15 @@ private static void collectSpecifcationCasesPreconditions(Term normalExcDefiniti if (term.op() == Junctor.AND) { Term lastChild = term.sub(term.arity() - 1); if (lastChild.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY) - || lastChild.equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + || lastChild.equalsModProperty(exceptionalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { // Nothing to do, condition is just true } else { Term firstChild = term.sub(0); if (firstChild .equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY) - || firstChild.equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + || firstChild.equalsModProperty(exceptionalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { // Nothing to do, condition is just true } else { for (int i = 0; i < term.arity(); i++) { @@ -2001,31 +2001,31 @@ private static void collectSpecifcationCasesPreconditions(Term normalExcDefiniti } else if (term.op() == Junctor.IMP) { Term leftTerm = term.sub(0); if (leftTerm.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY) - || leftTerm.equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + || leftTerm.equalsModProperty(exceptionalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { // Nothing to do, condition is just true } else { Term rightTerm = term.sub(1); // Deal with heavy weight specification cases if (rightTerm.op() == Junctor.AND && rightTerm.sub(0).op() == Junctor.IMP && rightTerm.sub(0).sub(0) - .equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + .equalsModProperty(normalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { normalConditions.add(leftTerm); } else if (rightTerm.op() == Junctor.AND && rightTerm.sub(1).op() == Junctor.IMP && rightTerm.sub(1).sub(0) - .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + .equalsModProperty(exceptionalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { exceptinalConditions.add(leftTerm); } // Deal with light weight specification cases else if (rightTerm.op() == Junctor.IMP - && rightTerm.sub(0).equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + && rightTerm.sub(0).equalsModProperty(normalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { normalConditions.add(leftTerm); } else if (rightTerm.op() == Junctor.IMP && rightTerm.sub(0) - .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + .equalsModProperty(exceptionalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { exceptinalConditions.add(leftTerm); } else { Term excCondition = rightTerm; @@ -2033,23 +2033,23 @@ else if (rightTerm.op() == Junctor.IMP if (excCondition.op() == Junctor.AND) { excCondition = excCondition.sub(excCondition.arity() - 1); } - if (excCondition.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (excCondition.equalsModProperty(normalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { normalConditions.add(leftTerm); } else if (excCondition - .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + .equalsModProperty(exceptionalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { exceptinalConditions.add(leftTerm); } else { // Check if left child is exception definition if (rightTerm.op() == Junctor.AND) { excCondition = rightTerm.sub(0); - if (excCondition.equalsModProperty(normalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (excCondition.equalsModProperty(normalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { normalConditions.add(leftTerm); } else if (excCondition - .equalsModProperty(exceptionalExcDefinition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + .equalsModProperty(exceptionalExcDefinition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { exceptinalConditions.add(leftTerm); } else { throw new ProofInputException("Exeptional condition expected, " @@ -3422,13 +3422,13 @@ private static List findSkolemReplacements(Sequent sequent, Term skolemCon if (term != skolemEquality) { int skolemCheck = checkSkolemEquality(term); if (skolemCheck == -1) { - if (term.sub(0).equalsModProperty(skolemConstant, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (term.sub(0).equalsModProperty(skolemConstant, + IRRELEVANT_TERM_LABELS_PROPERTY)) { result.add(term.sub(1)); } } else if (skolemCheck == 1) { - if (term.sub(1).equalsModProperty(skolemConstant, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (term.sub(1).equalsModProperty(skolemConstant, + IRRELEVANT_TERM_LABELS_PROPERTY)) { result.add(term.sub(0)); } } @@ -3518,8 +3518,8 @@ public static Term computePathCondition(Node parentNode, Node childNode, boolean } childNode = parent; } - if (services.getTermBuilder().ff().equalsModProperty(pathCondition, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (services.getTermBuilder().ff().equalsModProperty(pathCondition, + IRRELEVANT_TERM_LABELS_PROPERTY)) { throw new ProofInputException( "Path condition computation failed because the result is false."); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java index b8f83b1f119..7fd6ac4c639 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java @@ -24,7 +24,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java index ac99f63d94a..f2e6191560b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java @@ -25,7 +25,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; public class StartAuxiliaryLoopComputationMacro extends AbstractProofMacro implements StartSideProofMacro { diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java index 9c2ec5dda28..65271a84df0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java @@ -22,7 +22,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java index cad52501053..06b13c448a8 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java @@ -13,7 +13,7 @@ import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/JavaBlock.java b/key.core/src/main/java/de/uka/ilkd/key/logic/JavaBlock.java index bb1fd622065..032ca403c37 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/JavaBlock.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/JavaBlock.java @@ -4,7 +4,6 @@ package de.uka.ilkd.key.logic; import de.uka.ilkd.key.java.JavaProgramElement; -import de.uka.ilkd.key.java.NameAbstractionTable; import de.uka.ilkd.key.java.StatementBlock; import de.uka.ilkd.key.pp.PrettyPrinter; @@ -90,31 +89,6 @@ public boolean equals(Object o) { } } - /** - * returns true if the given ProgramElement is equal to the one of the JavaBlock modulo renaming - * (see comment in SourceElement) - */ - public boolean equalsModRenaming(Object o, NameAbstractionTable nat) { - if (!(o instanceof JavaBlock)) { - return false; - } - return equalsModRenaming(((JavaBlock) o).program(), nat); - } - - - /** - * returns true if the given ProgramElement is equal to the one of the JavaBlock modulo renaming - * (see comment in SourceElement) - */ - private boolean equalsModRenaming(JavaProgramElement pe, NameAbstractionTable nat) { - if (pe == null && program() == null) { - return true; - } else if (pe != null && program() != null) { - return program().equalsModRenaming(pe, nat); - } - return false; - } - /** * returns the java program * diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java index f8c4a77aba9..7db0022e77b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java @@ -7,7 +7,7 @@ import java.util.stream.Collectors; import de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty; -import de.uka.ilkd.key.logic.equality.RenamingTermProperty; +import de.uka.ilkd.key.logic.equality.RenamingProperty; import de.uka.ilkd.key.logic.equality.TermEqualsModProperty; import de.uka.ilkd.key.logic.equality.TermProperty; import de.uka.ilkd.key.logic.label.TermLabel; @@ -24,9 +24,10 @@ *

* * Two labeled terms are equal if they have equal term structure and equal annotations. In contrast, - * the method {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)} can be used to compare terms + * the method {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)} can be used to + * compare terms * while ignoring certain - * given properties. E.g. by using {@link RenamingTermProperty#RENAMING_TERM_PROPERTY}, just the + * given properties. E.g. by using {@link RenamingProperty#RENAMING_TERM_PROPERTY}, just the * term structures modulo * renaming are compared whilst ignoring annotations. *

diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java index b168ec3c794..417c391cfd4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java @@ -8,7 +8,7 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** @@ -159,8 +159,8 @@ private SemisequentChangeInfo insertAndRemoveRedundancyHelper(int idx, searchList = searchList.tail(); if (sequentFormula != null - && cf.formula().equalsModProperty(sequentFormula.formula(), RENAMING_TERM_PROPERTY - )) { + && cf.formula().equalsModProperty(sequentFormula.formula(), + RENAMING_TERM_PROPERTY)) { semiCI.rejectedFormula(sequentFormula); return semiCI; // semisequent already contains formula diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index 5092eacc2e0..fa898737d39 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -71,8 +71,8 @@ public Boolean equalsModThisProperty(Term term, Object o) { final ImmutableArray otherSubs = other.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), + IRRELEVANT_TERM_LABELS_PROPERTY)) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java similarity index 87% rename from key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java rename to key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java index 6f0dc65294c..658e566b807 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingTermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java @@ -3,7 +3,9 @@ * SPDX-License-Identifier: GPL-2.0-only */ package de.uka.ilkd.key.logic.equality; +import de.uka.ilkd.key.java.JavaProgramElement; import de.uka.ilkd.key.java.NameAbstractionTable; +import de.uka.ilkd.key.logic.JavaBlock; import de.uka.ilkd.key.logic.Term; import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.logic.op.ProgramVariable; @@ -18,19 +20,19 @@ * {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)}. * Renaming of variables is ignored in this equality check. */ -public class RenamingTermProperty implements TermProperty { +public class RenamingProperty implements TermProperty { /** * The single instance of this property. */ - public static final RenamingTermProperty RENAMING_TERM_PROPERTY = new RenamingTermProperty(); + public static final RenamingProperty RENAMING_TERM_PROPERTY = new RenamingProperty(); /** * This constructor is private as a single instance of this class should be shared. The instance * can be accessed - * through {@link RenamingTermProperty#RENAMING_TERM_PROPERTY} and is used as a parameter for + * through {@link RenamingProperty#RENAMING_TERM_PROPERTY} and is used as a parameter for * {@link TermProperty#equalsModThisProperty(Term, Object)}. */ - private RenamingTermProperty() {} + private RenamingProperty() {} /** * Checks if {@code o} is a term syntactically equal to {@code term} modulo bound renaming. @@ -160,7 +162,7 @@ private static NameAbstractionTable handleJava(Term t0, Term t1, NameAbstraction if (!t0.javaBlock().isEmpty() || !t1.javaBlock().isEmpty()) { nat = checkNat(nat); - if (!t0.javaBlock().equalsModRenaming(t1.javaBlock(), nat)) { + if (javaBlocksNotEqualModRenaming(t0.javaBlock(), t1.javaBlock(), nat)) { return FAILED; } } @@ -178,6 +180,22 @@ private static NameAbstractionTable handleJava(Term t0, Term t1, NameAbstraction return nat; } + /** + * returns true if the given ProgramElement is equal to the one of the JavaBlock modulo renaming + * (see comment in SourceElement) + */ + public static boolean javaBlocksNotEqualModRenaming(JavaBlock jb1, JavaBlock jb2, + NameAbstractionTable nat) { + JavaProgramElement pe1 = jb1.program(); + JavaProgramElement pe2 = jb2.program(); + if (pe1 == null && pe2 == null) { + return false; + } else if (pe1 != null && pe2 != null) { + return !pe1.equalsModRenaming(pe2, nat); + } + return true; + } + private boolean descendRecursively(Term t0, Term t1, ImmutableList ownBoundVars, ImmutableList cmpBoundVars, NameAbstractionTable nat) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java index 251ec239a7b..6d541d2e72b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermEqualsModProperty.java @@ -15,7 +15,7 @@ public interface TermEqualsModProperty { * Checks whether this object is equal to {@code o} modulo the property described by * {@code property}. * - * @param o the object that is checked for equality + * @param o the object that is checked for equality * @param property the property to be ignored in the equality check * @return whether this object is equal to o */ diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java index d030e3fe083..dc156a0de8d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java @@ -29,7 +29,7 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.java.CollectionUtil; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** *

@@ -2012,8 +2012,8 @@ protected void mergeLabels(SequentChangeInfo currentSequent, Services services, // Search existing SequentFormula Semisequent s = currentSequent.getSemisequentChangeInfo(inAntecedent).semisequent(); SequentFormula existingSF = CollectionUtil.search(s, - element -> element.formula().equalsModProperty(rejectedTerm, RENAMING_TERM_PROPERTY - )); + element -> element.formula().equalsModProperty(rejectedTerm, + RENAMING_TERM_PROPERTY)); if (existingSF != null) { // Create list of new labels Term existingTerm = existingSF.formula(); diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java index 600decc3a78..1afa11def64 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java @@ -18,7 +18,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * The command "focus" allows you to select formulas from the current sequent diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java index a5068943243..5660620c714 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java @@ -24,7 +24,7 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * instantiate var=a occ=2 with="a_8" hide @@ -135,8 +135,8 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta private TacletApp filterList(Parameters p, ImmutableList list) { for (TacletApp tacletApp : list) { if (tacletApp instanceof PosTacletApp pta) { - if (pta.posInOccurrence().subTerm().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY - )) { + if (pta.posInOccurrence().subTerm().equalsModProperty(p.formula, + RENAMING_TERM_PROPERTY)) { return pta; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java index 4695163c98d..3f58900ec70 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java @@ -22,7 +22,7 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * This class provides the command rewrite. diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java index 391f797fd71..d7517a71dce 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java @@ -23,7 +23,7 @@ import org.key_project.util.collection.ImmutableSLList; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * Command that applies a calculus rule All parameters are passed as strings and converted by the diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java index 3c8978e0113..d4a02ff67db 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java @@ -20,7 +20,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; public class SelectCommand extends AbstractCommand { public SelectCommand() { diff --git a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java index 2f8c0bb4b34..662e80a056d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java +++ b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java @@ -13,7 +13,7 @@ import de.uka.ilkd.key.logic.op.UpdateApplication; import de.uka.ilkd.key.proof.Goal; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * Methods for checking the applicability of a join for a given selection and thereby computing the diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java index 85b2f41b3f4..6c1d0da58e2 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/AuxiliaryContractBuilders.java @@ -651,8 +651,8 @@ public Term buildAnonOutUpdate(final Set vars, .entrySet()) { Term anonymisationUpdate = skip(); final Term modifiesClause = modifiesClauses.get(anonymisationHeap.getKey()); - if (!modifiesClause.equalsModProperty(strictlyNothing(), IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (!modifiesClause.equalsModProperty(strictlyNothing(), + IRRELEVANT_TERM_LABELS_PROPERTY)) { anonymisationUpdate = anonUpd(anonymisationHeap.getKey(), modifiesClause, services.getTermBuilder().label( services.getTermBuilder().func(anonymisationHeap.getValue()), diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java index d70e6734750..da0fdfb0db1 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java @@ -46,7 +46,7 @@ import org.jspecify.annotations.NonNull; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; public final class OneStepSimplifier implements BuiltInRule { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java index cb50fc90005..8ecdd0b4a80 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/WhileInvariantRule.java @@ -831,16 +831,16 @@ public ImmutableList apply(Goal goal, Services services, final RuleApp rul final Term strictlyNothing = tb.strictlyNothing(); final Term currentFrame; if (strictlyNothing.equalsModProperty( - mod, IRRELEVANT_TERM_LABELS_PROPERTY)) { + mod, IRRELEVANT_TERM_LABELS_PROPERTY)) { if (strictlyNothing.equalsModProperty( - freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { + freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { currentFrame = tb.frameStrictlyEmpty(tb.var(heap), heapToBeforeLoop.get(heap)); } else { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), freeMod); } } else { if (strictlyNothing.equalsModProperty( - freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { + freeMod, IRRELEVANT_TERM_LABELS_PROPERTY)) { currentFrame = tb.frame(tb.var(heap), heapToBeforeLoop.get(heap), mod); } else { currentFrame = tb.frame( diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java index 333b006fc21..70d649e8b01 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java @@ -15,7 +15,7 @@ import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java index d465f6f2288..0d4081a0f9d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java @@ -546,8 +546,8 @@ public boolean equals(Object obj) { final Object inst = e.value().getInstantiation(); assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { - if (!instAsTerm.equalsModProperty(cmp.getInstantiation(e.key()), IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (!instAsTerm.equalsModProperty(cmp.getInstantiation(e.key()), + IRRELEVANT_TERM_LABELS_PROPERTY)) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { @@ -578,8 +578,7 @@ public boolean equalsModProofIrrelevancy(Object obj) { assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { if (!instAsTerm.equalsModProperty( - cmp.getInstantiation(e.key()), IRRELEVANT_TERM_LABELS_PROPERTY - )) { + cmp.getInstantiation(e.key()), IRRELEVANT_TERM_LABELS_PROPERTY)) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java index f83c544c76d..dadfda0ecb9 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java @@ -17,7 +17,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; public abstract class ElementMatcher { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java index 834ef05a284..61fb06e18ce 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java @@ -35,7 +35,7 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** *

diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java index 9ff0c73212c..6345d318a62 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java @@ -14,7 +14,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; public abstract class MatchSchemaVariableInstruction extends Instruction { diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java index cad179b7c94..349a6719920 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java @@ -49,7 +49,7 @@ import org.jspecify.annotations.NonNull; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.clearSemisequent; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.closeMergePartnerGoal; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.getConjunctiveElementsFor; diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java index 4488007703d..9cd6157b990 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/metaconstruct/IntroAtPreDefsOp.java @@ -223,8 +223,8 @@ public void performActionOnLoopInvariant(final LoopSpecification spec) { final Term freeTerm = spec.getInternalFreeModifies().getOrDefault( services.getTypeConverter().getHeapLDT().getHeap(), tb.strictlyNothing()); if (heap != services.getTypeConverter().getHeapLDT().getSavedHeap() - || !tb.strictlyNothing().equalsModProperty(term, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + || !tb.strictlyNothing().equalsModProperty(term, + IRRELEVANT_TERM_LABELS_PROPERTY)) { final Term m = spec.getModifies(heap, self, atPres, services); final ImmutableList infFlowSpecs = spec.getInfFlowSpecs(heap, self, atPres, services); @@ -239,8 +239,7 @@ public void performActionOnLoopInvariant(final LoopSpecification spec) { } if (heap != services.getTypeConverter().getHeapLDT().getSavedHeap() || !tb.strictlyNothing().equalsModProperty( - freeTerm, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + freeTerm, IRRELEVANT_TERM_LABELS_PROPERTY)) { final Term m = spec.getFreeModifies(heap, selfTerm, atPres, services); final ImmutableList infFlowSpecs = spec.getInfFlowSpecs(heap, selfTerm, atPres, services); diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java b/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java index dd4d0fa3a6d..6349986e488 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/AbstractSMTTranslator.java @@ -24,7 +24,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.smt.SMTProblem.sequentToTerm; /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java index cbb17d8f795..e360c274ca1 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java @@ -29,7 +29,7 @@ import org.key_project.util.collection.DefaultImmutableSet; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * This handler handles the seqDef binder function specially. diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java index a58ebad7a10..2b176f56a6b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java @@ -11,7 +11,7 @@ import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.smt.SMTTranslationException; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; // W I P public class SumProdHandler implements SMTHandler { diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java index 036738a9450..f7cd55c8bfc 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java @@ -33,7 +33,7 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.java.MapUtil; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.util.Assert.assertEqualSort; import static de.uka.ilkd.key.util.Assert.assertSubSort; @@ -1366,14 +1366,14 @@ public String toString() { ((Services) services).getTypeConverter().getHeapLDT().getHeap(); return (globalDefs == null ? "" : "defs: " + globalDefs + "; ") + "pre: " + originalPres + (originalFreePres.get(heap) != null - && !originalFreePres.get(heap).equalsModProperty(tb.tt(), RENAMING_TERM_PROPERTY - ) + && !originalFreePres.get(heap).equalsModProperty(tb.tt(), + RENAMING_TERM_PROPERTY) ? "free pre: " + originalFreePres : "") + "; mby: " + originalMby + "; post: " + originalPosts + (originalFreePosts.get(heap) != null - && !originalFreePosts.get(heap).equalsModProperty(tb.tt(), RENAMING_TERM_PROPERTY - ) + && !originalFreePosts.get(heap).equalsModProperty(tb.tt(), + RENAMING_TERM_PROPERTY) ? "free post: " + originalFreePosts : "") + "; mods: " + originalMods + "; hasMod: " + hasRealModifiesClause diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java index 2e2f4b30e3a..113538d172b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/WellDefinednessCheck.java @@ -399,8 +399,8 @@ private String getText(boolean includeHtmlMarkup, Services services) { final boolean showSig = !isInv && !modelField(); if (getAssignable() != null && showSig) { String printMods = LogicPrinter.quickPrintTerm( - getAssignable(null).equalsModProperty(TB.strictlyNothing(), IRRELEVANT_TERM_LABELS_PROPERTY - ) ? TB.empty() + getAssignable(null).equalsModProperty(TB.strictlyNothing(), + IRRELEVANT_TERM_LABELS_PROPERTY) ? TB.empty() : this.getAssignable(null), services); mods = mods + (includeHtmlMarkup ? "
" : "\n") + "mod" @@ -734,24 +734,24 @@ final void setAssignable(Term ass, TermServices services) { this.assignable = ass; if (ass == null || TB.strictlyNothing().equalsModProperty( - ass, IRRELEVANT_TERM_LABELS_PROPERTY) + ass, IRRELEVANT_TERM_LABELS_PROPERTY) || TB.FALSE().equalsModProperty( - ass, IRRELEVANT_TERM_LABELS_PROPERTY)) { + ass, IRRELEVANT_TERM_LABELS_PROPERTY)) { this.assignable = TB.strictlyNothing(); } else if (TB.tt().equalsModProperty( - ass, IRRELEVANT_TERM_LABELS_PROPERTY) + ass, IRRELEVANT_TERM_LABELS_PROPERTY) || TB.TRUE().equalsModProperty( - ass, IRRELEVANT_TERM_LABELS_PROPERTY)) { + ass, IRRELEVANT_TERM_LABELS_PROPERTY)) { this.assignable = TB.allLocs(); } } final void combineAssignable(Term ass1, Term ass2, TermServices services) { if (ass1 == null || TB.strictlyNothing().equalsModProperty( - ass1, IRRELEVANT_TERM_LABELS_PROPERTY)) { + ass1, IRRELEVANT_TERM_LABELS_PROPERTY)) { setAssignable(ass2, services); } else if (ass2 == null || TB.strictlyNothing().equalsModProperty( - ass2, IRRELEVANT_TERM_LABELS_PROPERTY)) { + ass2, IRRELEVANT_TERM_LABELS_PROPERTY)) { setAssignable(ass1, services); } else { setAssignable(TB.union(ass1, ass2), services); diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java index 9e8eaadaa03..cf59890b49d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java @@ -52,7 +52,7 @@ import org.jspecify.annotations.Nullable; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.DIVERGES; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.SIGNALS; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.ClauseHd.ENSURES; @@ -627,8 +627,8 @@ private Term translateUnionClauses(Context context, ImmutableList 1) { throw new SLTranslationException( "\"assignable \\less_than_nothing\" does not go with other " @@ -771,8 +771,8 @@ private boolean translateStrictlyPure(Context context, ImmutableList createDependencyOperationContract(IProgramMethod boolean createContract = true; for (LocationVariable heap : HeapContext.getModHeaps(services, false)) { - if (clauses.accessibles.get(heap).equalsModProperty(tb.allLocs(), RENAMING_TERM_PROPERTY - )) { + if (clauses.accessibles.get(heap).equalsModProperty(tb.allLocs(), + RENAMING_TERM_PROPERTY)) { createContract = false; break; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java index bf53f72336d..274eeff1e93 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java @@ -132,8 +132,8 @@ private boolean independentSubformulas(PosInOccurrence changePos, SequentFormula changePos.replaceConstrainedFormula(newFormula); final Term afterChangeTerm = afterChangePos.subTerm(); return beforeChangeOp == afterChangeTerm.op() && beforeChangeTerm.sub(0) - .equalsModProperty(afterChangeTerm.sub(0), IRRELEVANT_TERM_LABELS_PROPERTY - ); + .equalsModProperty(afterChangeTerm.sub(0), + IRRELEVANT_TERM_LABELS_PROPERTY); } return false; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java index 85bc997492d..1ab3a2093ee 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java @@ -13,7 +13,7 @@ import de.uka.ilkd.key.strategy.TopRuleAppCost; import de.uka.ilkd.key.strategy.termProjection.ProjectionToTerm; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java index 1436995fac8..37311a23005 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java @@ -17,15 +17,15 @@ import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; public final class DependencyContractFeature extends BinaryFeature { private void removePreviouslyUsedSteps(Term focus, Goal goal, List steps) { for (RuleApp app : goal.appliedRuleApps()) { if (app.rule() instanceof UseDependencyContractRule - && app.posInOccurrence().subTerm().equalsModProperty(focus, RENAMING_TERM_PROPERTY - )) { + && app.posInOccurrence().subTerm().equalsModProperty(focus, + RENAMING_TERM_PROPERTY)) { final IBuiltInRuleApp bapp = (IBuiltInRuleApp) app; for (PosInOccurrence ifInst : bapp.ifInsts()) { steps.remove(ifInst); diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java index f4e508b34c4..995a740e82e 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DiffFindAndReplacewithFeature.java @@ -31,8 +31,8 @@ protected boolean filter(TacletApp app, PosInOccurrence pos, Goal goal, MutableS for (TacletGoalTemplate temp : ((Taclet) app.rule()).goalTemplates()) { RewriteTacletGoalTemplate rwtemp = (RewriteTacletGoalTemplate) temp; - if (rwtemp.replaceWith().equalsModProperty(pos.subTerm(), IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (rwtemp.replaceWith().equalsModProperty(pos.subTerm(), + IRRELEVANT_TERM_LABELS_PROPERTY)) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java index dcecdb4e948..2733400dfac 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/FocusIsSubFormulaOfInfFlowContractAppFeature.java @@ -16,7 +16,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java index 01d34f03719..a0e6559c93c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/QueryExpandCost.java @@ -181,8 +181,8 @@ protected int queryExpandAlreadyAppliedAtPos(RuleApp app, PosInOccurrence pos, G final Term oldterm = pio.subTerm(); final Term curterm = pos.subTerm(); if (appliedRuleApp.rule().equals(QueryExpand.INSTANCE) - && oldterm.equalsModProperty(curterm, IRRELEVANT_TERM_LABELS_PROPERTY - )) { + && oldterm.equalsModProperty(curterm, + IRRELEVANT_TERM_LABELS_PROPERTY)) { count++; if (count > maxRepetitionsOnSameTerm) { break; diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/EqualityConstraint.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/EqualityConstraint.java index 4372490056c..62b85386cc0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/EqualityConstraint.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/EqualityConstraint.java @@ -13,6 +13,7 @@ import de.uka.ilkd.key.java.Services; import de.uka.ilkd.key.logic.BooleanContainer; import de.uka.ilkd.key.logic.Term; +import de.uka.ilkd.key.logic.equality.RenamingProperty; import de.uka.ilkd.key.logic.label.TermLabelState; import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.logic.op.ProgramVariable; @@ -413,7 +414,8 @@ private static NameAbstractionTable handleJava(Term t0, Term t1, NameAbstraction if (!t0.javaBlock().isEmpty() || !t1.javaBlock().isEmpty()) { nat = checkNat(nat); - if (!t0.javaBlock().equalsModRenaming(t1.javaBlock(), nat)) { + if (RenamingProperty.javaBlocksNotEqualModRenaming(t0.javaBlock(), t1.javaBlock(), + nat)) { return FAILED; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java index f65cd882f6a..653afe0402c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/quantifierHeuristics/PredictCostProver.java @@ -18,7 +18,7 @@ import org.key_project.util.collection.ImmutableSet; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * TODO: rewrite, this seems pretty inefficient ... diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java index 8b12fd667fd..4b94585469f 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/termfeature/EqTermFeature.java @@ -8,7 +8,7 @@ import de.uka.ilkd.key.strategy.feature.MutableState; import de.uka.ilkd.key.strategy.termProjection.TermBuffer; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * Term feature for testing equality of two terms. The feature returns zero iff it is invoked on a diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java index 1f3af595cb5..43ea6a2a68a 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/termgenerator/RootsGenerator.java @@ -92,8 +92,7 @@ private Iterator emptyIterator() { } private Iterator toIterator(Term res) { - if (res.equalsModProperty(tb.ff(), IRRELEVANT_TERM_LABELS_PROPERTY - )) { + if (res.equalsModProperty(tb.ff(), IRRELEVANT_TERM_LABELS_PROPERTY)) { return emptyIterator(); } return ImmutableSLList.nil().prepend(res).iterator(); diff --git a/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java b/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java index 8c1f23348e7..6f14c0f8cce 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java +++ b/key.core/src/main/java/de/uka/ilkd/key/util/mergerule/MergeRuleUtils.java @@ -40,7 +40,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * This class encapsulates static methods used in the MergeRule implementation. The methods are diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java index cb09af3e1dc..d2047a53169 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/TestTerm.java @@ -5,7 +5,7 @@ import de.uka.ilkd.key.java.StatementBlock; import de.uka.ilkd.key.java.declaration.LocalVariableDeclaration; -import de.uka.ilkd.key.logic.equality.RenamingTermProperty; +import de.uka.ilkd.key.logic.equality.RenamingProperty; import de.uka.ilkd.key.logic.op.*; import de.uka.ilkd.key.logic.sort.Sort; import de.uka.ilkd.key.logic.sort.SortImpl; @@ -110,11 +110,10 @@ public void testProgramElementEqualsModRenaming() { Term match1 = TacletForTests.parseTerm("\\<{ int i; }\\>true & \\<{ int i; }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ int i; }\\>true "); assertTrue( - match1.sub(0).equalsModProperty(match2, RenamingTermProperty.RENAMING_TERM_PROPERTY), + match1.sub(0).equalsModProperty(match2, RenamingProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming (0)."); assertTrue( - match1.sub(0).equalsModProperty(match1.sub(1), RenamingTermProperty.RENAMING_TERM_PROPERTY - ), + match1.sub(0).equalsModProperty(match1.sub(1), RenamingProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming (1)."); Term match3 = TacletForTests.parseTerm("\\<{ int j = 0; }\\>true "); assertNotEquals(match1, match3, "Terms should not be equal."); @@ -125,15 +124,15 @@ public void testProgramElementEqualsModRenaming() { public void testEqualsModRenamingWithLabels() { Term match1 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); - assertTrue(match1.equalsModProperty(match2, RenamingTermProperty.RENAMING_TERM_PROPERTY), + assertTrue(match1.equalsModProperty(match2, RenamingProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming."); Term match3 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match4 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int j = 0; } } }\\>true"); - assertTrue(match3.equalsModProperty(match4, RenamingTermProperty.RENAMING_TERM_PROPERTY), + assertTrue(match3.equalsModProperty(match4, RenamingProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming."); Term match5 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match6 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); - assertTrue(match5.equalsModProperty(match6, RenamingTermProperty.RENAMING_TERM_PROPERTY), + assertTrue(match5.equalsModProperty(match6, RenamingProperty.RENAMING_TERM_PROPERTY), "Terms should be equalModRenaming."); } @@ -146,7 +145,7 @@ public void testEqualsModRenaming() { final Term pz = tf.createTerm(p, new Term[] { tf.createTerm(z) }, null, null); final Term quant2 = tb.all(z, tb.all(z, tb.all(z, pz))); - assertTrue(quant1.equalsModProperty(quant2, RenamingTermProperty.RENAMING_TERM_PROPERTY), + assertTrue(quant1.equalsModProperty(quant2, RenamingProperty.RENAMING_TERM_PROPERTY), "Terms " + quant1 + " and " + quant2 + " should be equal mod renaming"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java index 855f8ba7b9f..147235413c0 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java @@ -19,7 +19,7 @@ import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; import static de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty.PROOF_IRRELEVANCY_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static de.uka.ilkd.key.logic.equality.TermLabelsProperty.TERM_LABELS_PROPERTY; import static org.junit.jupiter.api.Assertions.*; diff --git a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java index 8bcf58141e3..6c7189fd10e 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java +++ b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java @@ -21,7 +21,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static org.junit.jupiter.api.Assertions.*; public class TestTermParser extends AbstractTestTermParser { diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java index 53d2dfea857..aa300084d42 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java @@ -25,7 +25,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static org.junit.jupiter.api.Assertions.*; diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java index 27e57b4fa09..13ffbc93a56 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java @@ -15,7 +15,7 @@ import org.junit.jupiter.api.Test; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static org.junit.jupiter.api.Assertions.*; public class TestApplyUpdateOnRigidCondition { diff --git a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java index 8c095a11241..9301d7e09d6 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java +++ b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java @@ -33,7 +33,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; /** * This test case makes sure that all KeY formulas which are translated to axioms in SMT can diff --git a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java index aac7e1acdee..bfdd080623c 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java +++ b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java @@ -26,7 +26,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import static de.uka.ilkd.key.logic.equality.RenamingTermProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; import static java.lang.String.format; import static org.junit.jupiter.api.Assertions.*; From 21b41f3e2efcd9e405c95f1de1077ea7bc0329ee Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Sun, 21 Jan 2024 12:01:31 +0100 Subject: [PATCH 16/22] change TermProperty to take two terms instead of one term and one object --- .../java/de/uka/ilkd/key/logic/TermImpl.java | 5 +- .../IrrelevantTermLabelsProperty.java | 42 ++++++++--------- .../equality/ProofIrrelevancyProperty.java | 47 +++++++++---------- .../key/logic/equality/RenamingProperty.java | 22 ++++----- .../logic/equality/TermLabelsProperty.java | 32 ++++++------- .../ilkd/key/logic/equality/TermProperty.java | 12 ++--- 6 files changed, 77 insertions(+), 83 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java index 0fa52f024f2..8d4ac7486c1 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java @@ -340,7 +340,10 @@ protected int computeHashCode() { @Override public boolean equalsModProperty(Object o, TermProperty property) { - return property.equalsModThisProperty(this, o); + if (!(o instanceof Term other)) { + return false; + } + return property.equalsModThisProperty(this, other); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java index fa898737d39..0909c508423 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/IrrelevantTermLabelsProperty.java @@ -25,53 +25,51 @@ public class IrrelevantTermLabelsProperty implements TermProperty { * can be accessed * through {@link IrrelevantTermLabelsProperty#IRRELEVANT_TERM_LABELS_PROPERTY} and is used as a * parameter for - * {@link TermProperty#equalsModThisProperty(Term, Object)}. + * {@link TermProperty#equalsModThisProperty(Term, Term)}. */ private IrrelevantTermLabelsProperty() {} /** - * Checks if {@code o} is a term syntactically equal to {@code term}, except for some irrelevant + * Checks if {@code term2} is a term syntactically equal to {@code term1}, except for some + * irrelevant * labels. * - * @param term a term - * @param o the object compared to {@code term} - * @return {@code true} iff {@code o} is a term syntactically equal to {@code term}, except for + * @param term1 a term + * @param term2 the term compared to {@code term1} + * @return {@code true} iff {@code term2} is a term syntactically equal to {@code term1}, except + * for * their irrelevant labels. * @see TermLabel#isProofRelevant() isStrategyRelevant */ @Override - public Boolean equalsModThisProperty(Term term, Object o) { - if (o == term) { + public Boolean equalsModThisProperty(Term term1, Term term2) { + if (term2 == term1) { return true; } - if (!(o instanceof Term other)) { + if (!(term1.op().equals(term2.op()) && term1.boundVars().equals(term2.boundVars()) + && term1.javaBlock().equals(term2.javaBlock()))) { return false; } - if (!(term.op().equals(other.op()) && term.boundVars().equals(other.boundVars()) - && term.javaBlock().equals(other.javaBlock()))) { - return false; - } - - final ImmutableArray termLabels = term.getLabels(); - final ImmutableArray otherLabels = other.getLabels(); - for (TermLabel label : termLabels) { - if (label.isProofRelevant() && !otherLabels.contains(label)) { + final ImmutableArray term1Labels = term1.getLabels(); + final ImmutableArray term2Labels = term2.getLabels(); + for (TermLabel label : term1Labels) { + if (label.isProofRelevant() && !term2Labels.contains(label)) { return false; } } - for (TermLabel label : otherLabels) { - if (label.isProofRelevant() && !termLabels.contains(label)) { + for (TermLabel label : term2Labels) { + if (label.isProofRelevant() && !term1Labels.contains(label)) { return false; } } - final ImmutableArray termSubs = term.subs(); - final ImmutableArray otherSubs = other.subs(); + final ImmutableArray termSubs = term1.subs(); + final ImmutableArray term2Subs = term2.subs(); final int numOfSubs = termSubs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), + if (!termSubs.get(i).equalsModProperty(term2Subs.get(i), IRRELEVANT_TERM_LABELS_PROPERTY)) { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index 5833f9ffc55..b7677d1946c 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -30,66 +30,63 @@ public class ProofIrrelevancyProperty implements TermProperty { * can be accessed * through {@link ProofIrrelevancyProperty#PROOF_IRRELEVANCY_PROPERTY} and is used as a * parameter for - * {@link TermProperty#equalsModThisProperty(Term, Object)}. + * {@link TermProperty#equalsModThisProperty(Term, Term)}. */ private ProofIrrelevancyProperty() {} /** - * Checks if {@code o} is a term syntactically equal to {@code term}, except for attributes that + * Checks if {@code term2} is a term syntactically equal to {@code term1}, except for attributes + * that * are not relevant for the purpose of these terms in the proof. *

* Combines the prior implementations of {@link EqualsModProofIrrelevancy} in TermImpl and * LabeledTermImpl. *

* - * @param term a term - * @param o the object compared to {@code term} - * @return true iff {@code o} is a term syntactically equal to {@code term}, except for + * @param term1 a term + * @param term2 the term compared to {@code term1} + * @return true iff {@code term2} is a term syntactically equal to {@code term1}, except for * proof-irrelevant attributes. */ @Override - public Boolean equalsModThisProperty(Term term, Object o) { - if (o == term) { + public Boolean equalsModThisProperty(Term term1, Term term2) { + if (term2 == term1) { return true; } - if (!(o instanceof Term other)) { - return false; - } - - final boolean opResult = term.op().equalsModProofIrrelevancy(other.op()); + final boolean opResult = term1.op().equalsModProofIrrelevancy(term2.op()); if (!(opResult - && EqualsModProofIrrelevancyUtil.compareImmutableArrays(term.boundVars(), - other.boundVars()) - && term.javaBlock().equalsModProofIrrelevancy(other.javaBlock()))) { + && EqualsModProofIrrelevancyUtil.compareImmutableArrays(term1.boundVars(), + term2.boundVars()) + && term1.javaBlock().equalsModProofIrrelevancy(term2.javaBlock()))) { return false; } - final ImmutableArray termLabels = term.getLabels(); - final ImmutableArray otherLabels = other.getLabels(); + final ImmutableArray termLabels = term1.getLabels(); + final ImmutableArray term2Labels = term2.getLabels(); for (TermLabel label : termLabels) { - if (label.isProofRelevant() && !otherLabels.contains(label)) { + if (label.isProofRelevant() && !term2Labels.contains(label)) { return false; } } - for (TermLabel label : otherLabels) { + for (TermLabel label : term2Labels) { if (label.isProofRelevant() && !termLabels.contains(label)) { return false; } } - final ImmutableArray termSubs = term.subs(); - final ImmutableArray otherSubs = other.subs(); - final int numOfSubs = termSubs.size(); + final ImmutableArray term1Subs = term1.subs(); + final ImmutableArray term2Subs = term2.subs(); + final int numOfSubs = term1Subs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), PROOF_IRRELEVANCY_PROPERTY)) { + if (!term1Subs.get(i).equalsModProperty(term2Subs.get(i), PROOF_IRRELEVANCY_PROPERTY)) { return false; } } // This would be the only new thing from LabeledTermImpl, but this doesn't seem right - if (term.hasLabels() && other.hasLabels()) { - if (other.getLabels().size() != term.getLabels().size()) { + if (term1.hasLabels() && term2.hasLabels()) { + if (term2.getLabels().size() != term1.getLabels().size()) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java index 658e566b807..ff5a8538ad4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java @@ -30,27 +30,24 @@ public class RenamingProperty implements TermProperty { * This constructor is private as a single instance of this class should be shared. The instance * can be accessed * through {@link RenamingProperty#RENAMING_TERM_PROPERTY} and is used as a parameter for - * {@link TermProperty#equalsModThisProperty(Term, Object)}. + * {@link TermProperty#equalsModThisProperty(Term, Term)}. */ private RenamingProperty() {} /** - * Checks if {@code o} is a term syntactically equal to {@code term} modulo bound renaming. + * Checks if {@code term2} is a term syntactically equal to {@code term1} modulo bound renaming. * - * @param term a term - * @param o the object compared to {@code term} - * @return true iff {@code o} has the same values in operator, sort, arity, varsBoundHere - * and javaBlock as {@code term} modulo bound renaming + * @param term1 a term + * @param term2 the term compared to {@code term1} + * @return true iff {@code term2} has the same values in operator, sort, arity, varsBoundHere + * and javaBlock as {@code term1} modulo bound renaming */ @Override - public Boolean equalsModThisProperty(Term term, Object o) { - if (o == term) { + public Boolean equalsModThisProperty(Term term1, Term term2) { + if (term2 == term1) { return true; } - if (!(o instanceof Term t)) { - return false; - } - return unifyHelp(term, t, ImmutableSLList.nil(), + return unifyHelp(term1, term2, ImmutableSLList.nil(), ImmutableSLList.nil(), null); } @@ -181,6 +178,7 @@ private static NameAbstractionTable handleJava(Term t0, Term t1, NameAbstraction } /** + * TODO better doc * returns true if the given ProgramElement is equal to the one of the JavaBlock modulo renaming * (see comment in SourceElement) */ diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java index 6ca8c953a22..16e14dfc0f0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermLabelsProperty.java @@ -22,39 +22,37 @@ public class TermLabelsProperty implements TermProperty { * This constructor is private as a single instance of this class should be shared. The instance * can be accessed * through {@link TermLabelsProperty#TERM_LABELS_PROPERTY} and is used as a parameter for - * {@link TermProperty#equalsModThisProperty(Term, Object)}. + * {@link TermProperty#equalsModThisProperty(Term, Term)}. */ private TermLabelsProperty() {} /** - * Checks if {@code o} is a term syntactically equal to {@code term}, ignoring all term + * Checks if {@code term2} is a term syntactically equal to {@code term1}, ignoring all + * term * labels. * - * @param term a term - * @param o the object compared to {@code term} - * @return {@code true} iff {@code o} is a term syntactically equal to this ignoring all + * @param term1 a term + * @param term2 the term compared to {@code term1} + * @return {@code true} iff {@code term2} is a term syntactically equal to {@code term1} + * ignoring all * term labels */ @Override - public Boolean equalsModThisProperty(Term term, Object o) { - if (o == term) { + public Boolean equalsModThisProperty(Term term1, Term term2) { + if (term2 == term1) { return true; } - if (!(o instanceof Term other)) { + if (!(term1.op().equals(term2.op()) && term1.boundVars().equals(term2.boundVars()) + && term1.javaBlock().equals(term2.javaBlock()))) { return false; } - if (!(term.op().equals(other.op()) && term.boundVars().equals(other.boundVars()) - && term.javaBlock().equals(other.javaBlock()))) { - return false; - } - - final ImmutableArray termSubs = term.subs(); - final ImmutableArray otherSubs = other.subs(); - final int numOfSubs = termSubs.size(); + final ImmutableArray term1Subs = term1.subs(); + final ImmutableArray term2Subs = term2.subs(); + final int numOfSubs = term1Subs.size(); for (int i = 0; i < numOfSubs; ++i) { - if (!termSubs.get(i).equalsModProperty(otherSubs.get(i), TERM_LABELS_PROPERTY)) { + if (!term1Subs.get(i).equalsModProperty(term2Subs.get(i), TERM_LABELS_PROPERTY)) { return false; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java index ef4b7fb6909..2f6e41b3b6a 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/TermProperty.java @@ -17,17 +17,17 @@ */ public interface TermProperty { /** - * Checks {@code term} and {@code o} for equality ignoring a certain property. + * Checks {@code term1} and {@code term2} for equality ignoring a certain property. * - * @param term the term to check for equality with {@code o} - * @param o the object to check for equality with {@code term} - * @return whether {@code term} and {@code o} are equal ignoring a certain property + * @param term1 the first term to check for equality with {@code term2} + * @param term2 the second term to check for equality with {@code term1} + * @return whether {@code term1} and {@code term2} are equal ignoring a certain property */ - Boolean equalsModThisProperty(Term term, Object o); + Boolean equalsModThisProperty(Term term1, Term term2); /** * Computes the hash code of the {@code term} in a context where - * {@link this#equalsModThisProperty(Term, Object)} is used as an equality check, so that it can + * {@link this#equalsModThisProperty(Term, Term)} is used as an equality check, so that it can * be used in, e.g., a HashMap. * * @param term the term to compute the hash code for From 7c2e84408482ec8ebe56756a97b21f53a8646642 Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Wed, 31 Jan 2024 12:39:56 +0100 Subject: [PATCH 17/22] remove caching of old hashcode from hashCodeModProofIrrelevancy --- .../java/de/uka/ilkd/key/logic/TermImpl.java | 4 ---- .../equality/ProofIrrelevancyProperty.java | 22 +++++-------------- 2 files changed, 6 insertions(+), 20 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java index 8d4ac7486c1..c58e49ca677 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java @@ -69,10 +69,6 @@ private enum ThreeValuedTruth { * Cached {@link #hashCode()} value. */ private int hashcode = -1; - /** - * Cached hash value. - */ - private int hashcode2 = -1; /** * This flag indicates that the {@link Term} itself or one of its children contains a non-empty diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index b7677d1946c..de83b340571 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -106,28 +106,18 @@ public Boolean equalsModThisProperty(Term term1, Term term2) { */ @Override public int hashCodeModThisProperty(Term term) { - int hashcode2 = -1; // this line is just so the code compiles - // part from TermImpl - if (hashcode2 == -1) { - // compute into local variable first to be thread-safe. - hashcode2 = Objects.hash(term.op(), hashCodeIterable(term.subs()), - EqualsModProofIrrelevancyUtil.hashCodeIterable(term.boundVars()), term.javaBlock()); - if (hashcode2 == -1) { - hashcode2 = 0; - } - } + int hashcode = Objects.hash(term.op(), hashCodeIterable(term.subs()), + EqualsModProofIrrelevancyUtil.hashCodeIterable(term.boundVars()), term.javaBlock()); + // part from LabeledTermImpl final ImmutableArray labels = term.getLabels(); - final int numOfLabels = labels.size(); - for (int i = 0; i < numOfLabels; i++) { + for (int i = 0, sz = labels.size(); i < sz; i++) { final TermLabel currentLabel = labels.get(i); if (currentLabel.isProofRelevant()) { - hashcode2 += 7 * currentLabel.hashCode(); + hashcode += 7 * currentLabel.hashCode(); } } - return hashcode2; - // throw new UnsupportedOperationException( - // "Hashing of terms modulo term proof-irrelevancy not yet implemented!"); + return hashcode; } // -------------------------- Utility methods --------------------------------- // From b2209f62495dceabfcd27429d33f40698fe144c9 Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Wed, 31 Jan 2024 12:57:57 +0100 Subject: [PATCH 18/22] change behaviour of equalsModProperty in the case of ProofIrrelevancyProperty number of labels does not matter anymore --- .../ilkd/key/logic/equality/ProofIrrelevancyProperty.java | 7 ------- .../ilkd/key/logic/equality/TestEqualsModProperty.java | 8 ++++---- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java index de83b340571..72aa7b28310 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/ProofIrrelevancyProperty.java @@ -84,13 +84,6 @@ public Boolean equalsModThisProperty(Term term1, Term term2) { } } - // This would be the only new thing from LabeledTermImpl, but this doesn't seem right - if (term1.hasLabels() && term2.hasLabels()) { - if (term2.getLabels().size() != term1.getLabels().size()) { - return false; - } - } - return true; } diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java index 147235413c0..142db7570a9 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java @@ -269,10 +269,10 @@ public void proofIrrelevancy() { labels2 = new ImmutableArray<>(relevantLabel1, relevantLabel2); term1 = tb.label(term1, labels1); term2 = tb.label(term2, labels2); - assertFalse(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), - "Should be false as both terms have a different number of labels"); - assertFalse(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), - "Should be false as both terms have a different number of labels"); + assertTrue(term1.equalsModProperty(term2, PROOF_IRRELEVANCY_PROPERTY), + "Should be true as both terms have the same relevant term labels and irrelevant labels do not matter"); + assertTrue(term2.equalsModProperty(term1, PROOF_IRRELEVANCY_PROPERTY), + "Should be true as both terms have the same relevant term labels and irrelevant labels do not matter"); // ------------ not the same relevant labels labels1 = new ImmutableArray<>(relevantLabel1); From f5b5578686f9de44f34d26f776d093f878ba8e6e Mon Sep 17 00:00:00 2001 From: Tobias Date: Wed, 7 Feb 2024 11:09:59 +0100 Subject: [PATCH 19/22] fix bug in SVInstantiations where a wrong property was used for equality check --- .../main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java index 0d4081a0f9d..efc2ee31859 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/inst/SVInstantiations.java @@ -30,6 +30,7 @@ import org.key_project.util.collection.ImmutableSLList; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; +import static de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty.PROOF_IRRELEVANCY_PROPERTY; /** * This class wraps an {@link ImmutableMap} from {@link SchemaVariable} to @@ -578,7 +579,7 @@ public boolean equalsModProofIrrelevancy(Object obj) { assert inst != null : "Illegal null instantiation."; if (inst instanceof Term instAsTerm) { if (!instAsTerm.equalsModProperty( - cmp.getInstantiation(e.key()), IRRELEVANT_TERM_LABELS_PROPERTY)) { + cmp.getInstantiation(e.key()), PROOF_IRRELEVANCY_PROPERTY)) { return false; } } else if (!inst.equals(cmp.getInstantiation(e.key()))) { From 3aef4f7a96b605e04523457e1eef1de4b2e323d3 Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Wed, 7 Feb 2024 17:34:49 +0100 Subject: [PATCH 20/22] rename static field RENAMING_TERM_PROPERTY to RENAMING_PROPERTY to have the same name as its class --- .../util/SymbolicExecutionUtil.java | 4 ++-- .../StartAuxiliaryBlockComputationMacro.java | 4 ++-- .../StartAuxiliaryLoopComputationMacro.java | 4 ++-- .../StartAuxiliaryMethodComputationMacro.java | 4 ++-- .../ilkd/key/logic/BoundVariableTools.java | 6 +++--- .../uka/ilkd/key/logic/LabeledTermImpl.java | 2 +- .../de/uka/ilkd/key/logic/Semisequent.java | 4 ++-- .../key/logic/equality/RenamingProperty.java | 4 ++-- .../key/logic/label/TermLabelManager.java | 4 ++-- .../ilkd/key/macros/scripts/FocusCommand.java | 6 +++--- .../macros/scripts/InstantiateCommand.java | 8 ++++---- .../key/macros/scripts/RewriteCommand.java | 6 +++--- .../ilkd/key/macros/scripts/RuleCommand.java | 6 +++--- .../key/macros/scripts/SelectCommand.java | 4 ++-- .../ilkd/key/proof/join/JoinIsApplicable.java | 6 +++--- .../uka/ilkd/key/rule/OneStepSimplifier.java | 8 ++++---- .../ApplyUpdateOnRigidCondition.java | 4 ++-- .../key/rule/match/legacy/ElementMatcher.java | 4 ++-- .../key/rule/match/vm/VMTacletMatcher.java | 4 ++-- .../MatchSchemaVariableInstruction.java | 4 ++-- .../de/uka/ilkd/key/rule/merge/MergeRule.java | 4 ++-- .../ilkd/key/smt/AbstractSMTTranslator.java | 16 +++++++-------- .../ilkd/key/smt/newsmt2/SeqDefHandler.java | 4 ++-- .../ilkd/key/smt/newsmt2/SumProdHandler.java | 6 +++--- .../FunctionalOperationContractImpl.java | 6 +++--- .../jml/translation/JMLSpecFactory.java | 6 +++--- .../strategy/feature/ContainsTermFeature.java | 4 ++-- .../feature/DependencyContractFeature.java | 4 ++-- ...SubFormulaOfInfFlowContractAppFeature.java | 4 ++-- .../PredictCostProver.java | 6 +++--- .../strategy/termfeature/EqTermFeature.java | 4 ++-- .../key/util/mergerule/MergeRuleUtils.java | 6 +++--- .../java/de/uka/ilkd/key/logic/TestTerm.java | 12 +++++------ .../logic/equality/TestEqualsModProperty.java | 20 +++++++++---------- .../uka/ilkd/key/parser/TestTermParser.java | 4 ++-- .../de/uka/ilkd/key/rule/TestApplyTaclet.java | 4 ++-- .../TestApplyUpdateOnRigidCondition.java | 16 +++++++-------- .../key/smt/newsmt2/ProveSMTLemmasTest.java | 4 ++-- .../key/speclang/jml/TestJMLTranslator.java | 16 +++++++-------- 39 files changed, 121 insertions(+), 121 deletions(-) diff --git a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java index 40f2d639722..419710ee3ed 100644 --- a/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java +++ b/key.core.symbolic_execution/src/main/java/de/uka/ilkd/key/symbolic_execution/util/SymbolicExecutionUtil.java @@ -72,7 +72,7 @@ import org.slf4j.LoggerFactory; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * Provides utility methods for symbolic execution with KeY. @@ -2676,7 +2676,7 @@ private static boolean checkReplaceTerm(Term toCheck, PosInOccurrence posInOccur Term replaceTerm) { Term termAtPio = followPosInOccurrence(posInOccurrence, toCheck); if (termAtPio != null) { - return termAtPio.equalsModProperty(replaceTerm, RENAMING_TERM_PROPERTY); + return termAtPio.equalsModProperty(replaceTerm, RENAMING_PROPERTY); } else { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java index 7fd6ac4c639..a7b80f23363 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryBlockComputationMacro.java @@ -24,7 +24,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** @@ -80,7 +80,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_BLOCK_WITH_PRE_RELATION); - return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_TERM_PROPERTY); + return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java index f2e6191560b..cd9f38083b4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryLoopComputationMacro.java @@ -25,7 +25,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; public class StartAuxiliaryLoopComputationMacro extends AbstractProofMacro implements StartSideProofMacro { @@ -77,7 +77,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_LOOP_WITH_INV_RELATION); - return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_TERM_PROPERTY); + return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java index 65271a84df0..33dc44f19d0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java +++ b/key.core/src/main/java/de/uka/ilkd/key/informationflow/macros/StartAuxiliaryMethodComputationMacro.java @@ -22,7 +22,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * @@ -69,7 +69,7 @@ public boolean canApplyTo(Proof proof, ImmutableList goals, PosInOccurrenc final Term selfComposedExec = f.create(InfFlowPOSnippetFactory.Snippet.SELFCOMPOSED_EXECUTION_WITH_PRE_RELATION); - return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_TERM_PROPERTY); + return posInOcc.subTerm().equalsModProperty(selfComposedExec, RENAMING_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java index 06b13c448a8..d1e930e93a0 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/BoundVariableTools.java @@ -13,7 +13,7 @@ import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** @@ -208,7 +208,7 @@ public boolean equalsModRenaming(ImmutableArray vars0, Ter return false; } if (vars0.size() == 0) { - return term0.equalsModProperty(term1, RENAMING_TERM_PROPERTY); + return term0.equalsModProperty(term1, RENAMING_PROPERTY); } final ImmutableArray unifiedVars = unifyVariableArrays(vars0, vars1, @@ -217,7 +217,7 @@ public boolean equalsModRenaming(ImmutableArray vars0, Ter final Term renamedTerm0 = renameVariables(term0, vars0, unifiedVars, services); final Term renamedTerm1 = renameVariables(term1, vars1, unifiedVars, services); - return renamedTerm0.equalsModProperty(renamedTerm1, RENAMING_TERM_PROPERTY); + return renamedTerm0.equalsModProperty(renamedTerm1, RENAMING_PROPERTY); } /** diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java index 7db0022e77b..336050f1136 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java @@ -27,7 +27,7 @@ * the method {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)} can be used to * compare terms * while ignoring certain - * given properties. E.g. by using {@link RenamingProperty#RENAMING_TERM_PROPERTY}, just the + * given properties. E.g. by using {@link RenamingProperty#RENAMING_PROPERTY}, just the * term structures modulo * renaming are compared whilst ignoring annotations. *

diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java index 417c391cfd4..5462c0f7fe4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Semisequent.java @@ -8,7 +8,7 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** @@ -160,7 +160,7 @@ private SemisequentChangeInfo insertAndRemoveRedundancyHelper(int idx, if (sequentFormula != null && cf.formula().equalsModProperty(sequentFormula.formula(), - RENAMING_TERM_PROPERTY)) { + RENAMING_PROPERTY)) { semiCI.rejectedFormula(sequentFormula); return semiCI; // semisequent already contains formula diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java index ff5a8538ad4..59299b13bee 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java @@ -24,12 +24,12 @@ public class RenamingProperty implements TermProperty { /** * The single instance of this property. */ - public static final RenamingProperty RENAMING_TERM_PROPERTY = new RenamingProperty(); + public static final RenamingProperty RENAMING_PROPERTY = new RenamingProperty(); /** * This constructor is private as a single instance of this class should be shared. The instance * can be accessed - * through {@link RenamingProperty#RENAMING_TERM_PROPERTY} and is used as a parameter for + * through {@link RenamingProperty#RENAMING_PROPERTY} and is used as a parameter for * {@link TermProperty#equalsModThisProperty(Term, Term)}. */ private RenamingProperty() {} diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java index dc156a0de8d..edccbb39487 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/label/TermLabelManager.java @@ -29,7 +29,7 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.java.CollectionUtil; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** *

@@ -2013,7 +2013,7 @@ protected void mergeLabels(SequentChangeInfo currentSequent, Services services, Semisequent s = currentSequent.getSemisequentChangeInfo(inAntecedent).semisequent(); SequentFormula existingSF = CollectionUtil.search(s, element -> element.formula().equalsModProperty(rejectedTerm, - RENAMING_TERM_PROPERTY)); + RENAMING_PROPERTY)); if (existingSF != null) { // Create list of new labels Term existingTerm = existingSF.formula(); diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java index 1afa11def64..7f755d091c3 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/FocusCommand.java @@ -18,7 +18,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * The command "focus" allows you to select formulas from the current sequent @@ -78,7 +78,7 @@ private void hideAll(Sequent toKeep) throws ScriptException { for (SequentFormula seqFormula : ante) { // This means "!keepAnte.contains(seqFormula.formula)" but with equality mod renaming! if (!keepAnte.exists( - it -> it.equalsModProperty(seqFormula.formula(), RENAMING_TERM_PROPERTY))) { + it -> it.equalsModProperty(seqFormula.formula(), RENAMING_PROPERTY))) { Taclet tac = getHideTaclet("left"); makeTacletApp(goal, seqFormula, tac, true); } @@ -88,7 +88,7 @@ private void hideAll(Sequent toKeep) throws ScriptException { ImmutableList succ = goal.sequent().succedent().asList(); for (SequentFormula seqFormula : succ) { if (!keepSucc.exists( - it -> it.equalsModProperty(seqFormula.formula(), RENAMING_TERM_PROPERTY))) { + it -> it.equalsModProperty(seqFormula.formula(), RENAMING_PROPERTY))) { Taclet tac = getHideTaclet("right"); makeTacletApp(goal, seqFormula, tac, false); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java index 5660620c714..13510a73b74 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/InstantiateCommand.java @@ -24,7 +24,7 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * instantiate var=a occ=2 with="a_8" hide @@ -110,7 +110,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta ImmutableList allApps = ImmutableSLList.nil(); for (SequentFormula sf : g.node().sequent().antecedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -119,7 +119,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta for (SequentFormula sf : g.node().sequent().succedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -136,7 +136,7 @@ private TacletApp filterList(Parameters p, ImmutableList list) { for (TacletApp tacletApp : list) { if (tacletApp instanceof PosTacletApp pta) { if (pta.posInOccurrence().subTerm().equalsModProperty(p.formula, - RENAMING_TERM_PROPERTY)) { + RENAMING_PROPERTY)) { return pta; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java index 3f58900ec70..4c15504162b 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RewriteCommand.java @@ -22,7 +22,7 @@ import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * This class provides the command rewrite. @@ -114,7 +114,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta for (SequentFormula sf : g.node().sequent().antecedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, @@ -124,7 +124,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta // filter taclets that are applicable on the given formula in the succedent for (SequentFormula sf : g.node().sequent().succedent()) { if (p.formula != null - && !sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY)) { + && !sf.formula().equalsModProperty(p.formula, RENAMING_PROPERTY)) { continue; } allApps = allApps.append(index.getTacletAppAtAndBelow(filter, diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java index d7517a71dce..21c661ed331 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/RuleCommand.java @@ -23,7 +23,7 @@ import org.key_project.util.collection.ImmutableSLList; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * Command that applies a calculus rule All parameters are passed as strings and converted by the @@ -317,7 +317,7 @@ private ImmutableList findAllTacletApps(Parameters p, EngineState sta private boolean isFormulaSearchedFor(Parameters p, SequentFormula sf, Services services) throws ScriptException { final boolean satisfiesFormulaParameter = - p.formula != null && sf.formula().equalsModProperty(p.formula, RENAMING_TERM_PROPERTY); + p.formula != null && sf.formula().equalsModProperty(p.formula, RENAMING_PROPERTY); final boolean satisfiesMatchesParameter = p.matches != null && formatTermString(LogicPrinter.quickPrintTerm(sf.formula(), services)) @@ -348,7 +348,7 @@ private List filterList(Parameters p, ImmutableList list) if (tacletApp instanceof PosTacletApp pta) { boolean add = p.on == null || pta.posInOccurrence().subTerm() - .equalsModProperty(p.on, RENAMING_TERM_PROPERTY); + .equalsModProperty(p.on, RENAMING_PROPERTY); Iterator it = pta.instantiations().svIterator(); while (it.hasNext()) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java index d4a02ff67db..f43592bde92 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java +++ b/key.core/src/main/java/de/uka/ilkd/key/macros/scripts/SelectCommand.java @@ -20,7 +20,7 @@ import org.key_project.util.collection.ImmutableList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; public class SelectCommand extends AbstractCommand { public SelectCommand() { @@ -135,7 +135,7 @@ private boolean contains(Sequent seq, Term formula) { private boolean contains(Semisequent semiseq, Term formula) { for (SequentFormula sf : semiseq.asList()) { - if (sf.formula().equalsModProperty(formula, RENAMING_TERM_PROPERTY)) { + if (sf.formula().equalsModProperty(formula, RENAMING_PROPERTY)) { return true; } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java index 662e80a056d..2568f3fe8cd 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java +++ b/key.core/src/main/java/de/uka/ilkd/key/proof/join/JoinIsApplicable.java @@ -13,7 +13,7 @@ import de.uka.ilkd.key.logic.op.UpdateApplication; import de.uka.ilkd.key.proof.Goal; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * Methods for checking the applicability of a join for a given selection and thereby computing the @@ -91,13 +91,13 @@ private ProspectivePartner areProspectivePartners(Goal g1, PosInOccurrence pio, Term formula = sf.formula(); Term update2 = tb.skip(); if (formula.op() instanceof UpdateApplication - && !formula.equalsModProperty(referenceFormula, RENAMING_TERM_PROPERTY)) { + && !formula.equalsModProperty(referenceFormula, RENAMING_PROPERTY)) { update2 = formula.sub(0);// don't change the order of this and // the following line. formula = formula.sub(1); } - if (formula.equalsModProperty(referenceFormula, RENAMING_TERM_PROPERTY)) { + if (formula.equalsModProperty(referenceFormula, RENAMING_PROPERTY)) { return new ProspectivePartner(referenceFormula, g1.node(), pio.sequentFormula(), update1, g2.node(), sf, update2); } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java index da0fdfb0db1..6c89ec252aa 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/OneStepSimplifier.java @@ -46,7 +46,7 @@ import org.jspecify.annotations.NonNull; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; public final class OneStepSimplifier implements BuiltInRule { @@ -749,9 +749,9 @@ public boolean equals(Object obj) { obj = ((TermReplacementKey) obj).term; } if (obj instanceof Term t) { - return term.equalsModProperty(t, RENAMING_TERM_PROPERTY); // Ignore naming and term - // labels in the way a - // taclet rule does. + return term.equalsModProperty(t, RENAMING_PROPERTY); // Ignore naming and term + // labels in the way a + // taclet rule does. } else { return false; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java index 70d649e8b01..4c6605abb02 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/conditions/ApplyUpdateOnRigidCondition.java @@ -15,7 +15,7 @@ import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** @@ -214,7 +214,7 @@ public MatchConditions check(SchemaVariable var, SVSubstitute instCandidate, Mat if (resultInst == null) { svInst = svInst.add(result, properResultInst, services); return mc.setInstantiations(svInst); - } else if (resultInst.equalsModProperty(properResultInst, RENAMING_TERM_PROPERTY)) { + } else if (resultInst.equalsModProperty(properResultInst, RENAMING_PROPERTY)) { return mc; } else { return null; diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java index dadfda0ecb9..bd872e402c3 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/legacy/ElementMatcher.java @@ -17,7 +17,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; public abstract class ElementMatcher { @@ -125,7 +125,7 @@ protected final MatchConditions addInstantiation(AbstractSV op, Term term, final Term t = inst.getTermInstantiation(op, inst.getExecutionContext(), services); if (t != null) { - if (!t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { + if (!t.equalsModProperty(term, RENAMING_PROPERTY)) { LOGGER.debug( "FAILED. Adding instantiations leads to unsatisfiable constraint. {} {}", op, term); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java index 61fb06e18ce..94a585c6f86 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/VMTacletMatcher.java @@ -35,7 +35,7 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** *

@@ -167,7 +167,7 @@ private Term matchUpdateContext(ImmutableList context, Term for if (formula.op() instanceof UpdateApplication) { final Term update = UpdateApplication.getUpdate(formula); final UpdateLabelPair ulp = curContext.head(); - if (ulp.update().equalsModProperty(update, RENAMING_TERM_PROPERTY) + if (ulp.update().equalsModProperty(update, RENAMING_PROPERTY) && ulp.updateApplicationlabels().equals(update.getLabels())) { curContext = curContext.tail(); formula = UpdateApplication.getTarget(formula); diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java index 6345d318a62..c2e676e4726 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/match/vm/instructions/MatchSchemaVariableInstruction.java @@ -14,7 +14,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; public abstract class MatchSchemaVariableInstruction extends Instruction { @@ -42,7 +42,7 @@ protected final MatchConditions addInstantiation(Term term, MatchConditions matc final Term t = inst.getTermInstantiation(op, inst.getExecutionContext(), services); if (t != null) { - if (!t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { + if (!t.equalsModProperty(term, RENAMING_PROPERTY)) { return null; } else { return matchCond; diff --git a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java index 349a6719920..ebad530cba9 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java +++ b/key.core/src/main/java/de/uka/ilkd/key/rule/merge/MergeRule.java @@ -49,7 +49,7 @@ import org.jspecify.annotations.NonNull; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.clearSemisequent; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.closeMergePartnerGoal; import static de.uka.ilkd.key.util.mergerule.MergeRuleUtils.getConjunctiveElementsFor; @@ -357,7 +357,7 @@ protected Triple, LinkedHashSet qu Services services) throws IllegalFormulaException { // check, if the modality was already translated. for (Term toMatch : modalityPredicates.keySet()) { - if (toMatch.equalsModProperty(t, RENAMING_TERM_PROPERTY)) { + if (toMatch.equalsModProperty(t, RENAMING_PROPERTY)) { return modalityPredicates.get(toMatch); } } @@ -2252,7 +2252,7 @@ protected final StringBuilder translateBsumFunction(Term bsumterm, ArrayList sub) { StringBuilder name = null; for (Term t : usedBsumTerms.keySet()) { - if (t.equalsModProperty(bsumterm, RENAMING_TERM_PROPERTY)) { + if (t.equalsModProperty(bsumterm, RENAMING_PROPERTY)) { name = usedBsumTerms.get(t); } } @@ -2290,7 +2290,7 @@ protected final StringBuilder translateBprodFunction(Term bprodterm, ArrayList sub) { StringBuilder name = null; for (Term t : usedBprodTerms.keySet()) { - if (t.equalsModProperty(bprodterm, RENAMING_TERM_PROPERTY)) { + if (t.equalsModProperty(bprodterm, RENAMING_PROPERTY)) { name = usedBprodTerms.get(t); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java index e360c274ca1..0fe7221919d 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SeqDefHandler.java @@ -29,7 +29,7 @@ import org.key_project.util.collection.DefaultImmutableSet; import org.key_project.util.collection.ImmutableSet; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * This handler handles the seqDef binder function specially. @@ -80,7 +80,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti (Map) state.computeIfAbsent("SEQDEF_MAP", x -> new LinkedHashMap<>()); for (Entry entry : seqDefMap.entrySet()) { - if (entry.getKey().equalsModProperty(term, RENAMING_TERM_PROPERTY)) { + if (entry.getKey().equalsModProperty(term, RENAMING_PROPERTY)) { return entry.getValue(); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java index 2b176f56a6b..394776c0843 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java +++ b/key.core/src/main/java/de/uka/ilkd/key/smt/newsmt2/SumProdHandler.java @@ -11,7 +11,7 @@ import de.uka.ilkd.key.logic.op.Operator; import de.uka.ilkd.key.smt.SMTTranslationException; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; // W I P public class SumProdHandler implements SMTHandler { @@ -43,7 +43,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti Operator op = term.op(); if (op == bsumOp) { for (Term t : usedBsumTerms.keySet()) { - if (t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { + if (t.equalsModProperty(term, RENAMING_PROPERTY)) { return usedBsumTerms.get(t); } } @@ -57,7 +57,7 @@ public SExpr handle(MasterHandler trans, Term term) throws SMTTranslationExcepti return ret; } else if (op == bprodOp) { for (Term t : usedBprodTerms.keySet()) { - if (t.equalsModProperty(term, RENAMING_TERM_PROPERTY)) { + if (t.equalsModProperty(term, RENAMING_PROPERTY)) { return usedBprodTerms.get(t); } } diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java index f7cd55c8bfc..5df4d660f08 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/FunctionalOperationContractImpl.java @@ -33,7 +33,7 @@ import org.key_project.util.collection.ImmutableSLList; import org.key_project.util.java.MapUtil; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static de.uka.ilkd.key.util.Assert.assertEqualSort; import static de.uka.ilkd.key.util.Assert.assertSubSort; @@ -1367,13 +1367,13 @@ public String toString() { return (globalDefs == null ? "" : "defs: " + globalDefs + "; ") + "pre: " + originalPres + (originalFreePres.get(heap) != null && !originalFreePres.get(heap).equalsModProperty(tb.tt(), - RENAMING_TERM_PROPERTY) + RENAMING_PROPERTY) ? "free pre: " + originalFreePres : "") + "; mby: " + originalMby + "; post: " + originalPosts + (originalFreePosts.get(heap) != null && !originalFreePosts.get(heap).equalsModProperty(tb.tt(), - RENAMING_TERM_PROPERTY) + RENAMING_PROPERTY) ? "free post: " + originalFreePosts : "") + "; mods: " + originalMods + "; hasMod: " + hasRealModifiesClause diff --git a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java index cf59890b49d..51a044f61ff 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java +++ b/key.core/src/main/java/de/uka/ilkd/key/speclang/jml/translation/JMLSpecFactory.java @@ -52,7 +52,7 @@ import org.jspecify.annotations.Nullable; import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.DIVERGES; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.Clause.SIGNALS; import static de.uka.ilkd.key.speclang.jml.pretranslation.TextualJMLSpecCase.ClauseHd.ENSURES; @@ -973,13 +973,13 @@ private ImmutableSet createDependencyOperationContract(IProgramMethod boolean createContract = true; for (LocationVariable heap : HeapContext.getModHeaps(services, false)) { if (clauses.accessibles.get(heap).equalsModProperty(tb.allLocs(), - RENAMING_TERM_PROPERTY)) { + RENAMING_PROPERTY)) { createContract = false; break; } if (pm.isModel() && pm.getStateCount() > 1) { if (clauses.accessibles.get(progVars.atPreVars.get(heap)) - .equalsModProperty(tb.allLocs(), RENAMING_TERM_PROPERTY)) { + .equalsModProperty(tb.allLocs(), RENAMING_PROPERTY)) { createContract = false; break; } diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java index 1ab3a2093ee..7f52a21e530 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/ContainsTermFeature.java @@ -13,7 +13,7 @@ import de.uka.ilkd.key.strategy.TopRuleAppCost; import de.uka.ilkd.key.strategy.termProjection.ProjectionToTerm; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** @@ -83,7 +83,7 @@ public boolean visitSubtree(Term visited) { @Override public void visit(Term visited) { - found = found || visited.equalsModProperty(term, RENAMING_TERM_PROPERTY); + found = found || visited.equalsModProperty(term, RENAMING_PROPERTY); } @Override diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java index 37311a23005..6cdad113fba 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/feature/DependencyContractFeature.java @@ -17,7 +17,7 @@ import org.key_project.util.collection.ImmutableSLList; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; public final class DependencyContractFeature extends BinaryFeature { @@ -25,7 +25,7 @@ private void removePreviouslyUsedSteps(Term focus, Goal goal, Listtrue & \\<{ int i; }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ int i; }\\>true "); assertTrue( - match1.sub(0).equalsModProperty(match2, RenamingProperty.RENAMING_TERM_PROPERTY), + match1.sub(0).equalsModProperty(match2, RenamingProperty.RENAMING_PROPERTY), "Terms should be equalModRenaming (0)."); assertTrue( - match1.sub(0).equalsModProperty(match1.sub(1), RenamingProperty.RENAMING_TERM_PROPERTY), + match1.sub(0).equalsModProperty(match1.sub(1), RenamingProperty.RENAMING_PROPERTY), "Terms should be equalModRenaming (1)."); Term match3 = TacletForTests.parseTerm("\\<{ int j = 0; }\\>true "); assertNotEquals(match1, match3, "Terms should not be equal."); @@ -124,15 +124,15 @@ public void testProgramElementEqualsModRenaming() { public void testEqualsModRenamingWithLabels() { Term match1 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); Term match2 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ } } }\\>true"); - assertTrue(match1.equalsModProperty(match2, RenamingProperty.RENAMING_TERM_PROPERTY), + assertTrue(match1.equalsModProperty(match2, RenamingProperty.RENAMING_PROPERTY), "Terms should be equalModRenaming."); Term match3 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match4 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int j = 0; } } }\\>true"); - assertTrue(match3.equalsModProperty(match4, RenamingProperty.RENAMING_TERM_PROPERTY), + assertTrue(match3.equalsModProperty(match4, RenamingProperty.RENAMING_PROPERTY), "Terms should be equalModRenaming."); Term match5 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); Term match6 = TacletForTests.parseTerm("\\<{ label0:{ label1:{ int i = 0; } } }\\>true"); - assertTrue(match5.equalsModProperty(match6, RenamingProperty.RENAMING_TERM_PROPERTY), + assertTrue(match5.equalsModProperty(match6, RenamingProperty.RENAMING_PROPERTY), "Terms should be equalModRenaming."); } @@ -145,7 +145,7 @@ public void testEqualsModRenaming() { final Term pz = tf.createTerm(p, new Term[] { tf.createTerm(z) }, null, null); final Term quant2 = tb.all(z, tb.all(z, tb.all(z, pz))); - assertTrue(quant1.equalsModProperty(quant2, RenamingProperty.RENAMING_TERM_PROPERTY), + assertTrue(quant1.equalsModProperty(quant2, RenamingProperty.RENAMING_PROPERTY), "Terms " + quant1 + " and " + quant2 + " should be equal mod renaming"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java index 142db7570a9..c50e185ed12 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java +++ b/key.core/src/test/java/de/uka/ilkd/key/logic/equality/TestEqualsModProperty.java @@ -19,7 +19,7 @@ import static de.uka.ilkd.key.logic.equality.IrrelevantTermLabelsProperty.IRRELEVANT_TERM_LABELS_PROPERTY; import static de.uka.ilkd.key.logic.equality.ProofIrrelevancyProperty.PROOF_IRRELEVANCY_PROPERTY; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static de.uka.ilkd.key.logic.equality.TermLabelsProperty.TERM_LABELS_PROPERTY; import static org.junit.jupiter.api.Assertions.*; @@ -63,14 +63,14 @@ public void renaming() { tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); Term term2 = tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.TRUE)); - assertFalse(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), + assertFalse(term1.equalsModProperty(term2, RENAMING_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); - assertFalse(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), + assertFalse(term2.equalsModProperty(term1, RENAMING_PROPERTY), "Terms are different to begin with, so they shouldn't be equal"); // other tests for equality already in TestTerm.java // ------------ comparison with something that is not a term - assertFalse(term1.equalsModProperty(1, RENAMING_TERM_PROPERTY), + assertFalse(term1.equalsModProperty(1, RENAMING_PROPERTY), "Should be false as other object is not a term"); // ------------ differing labels @@ -80,23 +80,23 @@ public void renaming() { tf.createTerm(Junctor.AND, tf.createTerm(Junctor.TRUE), tf.createTerm(Junctor.FALSE)); ImmutableArray labels1 = new ImmutableArray<>(irrelevantLabel); term1 = tb.label(term1, labels1); - assertTrue(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), + assertTrue(term1.equalsModProperty(term2, RENAMING_PROPERTY), "Should be true as labels do not matter"); - assertTrue(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), + assertTrue(term2.equalsModProperty(term1, RENAMING_PROPERTY), "Should be true as labels do not matter"); labels1 = new ImmutableArray<>(relevantLabel1); term1 = tb.label(term1, labels1); - assertTrue(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), + assertTrue(term1.equalsModProperty(term2, RENAMING_PROPERTY), "Should be true as labels do not matter"); - assertTrue(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), + assertTrue(term2.equalsModProperty(term1, RENAMING_PROPERTY), "Should be true as labels do not matter"); ImmutableArray labels2 = new ImmutableArray<>(relevantLabel2); term2 = tb.label(term2, labels2); - assertTrue(term1.equalsModProperty(term2, RENAMING_TERM_PROPERTY), + assertTrue(term1.equalsModProperty(term2, RENAMING_PROPERTY), "Should be true as labels do not matter"); - assertTrue(term2.equalsModProperty(term1, RENAMING_TERM_PROPERTY), + assertTrue(term2.equalsModProperty(term1, RENAMING_PROPERTY), "Should be true as labels do not matter"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java index 6c7189fd10e..78d5acfe534 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java +++ b/key.core/src/test/java/de/uka/ilkd/key/parser/TestTermParser.java @@ -21,7 +21,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static org.junit.jupiter.api.Assertions.*; public class TestTermParser extends AbstractTestTermParser { @@ -256,7 +256,7 @@ public void test13() throws Exception { Term t4 = parseTerm("\\exists int_sort ci; (\\<{ int p_y = 1;" + " {int s = 2;} }\\>" + " true ->" + "\\<{ int p_y = 1;boolean p_x = 2<1;" + "while(p_x){ int s=3 ;} }\\>" + " true)"); - assertTrue(t3.equalsModProperty(t4, RENAMING_TERM_PROPERTY), + assertTrue(t3.equalsModProperty(t4, RENAMING_PROPERTY), "Terms should be equalModRenaming"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java index aa300084d42..33d6c652ec1 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/TestApplyTaclet.java @@ -25,7 +25,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static org.junit.jupiter.api.Assertions.*; @@ -739,7 +739,7 @@ private void doTestCatchList(int p_proof) { Term resultFormula = goals.head().sequent().getFormulabyNr(1).formula(); Term correctFormula = correctSeq.getFormulabyNr(1).formula(); - assertTrue(resultFormula.equalsModProperty(correctFormula, RENAMING_TERM_PROPERTY), + assertTrue(resultFormula.equalsModProperty(correctFormula, RENAMING_PROPERTY), "Wrong result. Expected:" + ProofSaver.printAnything(correctFormula, TacletForTests.services()) + " But was:" + ProofSaver.printAnything(resultFormula, TacletForTests.services())); diff --git a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java index 13ffbc93a56..94cbd443874 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java +++ b/key.core/src/test/java/de/uka/ilkd/key/rule/conditions/TestApplyUpdateOnRigidCondition.java @@ -15,7 +15,7 @@ import org.junit.jupiter.api.Test; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static org.junit.jupiter.api.Assertions.*; public class TestApplyUpdateOnRigidCondition { @@ -24,7 +24,7 @@ void updateWithoutVariables() { Term term = TacletForTests.parseTerm("{i:=0}\\forall int a; a = i"); Term result = applyUpdateOnFormula(term); Term expected = TacletForTests.parseTerm("\\forall int a; {i:=0}(a = i)"); - assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), + assertTrue(expected.equalsModProperty(result, RENAMING_PROPERTY), "Update without free variables was not properly applied on formula!"); term = TacletForTests.parseTerm("{i:=0}(i = 0)"); @@ -36,7 +36,7 @@ void updateWithoutVariables() { term = TacletForTests.parseTerm("{i:=0} f(const)"); result = applyUpdateOnTerm(term); expected = TacletForTests.parseTerm("f({i:=0} const)"); - assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), + assertTrue(expected.equalsModProperty(result, RENAMING_PROPERTY), "Update without free variables was not properly applied on term!"); } @@ -50,21 +50,21 @@ void updateWithVariablesNoClash() { Term result = tb.all(b, applyUpdateOnFormula(term.sub(0))); Term expected = TacletForTests.parseTerm("\\forall int b; \\forall java.lang.Object a; {i:=b} (a = i)"); - assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), + assertTrue(expected.equalsModProperty(result, RENAMING_PROPERTY), "Update is not simply pulled over quantification!"); term = TacletForTests.parseTerm("\\forall int b; {i:=b} (0 = i)"); b = term.boundVars().get(0); result = tb.all(b, applyUpdateOnFormula(term.sub(0))); expected = TacletForTests.parseTerm("\\forall int b; {i:=b} 0 = {i:=b} i"); - assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), + assertTrue(expected.equalsModProperty(result, RENAMING_PROPERTY), "Update is not simply pulled over equality!"); term = TacletForTests.parseTerm("\\forall int b; {i:=b} f(const) = 0"); b = term.boundVars().get(0); result = tb.all(b, tb.equals(applyUpdateOnTerm(term.sub(0).sub(0)), term.sub(0).sub(1))); expected = TacletForTests.parseTerm("\\forall int b; f({i:=b} const) = 0"); - assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), + assertTrue(expected.equalsModProperty(result, RENAMING_PROPERTY), "Update is not simply pulled over function symbol!"); } @@ -78,7 +78,7 @@ void updateWithVariablesAndClash() { Term result = tb.all(a, applyUpdateOnFormula(term.sub(0))); Term expected = TacletForTests .parseTerm("\\forall int a; \\forall java.lang.Object a1; {i:=a} (a1 = i)"); - assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), + assertTrue(expected.equalsModProperty(result, RENAMING_PROPERTY), "Renaming or applying update afterwards !"); term = TacletForTests.parseTerm( @@ -88,7 +88,7 @@ void updateWithVariablesAndClash() { result = tb.all(a, tb.all(a1, applyUpdateOnFormula(term.sub(0).sub(0)))); expected = TacletForTests.parseTerm( "\\forall int a1; \\forall int a; \\forall java.lang.Object a2; {i:=a} (i = a1)"); - assertTrue(expected.equalsModProperty(result, RENAMING_TERM_PROPERTY), + assertTrue(expected.equalsModProperty(result, RENAMING_PROPERTY), "Counter appended to stem was not increased high enough!"); } diff --git a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java index 9301d7e09d6..b05f4767d35 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java +++ b/key.core/src/test/java/de/uka/ilkd/key/smt/newsmt2/ProveSMTLemmasTest.java @@ -33,7 +33,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; /** * This test case makes sure that all KeY formulas which are translated to axioms in SMT can @@ -92,7 +92,7 @@ public void testSMTLemmaSoundness(String name, String lemmaString) throws Except KeyIO io = new KeyIO(loadedProof.getServices()); Term parsedLemma = io.parseExpression(lemmaString); Term actual = loadedProof.root().sequent().succedent().get(0).formula(); - if (!actual.equalsModProperty(parsedLemma, RENAMING_TERM_PROPERTY)) { + if (!actual.equalsModProperty(parsedLemma, RENAMING_PROPERTY)) { LOGGER.info("Stored : {}", parsedLemma); LOGGER.warn("Proven : {}", actual); Assertions.fail("The proven lemma is different from the stored one."); diff --git a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java index bfdd080623c..13ff0eaa924 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java +++ b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java @@ -26,7 +26,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_TERM_PROPERTY; +import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; import static java.lang.String.format; import static org.junit.jupiter.api.Assertions.*; @@ -180,7 +180,7 @@ public void testForAll() { services.getNamespaces().sorts().lookup(new Name("int"))); Term expected = TB.all(i, TB.imp(TB.inInt(TB.var(i)), TB.and(TB.leq(TB.zTerm("0"), TB.var(i)), TB.leq(TB.var(i), TB.zTerm("2147483647"))))); - assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), + assertTrue(result.equalsModProperty(expected, RENAMING_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -196,7 +196,7 @@ public void testForEx() { services.getNamespaces().sorts().lookup(new Name("int"))); Term expected = TB.ex(i, TB.and(TB.inInt(TB.var(i)), TB.and(TB.leq(TB.zTerm("0"), TB.var(i)), TB.leq(TB.var(i), TB.zTerm("2147483647"))))); - assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), + assertTrue(result.equalsModProperty(expected, RENAMING_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -212,7 +212,7 @@ public void testBsumInt() { TB.bsum(i, TB.zTerm("0"), TB.zTerm("2147483647"), TB.var(i))); assertNotNull(result); Assertions.assertSame(q, result.sub(0).op()); - assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), + assertTrue(result.equalsModProperty(expected, RENAMING_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -226,7 +226,7 @@ public void testBsumBigInt() { Term expected = TB.bsum(i, TB.zTerm("0"), TB.zTerm("2147483647"), TB.var(i)); assertNotNull(result); Assertions.assertSame(q, result.op()); - assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), + assertTrue(result.equalsModProperty(expected, RENAMING_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -243,7 +243,7 @@ public void testInfiniteUnion() { TB.not(TB.equals(TB.var(o), TB.NULL()))); Term expected = TB.infiniteUnion(new QuantifiableVariable[] { o }, TB.ife(guard, TB.empty(), TB.empty())); - assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), + assertTrue(result.equalsModProperty(expected, RENAMING_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -261,7 +261,7 @@ public void testInfiniteUnion2() { TB.or(TB.convertToFormula(TB.created(TB.var(o))), TB.equals(TB.var(o), TB.NULL())); Term expected = TB.infiniteUnion(new QuantifiableVariable[] { o }, TB.ife(guard, TB.empty(), TB.empty())); - assertTrue(result.equalsModProperty(expected, RENAMING_TERM_PROPERTY), + assertTrue(result.equalsModProperty(expected, RENAMING_PROPERTY), "Result was: " + result + "; \nExpected was: " + expected); } @@ -440,7 +440,7 @@ public void testCorrectImplicitThisResolution() { TB.not(TB.equals(TB.var(qv), TB.NULL()))), // implicit non null TB.equals(TB.var(qv), TB.var(selfVar)))); - final boolean condition = result.equalsModProperty(expected, RENAMING_TERM_PROPERTY); + final boolean condition = result.equalsModProperty(expected, RENAMING_PROPERTY); assertTrue(condition, format("Expected:%s\n Was:%s", ProofSaver.printTerm(expected, services), ProofSaver.printTerm(result, services))); } From be7a1f06f988b36e25708c642bbf9ef495a130c3 Mon Sep 17 00:00:00 2001 From: Tobias Date: Wed, 6 Mar 2024 21:42:18 +0100 Subject: [PATCH 21/22] fix rest of merge conflicts --- .../uka/ilkd/key/logic/LabeledTermImpl.java | 8 +-- .../main/java/de/uka/ilkd/key/logic/Term.java | 1 - .../java/de/uka/ilkd/key/logic/TermImpl.java | 2 - .../key/logic/equality/RenamingProperty.java | 69 +++++++++++-------- .../key/strategy/FindTacletAppContainer.java | 3 +- .../key/speclang/jml/TestJMLTranslator.java | 3 +- 6 files changed, 46 insertions(+), 40 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java index 1757a620987..b17717cb9dd 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/LabeledTermImpl.java @@ -26,11 +26,9 @@ * * Two labeled terms are equal if they have equal term structure and equal annotations. In contrast, * the method {@link TermEqualsModProperty#equalsModProperty(Object, TermProperty)} can be used to - * compare terms - * while ignoring certain - * given properties. E.g. by using {@link RenamingProperty#RENAMING_PROPERTY}, just the - * term structures modulo - * renaming are compared whilst ignoring annotations. + * compare terms while ignoring certain given properties. E.g. by using + * {@link RenamingProperty#RENAMING_PROPERTY}, just the term structures modulo renaming are compared + * whilst ignoring annotations. *

* Prior implementations of {@link EqualsModProofIrrelevancy} are now in * {@link ProofIrrelevancyProperty}. diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java index 302195a6308..bb86484ed91 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java @@ -12,7 +12,6 @@ import org.key_project.logic.Name; import org.key_project.logic.Visitor; -import org.key_project.util.EqualsModProofIrrelevancy; import org.key_project.util.collection.ImmutableArray; import org.key_project.util.collection.ImmutableSet; diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java index 978d46bd3ea..3a49c3002b9 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/TermImpl.java @@ -13,8 +13,6 @@ import org.key_project.logic.Name; import org.key_project.logic.Visitor; import org.key_project.logic.sort.Sort; -import org.key_project.util.EqualsModProofIrrelevancy; -import org.key_project.util.EqualsModProofIrrelevancyUtil; import org.key_project.util.Strings; import org.key_project.util.collection.DefaultImmutableSet; import org.key_project.util.collection.ImmutableArray; diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java index 59299b13bee..4e2c9488dc4 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/equality/RenamingProperty.java @@ -7,10 +7,7 @@ import de.uka.ilkd.key.java.NameAbstractionTable; import de.uka.ilkd.key.logic.JavaBlock; import de.uka.ilkd.key.logic.Term; -import de.uka.ilkd.key.logic.op.Operator; -import de.uka.ilkd.key.logic.op.ProgramVariable; -import de.uka.ilkd.key.logic.op.QuantifiableVariable; -import de.uka.ilkd.key.logic.op.SchemaVariable; +import de.uka.ilkd.key.logic.op.*; import org.key_project.util.collection.ImmutableList; import org.key_project.util.collection.ImmutableSLList; @@ -117,6 +114,10 @@ private boolean unifyHelp(Term t0, Term t1, ImmutableList return true; } + if (t0.sort() != t1.sort() || t0.arity() != t1.arity()) { + return false; + } + final Operator op0 = t0.op(); if (op0 instanceof QuantifiableVariable) { @@ -125,17 +126,27 @@ private boolean unifyHelp(Term t0, Term t1, ImmutableList final Operator op1 = t1.op(); - if (!(op0 instanceof ProgramVariable) && op0 != op1) { - return false; - } - - if (t0.sort() != t1.sort() || t0.arity() != t1.arity()) { + if (op0 instanceof Modality mod0 && op1 instanceof Modality mod1) { + if (mod0.kind() != mod1.kind()) { + return false; + } + nat = handleJava(mod0.program(), mod1.program(), nat); + if (nat == FAILED) { + return false; + } + } else if (!(op0 instanceof ProgramVariable) && op0 != op1) { return false; } - nat = handleJava(t0, t1, nat); - if (nat == FAILED) { - return false; + if (!(op0 instanceof SchemaVariable) && op0 instanceof ProgramVariable pv0) { + if (op1 instanceof ProgramVariable pv1) { + nat = checkNat(nat); + if (!pv0.equalsModRenaming(pv1, nat)) { + return false; + } + } else { + return false; + } } return descendRecursively(t0, t1, ownBoundVars, cmpBoundVars, nat); @@ -155,32 +166,30 @@ && compareBoundVariables((QuantifiableVariable) t0.op(), */ private static final NameAbstractionTable FAILED = new NameAbstractionTable(); - private static NameAbstractionTable handleJava(Term t0, Term t1, NameAbstractionTable nat) { - - if (!t0.javaBlock().isEmpty() || !t1.javaBlock().isEmpty()) { - nat = checkNat(nat); - if (javaBlocksNotEqualModRenaming(t0.javaBlock(), t1.javaBlock(), nat)) { - return FAILED; - } - } - - if (!(t0.op() instanceof SchemaVariable) && t0.op() instanceof ProgramVariable) { - if (!(t1.op() instanceof ProgramVariable)) { - return FAILED; - } + private static NameAbstractionTable handleJava(JavaBlock jb0, JavaBlock jb1, + NameAbstractionTable nat) { + if (!jb0.isEmpty() || !jb1.isEmpty()) { nat = checkNat(nat); - if (!((ProgramVariable) t0.op()).equalsModRenaming((ProgramVariable) t1.op(), nat)) { + if (javaBlocksNotEqualModRenaming(jb0, jb1, nat)) { return FAILED; } } - return nat; } /** - * TODO better doc - * returns true if the given ProgramElement is equal to the one of the JavaBlock modulo renaming - * (see comment in SourceElement) + * Returns true if the given {@link JavaBlock}s are not equal modulo renaming. + *

+ * Moved here from {@link JavaBlock} while refactoring equalsModRenaming in {@link Term}. + * As the implementation of equalsModRenaming in {@link JavaBlock} was only used in + * {@link RenamingProperty#handleJava(JavaBlock, JavaBlock, NameAbstractionTable)} + * and the deprecated class de.uka.ilkd.key.strategy.quantifierHeuristics.EqualityConstraint, + * it is now only a helper method in {@link RenamingProperty}. + * + * @param jb1 the first {@link JavaBlock} + * @param jb2 the second {@link JavaBlock} + * @param nat the {@link NameAbstractionTable} used for the comparison + * @return true if the given {@link JavaBlock}s are NOT equal modulo renaming */ public static boolean javaBlocksNotEqualModRenaming(JavaBlock jb1, JavaBlock jb2, NameAbstractionTable nat) { diff --git a/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java b/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java index 5e6ee18b68d..10313f11e9e 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java +++ b/key.core/src/main/java/de/uka/ilkd/key/strategy/FindTacletAppContainer.java @@ -134,7 +134,8 @@ private boolean independentSubformulas(PosInOccurrence changePos, SequentFormula if (afterChangeTerm.op() instanceof Modality afterChangeMod) { return beforeChangeMod.kind() == afterChangeMod.kind() && beforeChangeTerm.sub(0) - .equalsModProperty(afterChangeTerm.sub(0), IRRELEVANT_TERM_LABELS_PROPERTY); + .equalsModProperty(afterChangeTerm.sub(0), + IRRELEVANT_TERM_LABELS_PROPERTY); } else { return false; } diff --git a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java index 137a2104f88..85427572149 100644 --- a/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java +++ b/key.core/src/test/java/de/uka/ilkd/key/speclang/jml/TestJMLTranslator.java @@ -32,6 +32,7 @@ import org.junit.jupiter.params.provider.CsvSource; import static de.uka.ilkd.key.logic.equality.RenamingProperty.RENAMING_PROPERTY; +import static de.uka.ilkd.key.logic.equality.TermLabelsProperty.TERM_LABELS_PROPERTY; import static java.lang.String.format; import static org.junit.jupiter.api.Assertions.*; @@ -478,7 +479,7 @@ public void testOperatorOverloading(String expression, String expected) { fail("Cannot parse " + expected, e); } - if (!tTrans.equalsModTermLabels(tExp)) { + if (!tTrans.equalsModProperty(tExp, TERM_LABELS_PROPERTY)) { // this gives nicer error assertEquals(tExp, tTrans); } From 6a22d9adc6f1232d0424eab81107f8c3b0dffadf Mon Sep 17 00:00:00 2001 From: Tobias Reinhold Date: Thu, 7 Mar 2024 14:53:32 +0100 Subject: [PATCH 22/22] add the override that got lost in the merge --- key.core/src/main/java/de/uka/ilkd/key/logic/Term.java | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java index bb86484ed91..60c03e6fdae 100644 --- a/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java +++ b/key.core/src/main/java/de/uka/ilkd/key/logic/Term.java @@ -44,10 +44,7 @@ */ public interface Term extends SVSubstitute, Sorted, TermEqualsModProperty, org.key_project.logic.Term { - - /** - * The top operator (e.g., in "A and B" this is "and", in f(x,y) it is "f"). - */ + @Override Operator op(); /**