Review fixes: fixed formatting, removed redundant types

UnitTestBot · amandelpie · Aug 24, 2022 · Jul 22, 2022 · Jul 25, 2022 · Jul 26, 2022
commit 83f4e7111c3533bbd95d631ffec47d9cf10ebc35
diff --git a/...framework/src/main/kotlin/org/utbot/framework/codegen/model/visitor/CgAbstractRenderer.kt b/...framework/src/main/kotlin/org/utbot/framework/codegen/model/visitor/CgAbstractRenderer.kt
@@ -317,7 +317,10 @@ internal abstract class CgAbstractRenderer(val context: CgContext, val printer:
 
     override fun visit(element: CgCustomTagStatement) {
         if (element.content.all { it.isEmpty() }) return
-        for (stmt in element.content) stmt.accept(this)
+
+        for (stmt in element.content) {
+            stmt.accept(this)
+        }
     }
 
     override fun visit(element: CgDocCodeStmt) {

diff --git a/...-intellij/src/main/kotlin/org/utbot/intellij/plugin/javadoc/UtCustomJavaDocTagProvider.kt b/...-intellij/src/main/kotlin/org/utbot/intellij/plugin/javadoc/UtCustomJavaDocTagProvider.kt
@@ -14,7 +14,7 @@ import org.utbot.summary.comment.CustomJavaDocTagProvider
  */
 class UtCustomJavaDocTagProvider : CustomJavadocTagProvider {
     override fun getSupportedTags(): List<UtCustomTagInfo> =
-        CustomJavaDocTagProvider().getPluginCustomTags().map { t -> UtCustomTagInfo(t) }
+        CustomJavaDocTagProvider().getPluginCustomTags().map { UtCustomTagInfo(it) }
 
     class UtCustomTagInfo(private val tag: CustomJavaDocTag) : JavadocTagInfo {
         override fun getName(): String = tag.name
@@ -27,8 +27,6 @@ class UtCustomJavaDocTagProvider : CustomJavadocTagProvider {
 
         override fun getReference(value: PsiDocTagValue?): PsiReference? = null
 
-        override fun isValidInContext(element: PsiElement?): Boolean {
-            return element is PsiMethod
-        }
+        override fun isValidInContext(element: PsiElement?): Boolean = element is PsiMethod
     }
 }
diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/javadoc/UtDocumentationProvider.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/javadoc/UtDocumentationProvider.kt
@@ -5,7 +5,6 @@ import com.intellij.codeInsight.javadoc.JavaDocInfoGenerator
 import com.intellij.lang.java.JavaDocumentationProvider
 import com.intellij.psi.PsiDocCommentBase
 import com.intellij.psi.PsiJavaDocumentedElement
-import com.intellij.psi.javadoc.PsiDocComment
 
 /**
  * To render UtBot custom JavaDoc tags correctly, we need to override the way it generates HTML tags for comments.
@@ -14,22 +13,23 @@ import com.intellij.psi.javadoc.PsiDocComment
  * It renders text, code, and links.
  */
 class UtDocumentationProvider : JavaDocumentationProvider() {
-    override fun generateRenderedDoc(comment: PsiDocCommentBase): String {
-        var target = comment.owner
-        if (target == null) target = comment
-        val docComment: PsiDocComment?
-        var finalJavaDoc = ""
-        if (target is PsiJavaDocumentedElement) {
-            docComment = target.docComment
-            if (docComment != null) {
-                val baseJavaDocInfoGenerator = JavaDocInfoGenerator(target.project, target)
-                val baseJavaDocInfo = baseJavaDocInfoGenerator.generateRenderedDocInfo()
-                val utJavaDocInfoGenerator = UtJavaDocInfoGenerator()
-                val javaDocInfoWithUtSections =
-                    utJavaDocInfoGenerator.addUtBotSpecificSectionsToJavaDoc(baseJavaDocInfo, docComment)
-                finalJavaDoc = JavaDocExternalFilter.filterInternalDocInfo(javaDocInfoWithUtSections)!!
-            }
+    override fun generateRenderedDoc(comment: PsiDocCommentBase): String? {
+        val target = comment.owner ?: comment
+
+        if (target !is PsiJavaDocumentedElement) {
+            return ""
         }
-        return finalJavaDoc
+
+        val docComment = target.docComment ?: return ""
+
+        val baseJavaDocInfoGenerator = JavaDocInfoGenerator(target.project, target)
+        // get JavaDoc comment rendered by the platform.
+        val baseJavaDocInfo = baseJavaDocInfoGenerator.generateRenderedDocInfo()
+        val utJavaDocInfoGenerator = UtJavaDocInfoGenerator()
+        // add UTBot sections with custom tags.
+        val javaDocInfoWithUtSections =
+            utJavaDocInfoGenerator.addUtBotSpecificSectionsToJavaDoc(baseJavaDocInfo, docComment)
+
+        return JavaDocExternalFilter.filterInternalDocInfo(javaDocInfoWithUtSections)
     }
 }
diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/javadoc/UtJavaDocInfoGenerator.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/javadoc/UtJavaDocInfoGenerator.kt
@@ -31,7 +31,12 @@ private val logger = KotlinLogging.logger {}
  */
 class UtJavaDocInfoGenerator {
     fun addUtBotSpecificSectionsToJavaDoc(javadoc: String?, comment: PsiDocComment): String {
-        val builder: StringBuilder = StringBuilder(javadoc)
+        val builder = if (javadoc == null) {
+            StringBuilder()
+        } else {
+            StringBuilder(javadoc)
+        }
+
         val docTagProvider = UtCustomJavaDocTagProvider()
         docTagProvider.supportedTags.forEach {
             generateUtTagSection(builder, comment, it)
@@ -44,49 +49,54 @@ class UtJavaDocInfoGenerator {
      */
     private fun generateUtTagSection(
         builder: StringBuilder,
-        comment: PsiDocComment?,
+        comment: PsiDocComment,
         utTag: UtCustomJavaDocTagProvider.UtCustomTagInfo
     ) {
-        if (comment != null) {
-            val tag = comment.findTagByName(utTag.name) ?: return
-            startHeaderSection(builder, utTag.getMessage()).append("<p>")
-            val sectionContent = buildString {
-                generateValue(this, tag.dataElements)
-                this.trim { it <= ' ' }
-            }
-            builder.append(sectionContent)
-            builder.append(DocumentationMarkup.SECTION_END)
+        val tag = comment.findTagByName(utTag.name) ?: return
+        startHeaderSection(builder, utTag.getMessage()).append("<p>")
+        val sectionContent = buildString {
+            generateValue(this, tag.dataElements)
+            trim()
         }
+
+        builder.append(sectionContent)
+        builder.append(DocumentationMarkup.SECTION_END)
     }
 
-    private fun startHeaderSection(builder: StringBuilder, message: String): StringBuilder {
-        return builder.append(DocumentationMarkup.SECTION_HEADER_START)
+    private fun startHeaderSection(builder: StringBuilder, message: String): StringBuilder =
+        builder.append(DocumentationMarkup.SECTION_HEADER_START)
             .append(message)
             .append(MESSAGE_SEPARATOR)
             .append(DocumentationMarkup.SECTION_SEPARATOR)
-    }
 
     /**
      * Generates info depending on tag's value type.
      */
     private fun generateValue(builder: StringBuilder, elements: Array<PsiElement>) {
-        var offset = if (elements.isNotEmpty()) {
-            elements[0].textOffset + elements[0].text.length
-        } else 0
-
-        for (i in elements.indices) {
-            if (elements[i].textOffset > offset) builder.append(' ')
-            offset = elements[i].textOffset + elements[i].text.length
-            val element = elements[i]
-            if (element is PsiInlineDocTag) {
-                when (element.name) {
-                    LITERAL_TAG -> generateLiteralValue(builder, element)
-                    CODE_TAG, SYSTEM_PROPERTY_TAG -> generateCodeValue(element, builder)
-                    LINK_TAG -> generateLinkValue(element, builder, false)
-                    LINKPLAIN_TAG -> generateLinkValue(element, builder, true)
+        if (elements.isEmpty()) {
+            return
+        }
+
+        var offset = elements[0].textOffset + elements[0].text.length
+
+        for (element in elements) {
+            with(element) {
+                if (textOffset > offset) {
+                    builder.append(' ')
+                }
+
+                offset = textOffset + text.length
+
+                if (element is PsiInlineDocTag) {
+                    when (element.name) {
+                        LITERAL_TAG -> generateLiteralValue(builder, element)
+                        CODE_TAG, SYSTEM_PROPERTY_TAG -> generateCodeValue(element, builder)
+                        LINK_TAG -> generateLinkValue(element, builder, false)
+                        LINKPLAIN_TAG -> generateLinkValue(element, builder, true)
+                    }
+                } else {
+                    appendPlainText(builder, text)
                 }
-            } else {
-                appendPlainText(builder, element.text)
             }
         }
     }
@@ -140,11 +150,11 @@ class UtJavaDocInfoGenerator {
 
     private fun generateLinkValue(tag: PsiInlineDocTag, builder: StringBuilder, plainLink: Boolean) {
         val tagElements = tag.dataElements
-        val linkText: String = createLinkText(tagElements)
+        val linkText = createLinkText(tagElements)
         if (linkText.isNotEmpty()) {
             val index = JavaDocUtil.extractReference(linkText)
-            val referenceText = linkText.substring(0, index).trim { it <= ' ' }
-            val label = StringUtil.nullize(linkText.substring(index).trim { it <= ' ' })
+            val referenceText = linkText.substring(0, index).trim()
+            val label = StringUtil.nullize(linkText.substring(index).trim())
             generateLink(builder, referenceText, label, tagElements[0], plainLink)
         }
     }
@@ -166,7 +176,7 @@ class UtJavaDocInfoGenerator {
                     this.append(' ')
                 }
             }
-        }.trim { it <= ' ' }
+        }.trim()
     }
 
     private fun generateLink(
@@ -176,10 +186,8 @@ class UtJavaDocInfoGenerator {
         context: PsiElement,
         plainLink: Boolean
     ) {
-        var linkLabel = label
-        if (label == null) {
-            val manager = context.manager
-            linkLabel = JavaDocUtil.getLabelText(manager.project, manager, refText, context)
+        val linkLabel = label ?: context.manager.let {
+            JavaDocUtil.getLabelText(it.project, it, refText, context)
         }
 
         var target: PsiElement? = null
@@ -196,9 +204,8 @@ class UtJavaDocInfoGenerator {
         } else if (target == null) {
             builder.append("<font color=red>").append(linkLabel).append("</font>")
         } else {
-            val referenceText = JavaDocUtil.getReferenceText(target.project, target)
-            if (referenceText != null) {
-                DocumentationManagerUtil.createHyperlink(builder, target, referenceText, linkLabel, plainLink)
+            JavaDocUtil.getReferenceText(target.project, target)?.let {
+                DocumentationManagerUtil.createHyperlink(builder, target, it, linkLabel, plainLink)
             }
         }
     }

diff --git a/utbot-summary/src/main/kotlin/org/utbot/summary/comment/CustomJavaDocCommentBuilder.kt b/utbot-summary/src/main/kotlin/org/utbot/summary/comment/CustomJavaDocCommentBuilder.kt
@@ -16,10 +16,10 @@ class CustomJavaDocCommentBuilder(
      * Collects statements for final JavaDoc comment.
      */
     fun buildDocStatements(method: SootMethod): List<DocStatement> {
-        val comment: CustomJavaDocComment = buildCustomJavaDocComment(method)
+        val comment = buildCustomJavaDocComment(method)
         val docStatementList =
             CustomJavaDocTagProvider().getPluginCustomTags().mapNotNull { it.generateDocStatement(comment) }
-        return listOf<DocStatement>(DocCustomTagStatement(docStatementList))
+        return listOf(DocCustomTagStatement(docStatementList))
     }
 
     private fun buildCustomJavaDocComment(currentMethod: SootMethod): CustomJavaDocComment {