Refactor: renamed RxTerm.isEffectivelyEmpty to isUnsatisfiable

Author: lmasroca

core/src/main/kotlin/org/evomaster/core/parser/GeneRegexJavaVisitor.kt

@@ -88,15 +88,15 @@ class GeneRegexJavaVisitor : RegexJavaBaseVisitor<VisitResult>(){
         val res = ctx.accept(this)
         val validDisjunctions = res.genes.map { it as DisjunctionRxGene }
 
-        val nonEmptyDisj = validDisjunctions.filter{ !it.isEffectivelyEmpty() }
+        val satisfiableDisjunctions = validDisjunctions.filter{ !it.isUnsatisfiable() }
 
-        if(nonEmptyDisj.isEmpty()){
+        if(satisfiableDisjunctions.isEmpty()){
             // As DisjunctionListRxGene extends CompositeFixedGene, its disjunctions list cannot be empty.
             // In this case we return null to represent an unsatisfiable DisjunctionListRxGene.
             return null
         }
 
-        val disjList = DisjunctionListRxGene(nonEmptyDisj)
+        val disjList = DisjunctionListRxGene(satisfiableDisjunctions)
 
         //TODO tmp hack until full handling of ^$. Assume full match when nested disjunctions
         for (gene in disjList.disjunctions) {
@@ -114,15 +114,15 @@ class GeneRegexJavaVisitor : RegexJavaBaseVisitor<VisitResult>(){
 
         val text = RegexUtils.getRegexExpByParserRuleContext(ctx)
 
-        val nonEmptyDisj = res.genes
+        val satisfiableDisjunctions = res.genes
             .map { it as DisjunctionRxGene }
-            .filter{ !it.isEffectivelyEmpty() }
+            .filter{ !it.isUnsatisfiable() }
 
-        if (nonEmptyDisj.isEmpty()) {
+        if (satisfiableDisjunctions.isEmpty()) {
             throw IllegalStateException("Regex is unsatisfiable.")
         }
 
-        val disjList = DisjunctionListRxGene(nonEmptyDisj)
+        val disjList = DisjunctionListRxGene(satisfiableDisjunctions)
 
         // we remove the <EOF> token from end of the string to store as sourceRegex
         val gene = RegexGene(
@@ -265,7 +265,7 @@ class GeneRegexJavaVisitor : RegexJavaBaseVisitor<VisitResult>(){
 
             // if quantified atom is unsatisfiable we must then check the limits
             if (atom == null ||
-                ((atom as? RxTerm)?.isEffectivelyEmpty() == true) && resAtom.genes.size == 1) {
+                ((atom as? RxTerm)?.isUnsatisfiable() == true) && resAtom.genes.size == 1) {
                 return if (limits.first == 0) {
                     // if 0 appearances is allowed then the regex is satisfiable only with empty string
                     VisitResult(PatternCharacterBlockGene("0_QuantifierOnEmptyRegex", ""))

core/src/main/kotlin/org/evomaster/core/search/gene/regex/BackReferenceRxGene.kt

@@ -22,8 +22,8 @@ class BackReferenceRxGene(
     val captureGroup: DisjunctionListRxGene?
 ) : RxAtom, SimpleGene("\\$groupIndex") {
 
-    override fun isEffectivelyEmpty(): Boolean {
-        return captureGroup == null || captureGroup.isEffectivelyEmpty()
+    override fun isUnsatisfiable(): Boolean {
+        return captureGroup == null || captureGroup.isUnsatisfiable()
     }
 
     override fun checkForLocallyValidIgnoringChildren(): Boolean = true

core/src/main/kotlin/org/evomaster/core/search/gene/regex/CharacterClassEscapeRxGene.kt

@@ -132,10 +132,10 @@ class CharacterClassEscapeRxGene(
         }
     }
 
-    override fun isEffectivelyEmpty(): Boolean = multiCharRange.isEmpty
+    override fun isUnsatisfiable(): Boolean = multiCharRange.isEmpty
 
     override fun isMutable(): Boolean {
-        return !isEffectivelyEmpty()
+        return !isUnsatisfiable()
     }
 
     override fun checkForLocallyValidIgnoringChildren() : Boolean{
@@ -199,7 +199,7 @@ class CharacterClassEscapeRxGene(
     }
 
     override fun getValueAsPrintableString(previousGenes: List<Gene>, mode: GeneUtils.EscapeMode?, targetFormat: OutputFormat?, extraCheck: Boolean): String {
-        if (isEffectivelyEmpty()) {
+        if (isUnsatisfiable()) {
             throw IllegalStateException("Cannot get value from empty CharacterClassEscape")
         }
         return if (!flags.isCaseable(value[0])) {

core/src/main/kotlin/org/evomaster/core/search/gene/regex/CharacterRangeRxGene.kt

@@ -30,15 +30,15 @@ class CharacterRangeRxGene(
         private val log = LoggerFactory.getLogger(CharacterRangeRxGene::class.java)
     }
 
-    var value : Char = if (isEffectivelyEmpty()) '\u0000' else validRanges[0].start
+    var value : Char = if (isUnsatisfiable()) '\u0000' else validRanges[0].start
 
     /**
      * Whether to output the character in uppercase.
      * Only meaningful when flags.caseInsensitive is true.
      */
     var useUpperCase: Boolean = false
 
-    override fun isEffectivelyEmpty(): Boolean = validRanges.isEmpty
+    override fun isUnsatisfiable(): Boolean = validRanges.isEmpty
 
     override fun checkForLocallyValidIgnoringChildren() : Boolean{
         return validRanges.any {
@@ -51,7 +51,7 @@ class CharacterRangeRxGene(
     }
 
     override fun isMutable(): Boolean {
-        if (isEffectivelyEmpty()) {
+        if (isUnsatisfiable()) {
             return false
         }
         // check if there is more than one character or if the character is caseable
@@ -139,7 +139,7 @@ class CharacterRangeRxGene(
             TODO should \ be handled specially?
             In any case, would have same handling as AnyCharacterRxGene
          */
-        if (isEffectivelyEmpty()) {
+        if (isUnsatisfiable()) {
             throw IllegalStateException("Cannot get value from empty CharacterRange")
         }
         return if (!flags.isCaseable(value)) {

core/src/main/kotlin/org/evomaster/core/search/gene/regex/DisjunctionRxGene.kt

@@ -47,8 +47,8 @@ class DisjunctionRxGene(
         private val log : Logger = LoggerFactory.getLogger(DisjunctionRxGene::class.java)
     }
 
-    override fun isEffectivelyEmpty(): Boolean =
-        terms.isNotEmpty() && terms.any { (it as? RxTerm)?.isEffectivelyEmpty() == true }
+    override fun isUnsatisfiable(): Boolean =
+        terms.isNotEmpty() && terms.any { (it as? RxTerm)?.isUnsatisfiable() == true }
 
     override fun checkForLocallyValidIgnoringChildren() : Boolean{
         return true

core/src/main/kotlin/org/evomaster/core/search/gene/regex/RxTerm.kt

@@ -10,5 +10,5 @@ interface RxTerm {
      * for example an empty character class intersection like [a&&b].
      * Used at construction time to filter unsatisfiable branches from disjunctions.
      */
-    fun isEffectivelyEmpty(): Boolean = false
+    fun isUnsatisfiable(): Boolean = false
 }