CHANGELOG.md

@@ -3,6 +3,17 @@
 # Changelog
 
 ## Unreleased
+### Added
+- GML support
+  - Syntax highlighting
+  - Basic completion: navigate from a component to it's C++ definition
+  - A formatter which completely supports Serenity's GML styling
+  - Widget and property autocompletion
+  - Documentation on element hover for both widgets and properties
+  - Type linting
+
+## 1.1.0 - 2024-01-21
+
 ### Added
 
 - Support for IPC files

build.gradle.kts

@@ -10,6 +10,7 @@ fun environment(key: String) = providers.environmentVariable(key)
 plugins {
     idea
     alias(libs.plugins.kotlin)
+    alias(libs.plugins.kotlinSerialization)
     alias(libs.plugins.grammarkit)
     alias(libs.plugins.gradleIntelliJPlugin)
     alias(libs.plugins.changelog)
@@ -23,6 +24,9 @@ repositories {
 }
 
 dependencies {
+    implementation("org.jetbrains.kotlin:kotlin-stdlib")
+    implementation("org.jetbrains.kotlin:kotlin-reflect")
+    implementation(libs.kotlinSerialization)
 }
 
 intellij {
@@ -32,14 +36,6 @@ intellij {
     plugins = properties("platformPlugins").map { it.split(',').map(String::trim).filter(String::isNotEmpty) }
 }
 
-kotlin {
-    @Suppress("UnstableApiUsage")
-    jvmToolchain {
-        languageVersion = JavaLanguageVersion.of(17)
-        vendor = JvmVendorSpec.JETBRAINS
-    }
-}
-
 changelog {
     groups.empty()
     repositoryUrl = properties("pluginRepositoryUrl")
@@ -64,7 +60,7 @@ tasks {
     generateLexer.configure { enabled = false }
     generateParser.configure { enabled = false }
 
-    val supportedDSLs = listOf("IDL", "IPC")
+    val supportedDSLs = listOf("GML", "IDL", "IPC")
 
     for (dsl in supportedDSLs) {
         task<GenerateLexerTask>("generate${dsl}Lexer") {
@@ -103,6 +99,13 @@ tasks {
         gradleVersion = properties("gradleVersion").get()
     }
 
+    runIdeForUiTests {
+        systemProperty("robot-server.port", "8082")
+        systemProperty("ide.mac.message.dialogs.as.sheets", "false")
+        systemProperty("jb.privacy.policy.text", "<!--999.999-->")
+        systemProperty("jb.consents.confirmation.enabled", "false")
+    }
+
     patchPluginXml {
         version = properties("pluginVersion")
         sinceBuild = properties("pluginSinceBuild")
@@ -134,13 +137,6 @@ tasks {
         }
     }
 
-    runIdeForUiTests {
-        systemProperty("robot-server.port", "8082")
-        systemProperty("ide.mac.message.dialogs.as.sheets", "false")
-        systemProperty("jb.privacy.policy.text", "<!--999.999-->")
-        systemProperty("jb.consents.confirmation.enabled", "false")
-    }
-
     publishPlugin {
         dependsOn("patchChangelog")
         token = environment("PUBLISH_TOKEN")

gradle.properties

@@ -2,13 +2,13 @@ pluginGroup=me.mattco.serenityos
 pluginName=SerenityOS-DSL
 pluginVersion=1.1.0
 pluginSinceBuild=232
-pluginUntilBuild=233.2
+pluginUntilBuild=233.*
 platformType=CL
 platformVersion=2023.3.2
 # Plugin Dependencies -> https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html
 # Example: platformPlugins = com.intellij.java, com.jetbrains.php:203.4449.22
 platformPlugins=com.intellij.clion,com.intellij.cidr.lang,com.intellij.cidr.base
 javaVersion=17
-gradleVersion=8.4
+gradleVersion=8.5
 # The platform includes Kotlin, so we don't have to
 kotlin.stdlib.default.dependency=false

gradle/libs.versions.toml

@@ -6,13 +6,16 @@ annotations = "24.1.0"
 kotlin = "1.9.22"
 changelog = "2.2.0"
 gradleIntelliJPlugin = "1.17.0"
-grammarkit = "2022.3.2"
+grammarkit = "2022.3.2.1"
+kotlinxSerialization = "1.6.2"
 
 [libraries]
 annotations = { group = "org.jetbrains", name = "annotations", version.ref = "annotations" }
+kotlinSerialization = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerialization" }
 
 [plugins]
 changelog = { id = "org.jetbrains.changelog", version.ref = "changelog" }
 gradleIntelliJPlugin = { id = "org.jetbrains.intellij", version.ref = "gradleIntelliJPlugin" }
 kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 grammarkit = { id = "org.jetbrains.grammarkit", version.ref = "grammarkit" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/kotlin/me/mattco/serenityos/common/DSLAnnotator.kt

@@ -8,35 +8,36 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 
 abstract class DSLAnnotator : Annotator {
-    final override fun annotate(element: PsiElement, holder: AnnotationHolder) {
-        annotate(element, Holder(holder))
+    private lateinit var holder: AnnotationHolder
+
+    override fun annotate(element: PsiElement, holder: AnnotationHolder) {
+        this.holder = holder
+        annotate(element)
+    }
+
+    abstract fun annotate(element: PsiElement)
+
+    private fun newAnnotation(severity: HighlightSeverity, message: String? = null) = if (message == null) {
+        holder.newSilentAnnotation(severity)
+    } else holder.newAnnotation(severity, message)
+
+    fun PsiElement.highlight(attribute: TextAttributesKey) {
+        newAnnotation(HighlightSeverity.INFORMATION)
+            .range(this)
+            .textAttributes(attribute)
+            .create()
+    }
+
+    fun TextRange.highlight(attribute: TextAttributesKey) {
+        newAnnotation(HighlightSeverity.INFORMATION)
+            .range(this)
+            .textAttributes(attribute)
+            .create()
     }
 
-    protected abstract fun annotate(element: PsiElement, holder: Holder)
-
-    data class Holder(private val holder: AnnotationHolder) {
-        fun newAnnotation(severity: HighlightSeverity, message: String? = null) = if (message == null) {
-            holder.newSilentAnnotation(severity)
-        } else holder.newAnnotation(severity, message)
-
-        fun PsiElement.highlight(attribute: TextAttributesKey) {
-            newAnnotation(HighlightSeverity.INFORMATION)
-                .range(this)
-                .textAttributes(attribute)
-                .create()
-        }
-
-        fun TextRange.highlight(attribute: TextAttributesKey) {
-            newAnnotation(HighlightSeverity.INFORMATION)
-                .range(this)
-                .textAttributes(attribute)
-                .create()
-        }
-
-        fun PsiElement.highlightError(message: String) {
-            newAnnotation(HighlightSeverity.ERROR, message)
-                .range(this)
-                .create()
-        }
+    fun PsiElement.highlightError(message: String) {
+        newAnnotation(HighlightSeverity.ERROR, message)
+            .range(this)
+            .create()
     }
 }

src/main/kotlin/me/mattco/serenityos/common/DSLColorSettingsPage.kt

@@ -28,7 +28,7 @@ abstract class DSLColorSettingsPage(private val language: Language) : ColorSetti
 
     override fun getColorDescriptors(): Array<ColorDescriptor> = ColorDescriptor.EMPTY_ARRAY
 
-    override fun getDisplayName() = IPCLanguage.displayName
+    override fun getDisplayName() = language.displayName
 
     override fun getAttributeDescriptors() =
         getAttributes().map { AttributesDescriptor(it.key, it.value) }.toTypedArray()

src/main/kotlin/me/mattco/serenityos/idl/IDLCommenter.kt → src/main/kotlin/me/mattco/serenityos/common/DSLCommenter.kt

@@ -1,8 +1,8 @@
-package me.mattco.serenityos.idl
+package me.mattco.serenityos.common
 
 import com.intellij.lang.Commenter
 
-class IDLCommenter : Commenter {
+class DSLCommenter : Commenter {
     override fun getLineCommentPrefix() = "// "
 
     override fun getBlockCommentPrefix() = null

src/main/kotlin/me/mattco/serenityos/common/DSLTreeChangeListener.kt

@@ -0,0 +1,43 @@
+package me.mattco.serenityos.common
+
+import com.intellij.psi.PsiTreeChangeEvent
+import com.intellij.psi.PsiTreeChangeListener
+
+// Allows implementers to only override the functions they care about
+abstract class DSLTreeChangeListener : PsiTreeChangeListener {
+    override fun beforeChildAddition(event: PsiTreeChangeEvent) {
+    }
+
+    override fun beforeChildRemoval(event: PsiTreeChangeEvent) {
+    }
+
+    override fun beforeChildReplacement(event: PsiTreeChangeEvent) {
+    }
+
+    override fun beforeChildMovement(event: PsiTreeChangeEvent) {
+    }
+
+    override fun beforeChildrenChange(event: PsiTreeChangeEvent) {
+    }
+
+    override fun beforePropertyChange(event: PsiTreeChangeEvent) {
+    }
+
+    override fun childAdded(event: PsiTreeChangeEvent) {
+    }
+
+    override fun childRemoved(event: PsiTreeChangeEvent) {
+    }
+
+    override fun childReplaced(event: PsiTreeChangeEvent) {
+    }
+
+    override fun childrenChanged(event: PsiTreeChangeEvent) {
+    }
+
+    override fun childMoved(event: PsiTreeChangeEvent) {
+    }
+
+    override fun propertyChanged(event: PsiTreeChangeEvent) {
+    }
+}

src/main/kotlin/me/mattco/serenityos/common/completions.kt

@@ -0,0 +1,16 @@
+package me.mattco.serenityos.common
+
+import com.intellij.openapi.util.Key
+import com.intellij.patterns.*
+import com.intellij.psi.PsiElement
+import com.intellij.psi.tree.IElementType
+import com.intellij.util.ProcessingContext
+
+typealias PsiPattern = ElementPattern<out PsiElement>
+
+fun psiElement(type: IElementType): PsiElementPattern.Capture<PsiElement> = PlatformPatterns.psiElement(type)
+
+inline fun <reified T : PsiElement> psiElement(): PsiElementPattern.Capture<T> =
+    PlatformPatterns.psiElement(T::class.java)
+
+inline operator fun <reified T> ProcessingContext.set(key: Key<T>, value: T) = this.put(key, value)

src/main/kotlin/me/mattco/serenityos/common/formatting/SpacingBuilder.kt

@@ -0,0 +1,83 @@
+package me.mattco.serenityos.common.formatting
+
+import com.intellij.formatting.ASTBlock
+import com.intellij.formatting.Block
+import com.intellij.formatting.Spacing
+import com.intellij.formatting.SpacingBuilder
+import com.intellij.psi.codeStyle.CommonCodeStyleSettings
+import com.intellij.psi.tree.IElementType
+import com.intellij.psi.tree.TokenSet
+
+interface Builder {
+    fun getSpacing(parent: ASTBlock?, left: ASTBlock?, right: ASTBlock?): Spacing?
+}
+
+// Heavily inspired by the Kotlin plugin's SpacingBuilder system
+class SpacingBuilder(private val settings: CommonCodeStyleSettings) : Builder {
+    private val builders = mutableListOf<Builder>()
+
+    fun simple(block: SpacingBuilder.() -> Unit) {
+        builders.add(SimpleBuilder(settings).apply(block))
+    }
+
+    fun contextual(
+        parent: IElementType? = null,
+        left: IElementType? = null,
+        right: IElementType? = null,
+        parents: TokenSet = parent?.let { tokenSetOf(it) } ?: tokenSetOf(),
+        lefts: TokenSet = left?.let { tokenSetOf(it) } ?: tokenSetOf(),
+        rights: TokenSet = right?.let { tokenSetOf(it) } ?: tokenSetOf(),
+        rule: (ASTBlock?, ASTBlock?, ASTBlock?) -> Spacing?,
+    ) {
+        builders.add(ContextualBuilder(parents, lefts, rights, rule))
+    }
+
+    fun getSpacing(parent: Block?, left: Block?, right: Block?): Spacing? {
+        if (parent !is ASTBlock || left !is ASTBlock || right !is ASTBlock)
+            return null
+        return getSpacing(parent, left, right)
+    }
+
+    override fun getSpacing(parent: ASTBlock?, left: ASTBlock?, right: ASTBlock?): Spacing? {
+        for (builder in builders)
+            builder.getSpacing(parent, left, right)?.let { return it }
+        return null
+    }
+
+    fun makeSpacing(
+        minSpaces: Int = 1,
+        maxSpaces: Int = 1,
+        minLineFeeds: Int = 0,
+        keepLineBreaks: Boolean = true,
+        keepBlankLines: Int = 1,
+    ): Spacing = Spacing.createSpacing(minSpaces, maxSpaces, minLineFeeds, keepLineBreaks, keepBlankLines)
+
+    class SimpleBuilder(settings: CommonCodeStyleSettings) : SpacingBuilder(settings), Builder {
+        override fun getSpacing(parent: ASTBlock?, left: ASTBlock?, right: ASTBlock?): Spacing? {
+            return super.getSpacing(parent, left, right)
+        }
+    }
+
+    class ContextualBuilder(
+        private val parents: TokenSet,
+        private val lefts: TokenSet,
+        private val rights: TokenSet,
+        private val rule: (ASTBlock?, ASTBlock?, ASTBlock?) -> Spacing?,
+    ) : Builder {
+        override fun getSpacing(parent: ASTBlock?, left: ASTBlock?, right: ASTBlock?): Spacing? {
+            if (parents.match(parent) && lefts.match(left) && rights.match(right))
+                return rule(parent, left, right)
+            return null
+        }
+
+        companion object {
+            fun TokenSet.match(block: ASTBlock?) =
+                block == null || types.isEmpty() || this.contains(block.elementType)
+        }
+    }
+}
+
+val ASTBlock.elementType: IElementType
+    get() = this.node!!.elementType
+
+fun tokenSetOf(vararg types: IElementType?) = TokenSet.create(*types.filterNotNull().toTypedArray())

src/main/kotlin/me/mattco/serenityos/common/projectUtils.kt

@@ -0,0 +1,12 @@
+package me.mattco.serenityos.common
+
+import com.intellij.openapi.project.BaseProjectDirectories.Companion.getBaseDirectories
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+
+// TODO: Dependent on folder name?
+val Project.isSerenity: Boolean
+    get() = name == "SerenityOS"
+
+val Project.userlandDirectory: VirtualFile?
+    get() = getBaseDirectories().singleOrNull()?.findChild("Userland")