Feature Flag Annotator

gradle/libs.versions.toml

@@ -78,6 +78,7 @@ gradlePlugins-wire = { module = "com.squareup.wire:wire-gradle-plugin", version.
 guava = "com.google.guava:guava:32.1.2-jre"
 kotlinCliUtil = "com.slack.cli:kotlin-cli-util:2.2.1"
 kotlin-bom = { module = "org.jetbrains.kotlin:kotlin-bom", version.ref = "kotlin" }
+kotlin-compilerEmbeddable = { module = "org.jetbrains.kotlin:kotlin-compiler-embeddable", version.ref = "kotlin" }
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
 ktfmt = { module = "com.facebook:ktfmt", version.ref = "ktfmt" }
 jgrapht = "org.jgrapht:jgrapht-core:1.5.2"

skate-plugin/build.gradle.kts

@@ -17,7 +17,10 @@ repositories { mavenCentral() }
 
 // Configure Gradle IntelliJ Plugin
 // Read more: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html
-intellij { plugins.add("org.intellij.plugins.markdown") }
+intellij {
+  plugins.add("org.intellij.plugins.markdown")
+  plugins.add("org.jetbrains.kotlin")
+}
 
 fun isGitHash(hash: String): Boolean {
   if (hash.length != 40) {
@@ -86,6 +89,7 @@ tasks
 
 dependencies {
   implementation(libs.bugsnag) { exclude(group = "org.slf4j") }
+  compileOnly(libs.kotlin.compilerEmbeddable)
   testImplementation(libs.junit)
   testImplementation(libs.truth)
 }

skate-plugin/src/main/kotlin/com/slack/sgp/intellij/Constants.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2023 Slack Technologies, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.slack.sgp.intellij
+
+import com.intellij.openapi.util.Key
+
+// Note this is a hack to allow tests to not use KotlinLanguage class due to classloading problems
+// with IJ and detekt.
+val TEST_KOTLIN_LANGUAGE_ID_KEY = Key.create<String>("__tests_only_kotlin_id__")

skate-plugin/src/main/kotlin/com/slack/sgp/intellij/SkatePluginSettings.kt

@@ -38,8 +38,22 @@ class SkatePluginSettings : SimplePersistentStateComponent<SkatePluginSettings.S
       state.isWhatsNewEnabled = value
     }
 
+  var isLinkifiedFeatureFlagsEnabled: Boolean
+    get() = state.isLinkifiedFeatureFlagsEnabled
+    set(value) {
+      state.isLinkifiedFeatureFlagsEnabled = value
+    }
+
+  var featureFlagBaseUrl: String?
+    get() = state.featureFlagBaseUrl ?: "https://houston.tinyspeck.com/experiments/all"
+    set(value) {
+      state.featureFlagBaseUrl = value
+    }
+
   class State : BaseState() {
     var whatsNewFilePath by string()
     var isWhatsNewEnabled by property(true)
+    var isLinkifiedFeatureFlagsEnabled by property(true)
+    var featureFlagBaseUrl by string()
   }
 }

skate-plugin/src/main/kotlin/com/slack/sgp/intellij/featureflags/FeatureFlagAnnotator.kt

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2023 Slack Technologies, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.slack.sgp.intellij.featureflags
+
+import com.intellij.codeInsight.intention.IntentionAction
+import com.intellij.ide.BrowserUtil
+import com.intellij.lang.annotation.AnnotationHolder
+import com.intellij.lang.annotation.ExternalAnnotator
+import com.intellij.lang.annotation.HighlightSeverity
+import com.intellij.openapi.application.runReadAction
+import com.intellij.openapi.components.service
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.util.PsiTreeUtil
+import com.slack.sgp.intellij.SkatePluginSettings
+import com.slack.sgp.intellij.TEST_KOTLIN_LANGUAGE_ID_KEY
+import com.slack.sgp.intellij.util.isLinkifiedFeatureFlagsEnabled
+import java.net.URI
+import org.jetbrains.kotlin.idea.KotlinLanguage
+
+class FeatureFlagAnnotator : ExternalAnnotator<PsiFile, List<FeatureFlagSymbol>>() {
+  private val extractor by lazy { FeatureFlagExtractor() }
+
+  override fun collectInformation(file: PsiFile): PsiFile? {
+    if (!isKotlinFeatureFile(file)) {
+      return null
+    }
+    if (extractor.getFeatureFlagsForPsiFile(file) == null) {
+      val flags = extractor.extractFeatureFlags(file)
+      extractor.setFeatureFlagsForPsiFile(file, flags)
+    }
+    return file
+  }
+
+  override fun doAnnotate(collectedInfo: PsiFile): List<FeatureFlagSymbol> {
+    if (!collectedInfo.project.isLinkifiedFeatureFlagsEnabled() || !isKotlinFile(collectedInfo)) {
+      return emptyList()
+    }
+
+    val flagsForFile = extractor.getFeatureFlagsForPsiFile(collectedInfo)
+    return transformToFeatureFlagSymbols(collectedInfo, flagsForFile)
+  }
+
+  private fun transformToFeatureFlagSymbols(
+    psiFile: PsiFile,
+    flags: List<String>?
+  ): List<FeatureFlagSymbol> {
+    if (flags.isNullOrEmpty()) {
+      return emptyList()
+    }
+    val baseUrl = psiFile.project.service<SkatePluginSettings>().featureFlagBaseUrl.orEmpty()
+
+    return flags.mapNotNull { flag ->
+      val textRange = runReadAction { findTextRangeForFlag(psiFile, flag) }
+      if (textRange != null) {
+        val url = "$baseUrl?q=${flag.lowercase()}"
+        FeatureFlagSymbol(textRange, url)
+      } else {
+        null
+      }
+    }
+  }
+
+  private fun findTextRangeForFlag(psiFile: PsiFile, flag: String): TextRange? {
+    val elements = PsiTreeUtil.findChildrenOfType(psiFile, PsiElement::class.java)
+    return elements.firstOrNull { it.text == flag }?.textRange
+  }
+
+  private fun isKotlinFile(psiFile: PsiFile): Boolean =
+    psiFile.language.id == KotlinLanguage.INSTANCE.id ||
+      psiFile.getUserData(TEST_KOTLIN_LANGUAGE_ID_KEY) == KotlinLanguage.INSTANCE.id
+
+  private fun isKotlinFeatureFile(psiFile: PsiFile): Boolean = psiFile.name.endsWith("Feature.kt")
+
+  override fun apply(
+    file: PsiFile,
+    annotationResult: List<FeatureFlagSymbol>,
+    holder: AnnotationHolder
+  ) {
+    for (symbol in annotationResult) {
+      val message = "Open on Houston: ${symbol.url}"
+      holder
+        .newAnnotation(
+          HighlightSeverity.INFORMATION,
+          "More details about feature flag on Houston..."
+        )
+        .range(symbol.textRange)
+        .needsUpdateOnTyping(true)
+        .withFix(UrlIntentionAction(message, symbol.url))
+        .create()
+    }
+  }
+}
+
+class FeatureFlagSymbol(val textRange: TextRange, val url: String)
+
+class UrlIntentionAction(
+  private val message: String,
+  private val url: String,
+) : IntentionAction {
+  override fun getText(): String = message
+
+  override fun getFamilyName(): String = text
+
+  override fun isAvailable(project: Project, editor: Editor?, file: PsiFile?) = true
+
+  override fun invoke(project: Project, editor: Editor?, file: PsiFile?) {
+    BrowserUtil.browse(URI(url))
+  }
+
+  override fun startInWriteAction(): Boolean {
+    return false
+  }
+}

skate-plugin/src/main/kotlin/com/slack/sgp/intellij/featureflags/FeatureFlagExtractor.kt

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2023 Slack Technologies, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.slack.sgp.intellij.featureflags
+
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.psi.PsiFile
+
+/**
+ * Responsible for extracting feature flags. Searches for enum entries annotated with 'FeatureFlag'
+ * to identify feature flags.
+ */
+class FeatureFlagExtractor {
+
+  private val log: Logger = Logger.getInstance(FeatureFlagExtractor::class.java)
+
+  // Caches the feature flags for a given PSI file to optimize repeated lookups
+  companion object {
+    private val featureFlagCache = mutableMapOf<PsiFile, List<String>>()
+  }
+
+  fun setFeatureFlagsForPsiFile(psiFile: PsiFile, flags: List<String>) {
+    featureFlagCache[psiFile] = flags
+  }
+
+  fun getFeatureFlagsForPsiFile(psiFile: PsiFile): List<String>? {
+    return featureFlagCache[psiFile]
+  }
+  /**
+   * Extracts the names of feature flags from the provided PSI file. Only processes Kotlin files.
+   *
+   * @param psiFile The PSI representation of the file to process.
+   * @return A list of feature flag names in a file
+   */
+  fun extractFeatureFlags(psiFile: PsiFile): List<String> {
+    log.info("Looking for feature flags in a file: $psiFile")
+    val enumsWithAnnotation = findAnnotatedEnums(psiFile)
+    log.info("Found feature flags: $enumsWithAnnotation")
+    return enumsWithAnnotation
+  }
+
+  /** Recursively searches the given PSI file for enums with 'FeatureFlag' annotations. */
+  private fun findAnnotatedEnums(psiFile: Any): List<String> {
+    val annotatedEnumEntries = mutableListOf<String>()
+
+    fun addIfAnnotatedEnum(element: Any) {
+      if (isKtEnumEntry(element) && hasFeatureFlagAnnotation(element)) {
+        element.javaClass
+          .getMethod("getName")
+          .invoke(element)
+          .takeIf { it is String }
+          ?.let { annotatedEnumEntries.add(it as String) }
+      }
+    }
+
+    fun recurse(element: Any) {
+      addIfAnnotatedEnum(element)
+      element.javaClass.methods
+        .find { it.name == "getChildren" }
+        ?.let { method -> (method.invoke(element) as? Array<*>)?.forEach { recurse(it!!) } }
+    }
+    recurse(psiFile)
+    return annotatedEnumEntries
+  }
+
+  /**
+   * Determines if a given PSI element is an enum entry annotated with 'FeatureFlag'.
+   *
+   * @param element The enum entry to check.
+   * @return true if the enum entry is a feature flag, false otherwise.
+   */
+  private fun hasFeatureFlagAnnotation(element: Any): Boolean {
+    val annotationEntriesMethod = element.javaClass.getMethod("getAnnotationEntries")
+    val annotationEntries = annotationEntriesMethod.invoke(element) as? List<*>
+    return annotationEntries?.any {
+      val shortNameMethod = it!!.javaClass.getMethod("getShortName")
+      val shortName = shortNameMethod.invoke(it)
+      shortName?.toString() == "FeatureFlag"
+    } ?: false
+  }
+
+  /** Checks if the given PSI element is a Kotlin enum entry. */
+  private fun isKtEnumEntry(element: Any): Boolean {
+    log.info("Checking if element is a Kotlin Enum Entry")
+    val result = element.javaClass.name == "org.jetbrains.kotlin.psi.KtEnumEntry"
+    log.info("Element is Kotlin Enum Entry: $result")
+    return result
+  }
+}

skate-plugin/src/main/kotlin/com/slack/sgp/intellij/util/ProjectUtils.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2023 Slack Technologies, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.slack.sgp.intellij.util
+
+import com.intellij.openapi.components.service
+import com.intellij.openapi.project.Project
+import com.slack.sgp.intellij.SkatePluginSettings
+
+fun Project.settings(): SkatePluginSettings = service<SkatePluginSettings>()
+
+fun Project.isLinkifiedFeatureFlagsEnabled(): Boolean = settings().isLinkifiedFeatureFlagsEnabled

skate-plugin/src/main/resources/META-INF/plugin.xml

@@ -21,6 +21,7 @@
          Read more: https://plugins.jetbrains.com/docs/intellij/plugin-compatibility.html -->
     <depends>com.intellij.modules.platform</depends>
     <depends>org.intellij.plugins.markdown</depends>
+    <depends>org.jetbrains.kotlin</depends>
 
     <!-- Extension points defined by the plugin.
          Read more: https://plugins.jetbrains.com/docs/intellij/plugin-extension-points.html -->
@@ -30,6 +31,7 @@
                 serviceImplementation="com.slack.sgp.intellij.SkateProjectServiceImpl"/>
         <projectConfigurable instance="com.slack.sgp.intellij.SkateConfig"/>
         <errorHandler implementation="com.slack.sgp.intellij.SkateErrorHandler"/>
+        <externalAnnotator language="kotlin" implementationClass="com.slack.sgp.intellij.featureflags.FeatureFlagAnnotator"/>
     </extensions>
 
     <applicationListeners>