More complexity fixes.

cs125-illinois · Oct 14, 2021 · 292c888 · 292c888
1 parent 349dca3
commit 292c888
Show file tree

Hide file tree

Showing 7 changed files with 95 additions and 19 deletions.
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -18,7 +18,7 @@ allprojects {
 }
 subprojects {
     group = "com.github.cs125-illinois.jeed"
-    version = "2021.10.1"
+    version = "2021.10.2"
     tasks.withType<Test> {
         useJUnitPlatform()
         enableAssertions = true

diff --git a/containerrunner/src/main/resources/edu.illinois.cs.cs125.jeed.containerrunner.version b/containerrunner/src/main/resources/edu.illinois.cs.cs125.jeed.containerrunner.version
@@ -1 +1 @@
-version=2021.10.1
+version=2021.10.2
diff --git a/core/src/main/kotlin/JavaComplexity.kt b/core/src/main/kotlin/JavaComplexity.kt
@@ -171,7 +171,7 @@ class JavaComplexityListener(val source: Source, entry: Map.Entry<String, String
         } else if (firstToken.type == JavaLexer.IF) {
             /*
              * if statements only ever add one unit of complexity. If no else is present then we either enter
-             * the condition or not or not, adding one path.
+             * the condition or not, adding one path.
              * If else is present then we either take the condition or the else, adding one path.
              */
             currentComplexity.complexity++

diff --git a/core/src/main/kotlin/KotlinComplexity.kt b/core/src/main/kotlin/KotlinComplexity.kt
@@ -176,35 +176,47 @@ class KotlinComplexityListener(val source: Source, entry: Map.Entry<String, Stri
     }
 
     // ||
+    private var requireDepth = 0
     override fun enterDisjunction(ctx: KotlinParser.DisjunctionContext) {
-        if (!ctx.text.contains("||")) {
-            return
+        val conjunction = ctx.conjunction()[0].text
+        if (conjunction.startsWith("require(") ||
+            conjunction.startsWith("check(") ||
+            conjunction.startsWith("assert(")
+        ) {
+            if (requireDepth == 0) {
+                currentComplexity.complexity++
+            }
+            requireDepth++
         }
-        if (ctx.text.contains("(") || ctx.text.contains(")")) {
+        if (ctx.DISJ().isEmpty()) {
             return
         }
         require(complexityStack.isNotEmpty())
-        currentComplexity.complexity++
+        currentComplexity.complexity += 1
+    }
+
+    override fun exitDisjunction(ctx: KotlinParser.DisjunctionContext) {
+        val conjunction = ctx.conjunction()[0].text
+        if (conjunction.startsWith("require(") ||
+            conjunction.startsWith("check(") ||
+            conjunction.startsWith("assert(")
+        ) {
+            requireDepth--
+        }
     }
 
     // &&
     override fun enterConjunction(ctx: KotlinParser.ConjunctionContext) {
-        if (!ctx.text.contains("&&")) {
-            return
-        }
-        if (ctx.text.contains("(") || ctx.text.contains(")")) {
+        if (ctx.CONJ().isEmpty()) {
             return
         }
         require(complexityStack.isNotEmpty())
-        currentComplexity.complexity++
+        currentComplexity.complexity += 1
     }
 
     // ?:
     override fun enterElvisExpression(ctx: KotlinParser.ElvisExpressionContext) {
-        if (!ctx.text.contains("?:")) {
-            return
-        }
-        if (ctx.text.contains("(") || ctx.text.contains(")")) {
+        if (ctx.ELVIS().isEmpty()) {
             return
         }
         require(complexityStack.isNotEmpty())
@@ -218,19 +230,31 @@ class KotlinComplexityListener(val source: Source, entry: Map.Entry<String, Stri
         // currentComplexity.complexity++
     }
 
+    private var inIfExpression = false
+
     // if & else if
     override fun enterIfExpression(ctx: KotlinParser.IfExpressionContext) {
         if (!ctx.text.contains("if")) {
             return
         }
         require(complexityStack.isNotEmpty())
         currentComplexity.complexity++
+        inIfExpression = true
+    }
+
+    override fun exitIfExpression(ctx: KotlinParser.IfExpressionContext) {
+        inIfExpression = false
     }
 
     // when, called for each ->, except the default one
     override fun enterWhenCondition(ctx: KotlinParser.WhenConditionContext) {
         require(complexityStack.isNotEmpty())
         currentComplexity.complexity++
+        inIfExpression = true
+    }
+
+    override fun exitWhenCondition(ctx: KotlinParser.WhenConditionContext) {
+        inIfExpression = false
     }
 
     // catch block
@@ -245,6 +269,13 @@ class KotlinComplexityListener(val source: Source, entry: Map.Entry<String, Stri
         currentComplexity.complexity++
     }
 
+    override fun enterJumpExpression(ctx: KotlinParser.JumpExpressionContext) {
+        if (ctx.THROW() != null && requireDepth == 0) {
+            require(complexityStack.isNotEmpty())
+            currentComplexity.complexity++
+        }
+    }
+
     // ?.
     override fun enterMemberAccessOperator(ctx: KotlinParser.MemberAccessOperatorContext) {
         if (ctx.text != "?.") {

diff --git a/core/src/main/resources/edu.illinois.cs.cs125.jeed.core.version b/core/src/main/resources/edu.illinois.cs.cs125.jeed.core.version
@@ -1 +1 @@
-version=2021.10.1
+version=2021.10.2
diff --git a/core/src/test/kotlin/TestKotlinComplexity.kt b/core/src/test/kotlin/TestKotlinComplexity.kt
@@ -363,7 +363,9 @@ class PingPonger constructor(private var state: String) {
                 """.trim()
             )
         ).complexity().also {
-            it.lookup("PingPonger", "Test.kt").complexity shouldBe 5
+            it.lookup("PingPonger", "Test.kt").complexity shouldBe 8
+            it.lookup("PingPonger.pong():Boolean", "Test.kt").complexity shouldBe 2
+            it.lookup("PingPonger.ping():Boolean", "Test.kt").complexity shouldBe 2
         }
     }
 
@@ -650,4 +652,47 @@ val addEight = object : Adder {
             ).complexity()
         }
     }
+    "should measure when and if equivalently" {
+        Source.fromKotlin(
+            """
+fun first(first: Int, second: Int): Int {
+  return if (first > second && second > first) {
+    1
+  } else if (second < first && first < second) {
+    -1
+  } else {
+    0
+  }
+}
+fun second(first: Int, second: Int): Int {
+  return when {
+    first > second && second > first -> 1
+    second < first && first < second -> -1
+    else -> 0
+  }
+}
+""".trim()
+        ).complexity().also {
+            it.lookup("first(Int,Int):Int", "Main.kt").complexity shouldBe 5
+            it.lookup("second(Int,Int):Int", "Main.kt").complexity shouldBe 5
+        }
+    }
+    "should measure if correctly" {
+        Source.fromKotlin(
+            """
+fun first(first: Int, second: Int): Int {
+  var it = first > second || second == first
+  return if (first > second && second > first || second == first && second == second) {
+    1
+  } else if (second < first && first < second) {
+    -1
+  } else {
+    0
+  }
+}
+""".trim()
+        ).complexity().also {
+            it.lookup("first(Int,Int):Int", "Main.kt").complexity shouldBe 8
+        }
+    }
 })
diff --git a/server/src/main/resources/edu.illinois.cs.cs125.jeed.server.version b/server/src/main/resources/edu.illinois.cs.cs125.jeed.server.version
@@ -1 +1 @@
-version=2021.10.1
+version=2021.10.2