Feature Flag Annotator

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

@@ -55,10 +55,31 @@ class SkatePluginSettings : SimplePersistentStateComponent<SkatePluginSettings.S
       state.translatorFileNameSuffix = value
     }
 
+  var isLinkifiedFeatureFlagsEnabled: Boolean
+    get() = state.isLinkifiedFeatureFlagsEnabled
+    set(value) {
+      state.isLinkifiedFeatureFlagsEnabled = value
+    }
+
+  var featureFlagBaseUrl: String?
+    get() = state.featureFlagBaseUrl
+    set(value) {
+      state.featureFlagBaseUrl = value
+    }
+
+  var featureFlagAnnotation: String?
+    get() = state.featureFlagAnnotation
+    set(value) {
+      state.featureFlagAnnotation = value
+    }
+
   class State : BaseState() {
     var whatsNewFilePath by string()
     var isWhatsNewEnabled by property(true)
     var translatorSourceModelsPackageName by string()
     var translatorFileNameSuffix by string()
+    var isLinkifiedFeatureFlagsEnabled by property(false)
+    var featureFlagBaseUrl by string()
+    var featureFlagAnnotation by string()
   }
 }

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

@@ -0,0 +1,81 @@
+/*
+ * 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.editor.Editor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiFile
+import com.slack.sgp.intellij.util.isLinkifiedFeatureFlagsEnabled
+import java.net.URI
+import org.jetbrains.kotlin.psi.KtFile
+
+class FeatureFlagAnnotator : ExternalAnnotator<List<FeatureFlagSymbol>, List<FeatureFlagSymbol>>() {
+
+  override fun collectInformation(file: PsiFile): List<FeatureFlagSymbol> {
+    val isEligibleForLinkifiedFeatureProcessing =
+      file.project.isLinkifiedFeatureFlagsEnabled() && file is KtFile && isKotlinFeatureFile(file)
+
+    if (!isEligibleForLinkifiedFeatureProcessing) {
+      return emptyList()
+    }
+    return FeatureFlagExtractor.extractFeatureFlags(file)
+  }
+
+  override fun doAnnotate(collectedInfo: List<FeatureFlagSymbol>): List<FeatureFlagSymbol> =
+    collectedInfo
+
+  override fun apply(
+    file: PsiFile,
+    annotationResult: List<FeatureFlagSymbol>,
+    holder: AnnotationHolder
+  ) {
+    for (symbol in annotationResult) {
+      val message = "Open at: ${symbol.url}"
+      holder
+        .newAnnotation(HighlightSeverity.INFORMATION, "Open for more details.")
+        .range(symbol.range)
+        .needsUpdateOnTyping(true)
+        .withFix(UrlIntentionAction(message, symbol.url))
+        .create()
+    }
+  }
+
+  private fun isKotlinFeatureFile(psiFile: PsiFile): Boolean = psiFile.name.endsWith("Feature.kt")
+}
+
+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,64 @@
+/*
+ * 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.components.service
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiFile
+import com.slack.sgp.intellij.SkatePluginSettings
+import java.util.Locale
+import org.jetbrains.uast.UEnumConstant
+import org.jetbrains.uast.UFile
+import org.jetbrains.uast.evaluateString
+import org.jetbrains.uast.toUElementOfType
+
+/**
+ * Responsible for extracting feature flags. Searches for enum entries annotated with 'FeatureFlag'
+ * to identify feature flags.
+ */
+object FeatureFlagExtractor {
+
+  /**
+   * 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.
+   */
+  fun extractFeatureFlags(psiFile: PsiFile): List<FeatureFlagSymbol> {
+    val settings = psiFile.project.service<SkatePluginSettings>()
+    val baseUrl = settings.featureFlagBaseUrl
+    val flagAnnotation = settings.featureFlagAnnotation.orEmpty()
+
+    val uFile = psiFile.toUElementOfType<UFile>() ?: return emptyList()
+
+    return uFile
+      .allClassesAndInnerClasses()
+      .filter { it.isEnum }
+      .flatMap { enumClass -> enumClass.uastDeclarations.filterIsInstance<UEnumConstant>() }
+      .mapNotNull { enumConstant ->
+        enumConstant.findAnnotation(flagAnnotation)?.let { flagAnnotation ->
+          val textRange = enumConstant.sourcePsi?.textRange ?: return@mapNotNull null
+          val key =
+            flagAnnotation.findAttributeValue("key")?.evaluateString()?.takeUnless {
+              it.trim().isBlank()
+            } ?: enumConstant.name.lowercase(Locale.US)
+          FeatureFlagSymbol(textRange, "$baseUrl$key")
+        }
+      }
+      .toList()
+  }
+}
+
+data class FeatureFlagSymbol(val range: TextRange, val url: String)

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

