Allow Map keys to be a typealias of String

.github/workflows/publish-release.yml

@@ -23,12 +23,8 @@ jobs:
 
       - name: Rename cli-shadow to cli
         run: |
-          mv cli/build/distributions/cli-shadow-*.zip cli/build/distributions/cli.zip
-          mv cli/build/distributions/cli-shadow-*.tar cli/build/distributions/cli.tar
-
-      - name: Rename samt-ls-version to samt-ls
-        run: |
-          mv language-server/build/libs/samt-ls-*.jar language-server/build/libs/samt-ls.jar
+          mv cli/build/distributions/cli-shadow.zip cli/build/distributions/cli.zip
+          mv cli/build/distributions/cli-shadow.tar cli/build/distributions/cli.tar
 
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v1

cli/build.gradle.kts

@@ -30,8 +30,15 @@ tasks {
     shadowJar {
         archiveBaseName.set("samt-cli")
         archiveClassifier.set("")
+        archiveVersion.set("")
         manifest {
             attributes("Main-Class" to "tools.samt.cli.AppKt")
         }
     }
+    shadowDistTar {
+        archiveVersion.set("")
+    }
+    shadowDistZip{
+        archiveVersion.set("")
+    }
 }

compiler/src/main/kotlin/tools/samt/semantic/SemanticModelPostProcessor.kt

@@ -57,6 +57,17 @@ internal class SemanticModelPostProcessor(private val controller: DiagnosticCont
             is MapType -> {
                 checkModelType(type.keyType)
                 checkModelType(type.valueType)
+
+                val keyType = type.keyType as ResolvedTypeReference
+                // error if keyType does not refer to string type
+                // serializing non-string types as keys is currently not supported,
+                // but types like integers or enums might be supported in the future
+                if (keyType.type.let { it != StringType && !(it is AliasType && it.fullyResolvedType?.type == StringType) }) {
+                    keyType.typeNode.reportError(controller) {
+                        message("Map key type must be String")
+                        highlight("expected String", keyType.typeNode.location)
+                    }
+                }
             }
 
             is AliasType -> {

compiler/src/main/kotlin/tools/samt/semantic/SemanticModelReferenceResolver.kt

@@ -129,25 +129,15 @@ internal class SemanticModelReferenceResolver(
                             val keyType = resolveAndLinkExpression(scope, keyTypeNode)
                             val valueType = resolveAndLinkExpression(scope, valueTypeNode)
 
-                            // error if keyType does not refer to string type
-                            // serializing non-string types as keys is currently not supported,
-                            // but types like integers or enums might be supported in the future
-                            if (keyType.type != StringType) {
-                                keyTypeNode.reportError(controller) {
-                                    message("Map key type must be String")
-                                    highlight("expected String", keyTypeNode.location)
-                                }
-                            } else {
-                                return ResolvedTypeReference(
-                                    type = MapType(
-                                        keyType = keyType,
-                                        valueType = valueType,
-                                        node = expression,
-                                    ),
-                                    typeNode = expression.base,
-                                    fullNode = expression,
-                                )
-                            }
+                            return ResolvedTypeReference(
+                                type = MapType(
+                                    keyType = keyType,
+                                    valueType = valueType,
+                                    node = expression,
+                                ),
+                                typeNode = expression.base,
+                                fullNode = expression,
+                            )
                         } else {
                             expression.reportError(controller) {
                                 message("Map must have exactly two type arguments")

compiler/src/test/kotlin/tools/samt/semantic/SemanticModelTest.kt

@@ -493,6 +493,21 @@ class SemanticModelTest {
                 )
             )
         }
+
+        @Test
+        fun `can use typealiases of String as keys in maps`() {
+            val source = """
+                package foo
+
+                typealias StringAlias = String
+                typealias StringAliasAlias = StringAlias
+
+                record Foo {
+                    arg: Map<StringAliasAlias, String>
+                }
+            """.trimIndent()
+            parseAndCheck(source to emptyList())
+        }
     }
 
     @Nested

language-server/build.gradle.kts

@@ -22,6 +22,7 @@ tasks {
     shadowJar {
         archiveBaseName.set("samt-ls")
         archiveClassifier.set("")
+        archiveVersion.set("")
         manifest {
             attributes("Main-Class" to "tools.samt.ls.AppKt")
         }