@@ -0,0 +1,28 @@
+/*
+ * 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 org.jetbrains.uast.UClass
+import org.jetbrains.uast.UFile
+
+fun UFile.allClassesAndInnerClasses(): Sequence<UClass> {
+  return classes.asSequence().flatMap(UClass::asSequenceWithInnerClasses)
+}
+
+fun UClass.asSequenceWithInnerClasses(): Sequence<UClass> {
+  return sequenceOf(this)
+    .plus(innerClasses.asSequence().flatMap(UClass::asSequenceWithInnerClasses))
+}

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

@@ -18,10 +18,14 @@ package com.slack.sgp.intellij.ui
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.DialogPanel
 import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.ui.components.JBCheckBox
+import com.intellij.ui.dsl.builder.Cell
 import com.intellij.ui.dsl.builder.Panel
 import com.intellij.ui.dsl.builder.bindSelected
 import com.intellij.ui.dsl.builder.bindText
 import com.intellij.ui.dsl.builder.panel
+import com.intellij.ui.dsl.builder.selected
+import com.intellij.ui.layout.ComponentPredicate
 import com.slack.sgp.intellij.SkateBundle
 import com.slack.sgp.intellij.SkatePluginSettings
 import java.io.File
@@ -34,6 +38,7 @@ internal class SkateConfigUI(
   fun createPanel(): DialogPanel = panel {
     checkBoxRow()
     choosePathRow()
+    featureFlagSettings()
   }
 
   private fun Panel.checkBoxRow() {
@@ -71,4 +76,53 @@ internal class SkateConfigUI(
         .enabled(settings.isWhatsNewEnabled)
     }
   }
+
+  private fun Panel.featureFlagSettings() {
+    lateinit var linkifiedFeatureFlagsCheckBox: Cell<JBCheckBox>
+
+    row(SkateBundle.message("skate.configuration.enableFeatureFlagLinking.title")) {
+      linkifiedFeatureFlagsCheckBox =
+        checkBox(SkateBundle.message("skate.configuration.enableFeatureFlagLinking.description"))
+          .bindSelected(
+            getter = { settings.isLinkifiedFeatureFlagsEnabled },
+            setter = { settings.isLinkifiedFeatureFlagsEnabled = it }
+          )
+    }
+
+    bindAndValidateTextFieldRow(
+      titleMessageKey = "skate.configuration.featureFlagAnnotation.title",
+      getter = { settings.featureFlagAnnotation },
+      setter = { settings.featureFlagAnnotation = it },
+      errorMessageKey = "skate.configuration.featureFlagFieldEmpty.error",
+      enabledCondition = linkifiedFeatureFlagsCheckBox.selected
+    )
+
+    bindAndValidateTextFieldRow(
+      titleMessageKey = "skate.configuration.featureFlagBaseUrl.title",
+      getter = { settings.featureFlagBaseUrl },
+      setter = { settings.featureFlagBaseUrl = it },
+      errorMessageKey = "skate.configuration.featureFlagFieldEmpty.error",
+      enabledCondition = linkifiedFeatureFlagsCheckBox.selected
+    )
+  }
+
+  private fun Panel.bindAndValidateTextFieldRow(
+    titleMessageKey: String,
+    getter: () -> String?,
+    setter: (String) -> Unit,
+    errorMessageKey: String,
+    enabledCondition: ComponentPredicate? = null
+  ) {
+    row(SkateBundle.message(titleMessageKey)) {
+      textField()
+        .bindText(getter = { getter().orEmpty() }, setter = setter)
+        .validationOnApply {
+          if (it.text.isBlank()) error(SkateBundle.message(errorMessageKey)) else null
+        }
+        .validationOnInput {
+          if (it.text.isBlank()) error(SkateBundle.message(errorMessageKey)) else null
+        }
+        .apply { enabledCondition?.let { enabledIf(it) } }
+    }
+  }
 }

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

@@ -32,6 +32,7 @@
         <projectConfigurable instance="com.slack.sgp.intellij.SkateConfig"/>
         <errorHandler implementation="com.slack.sgp.intellij.SkateErrorHandler"/>
         <annotator language="kotlin" implementationClass="com.slack.sgp.intellij.modeltranslator.TranslatorAnnotator"/>
+        <externalAnnotator language="kotlin" implementationClass="com.slack.sgp.intellij.featureflags.FeatureFlagAnnotator"/>
     </extensions>
 
     <applicationListeners>

skate-plugin/src/main/resources/messages/skateBundle.properties

@@ -4,3 +4,8 @@ skate.configuration.choosePath.dialog.title=Choose Changelog File
 skate.configuration.enableWhatsNew.title=Enable What's New Panel
 skate.configuration.enableWhatsNew.description=If enabled, shows the What's New Panel if there are new changes detected in a specified changelog file.
 skate.modelTranslator.description=Generate translator body
+skate.configuration.enableFeatureFlagLinking.title=Enable Feature Flag Linking
+skate.configuration.enableFeatureFlagLinking.description=If enabled, show inspections for opening feature flag links from corresponding enum entries.
+skate.configuration.featureFlagBaseUrl.title=Base URL for feature flag linking. The flag key will be appended to the end of this
+skate.configuration.featureFlagAnnotation.title=Feature flag annotation's fully-qualified name (com.example.FeatureFlag)
+skate.configuration.featureFlagFieldEmpty.error=Field cannot be empty when feature flag linking is enabled

skate-plugin/src/test/kotlin/com/slack/sgp/intellij/featureflags/BaseFeatureFlagTest.kt

@@ -0,0 +1,49 @@
+/*
+ * 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.psi.PsiFile
+import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixture4TestCase
+
+abstract class BaseFeatureFlagTest : LightPlatformCodeInsightFixture4TestCase() {
+  // language=kotlin
+  protected val fileContent =
+    """
+        package slack.featureflag
+
+        annotation class FeatureFlag(defaultValue: Boolean, val key: String = "", minimization: Minimization)
+
+        enum class Minimization { AUTHENTICATED }
+
+        enum class TestFeatures :
+          FeatureFlagEnum {
+          @Deprecated("test")
+          @FeatureFlag(defaultValue = false, key ="test_flag_one", minimization = AUTHENTICATED)
+          FLAG_ONE,
+          @FeatureFlag(defaultValue = false, minimization = AUTHENTICATED)
+          FLAG_TWO,
+          @FeatureFlag(defaultValue = false, minimization = AUTHENTICATED)
+          FLAG_THREE,
+        }
+    """
+
+  protected fun createKotlinFile(
+    name: String,
+    text: String,
+  ): PsiFile {
+    return myFixture.configureByText(name, text)
+  }
+}