feat: syntax and formatting for literal types

.gitignore

@@ -13,6 +13,7 @@ coverage/
 dist/
 dist-ssr/
 out/
+DSL/syntaxes/safe-ds.tmLanguage.json
 
 # Node
 .npm/

DSL/src/language-server/formatting/safe-ds-formatter.ts

@@ -1,7 +1,7 @@
 import { AbstractFormatter, AstNode, CstNode, findCommentNode, Formatting, isAstNode } from 'langium';
 import * as ast from '../generated/ast';
 import { SdsImport, SdsImportAlias, SdsModule } from '../generated/ast';
-import { annotationCallsOrEmpty, typeArgumentsOrEmpty } from '../helpers/astShortcuts';
+import { annotationCallsOrEmpty, literalsOrEmpty, typeArgumentsOrEmpty } from '../helpers/astShortcuts';
 import { FormattingAction, FormattingActionOptions } from 'langium/src/lsp/formatter';
 import noSpace = Formatting.noSpace;
 import newLine = Formatting.newLine;
@@ -149,6 +149,10 @@ export class SafeDSFormatter extends AbstractFormatter {
             this.formatSdsMemberType(node);
         } else if (ast.isSdsCallableType(node)) {
             this.formatSdsCallableType(node);
+        } else if (ast.isSdsLiteralType(node)) {
+            this.formatSdsLiteralType(node);
+        } else if (ast.isSdsLiteralList(node)) {
+            this.formatSdsLiteralList(node);
         } else if (ast.isSdsNamedType(node)) {
             this.formatSdsNamedType(node);
         } else if (ast.isSdsUnionType(node)) {
@@ -761,6 +765,25 @@ export class SafeDSFormatter extends AbstractFormatter {
         formatter.keyword('->').surround(oneSpace());
     }
 
+    private formatSdsLiteralType(node: ast.SdsLiteralType): void {
+        const formatter = this.getNodeFormatter(node);
+
+        formatter.keyword('literal').append(noSpace());
+    }
+
+    private formatSdsLiteralList(node: ast.SdsLiteralList): void {
+        const formatter = this.getNodeFormatter(node);
+        const literals = node.literals ?? [];
+
+        if (literals.length > 0) {
+            formatter.node(literals[0]).prepend(noSpace());
+            formatter.nodes(...literals.slice(1)).prepend(oneSpace());
+        }
+
+        formatter.keywords(',').prepend(noSpace());
+        formatter.keyword('>').prepend(noSpace());
+    }
+
     private formatSdsNamedType(node: ast.SdsNamedType) {
         const formatter = this.getNodeFormatter(node);
 
@@ -847,10 +870,12 @@ export class SafeDSFormatter extends AbstractFormatter {
 
         if (ast.isSdsCallableType(node) || ast.isSdsMemberType(node)) {
             return true;
-        } else if (ast.isSdsUnionType(node)) {
-            return typeArgumentsOrEmpty(node.typeArgumentList).length > 0;
+        } else if (ast.isSdsLiteralType(node)) {
+            return literalsOrEmpty(node).length > 0;
         } else if (ast.isSdsNamedType(node)) {
             return typeArgumentsOrEmpty(node.typeArgumentList).length > 0;
+        } else if (ast.isSdsUnionType(node)) {
+            return typeArgumentsOrEmpty(node.typeArgumentList).length > 0;
         } else {
             return false;
         }

DSL/src/language-server/grammar/safe-ds.langium

@@ -841,6 +841,7 @@ SdsType returns SdsType:
 
 SdsPrimaryType returns SdsType:
     SdsCallableType
+  | SdsLiteralType
   | SdsNamedType
   | SdsUnionType
 ;
@@ -854,6 +855,29 @@ SdsCallableType returns SdsCallableType:
     resultList=SdsResultList
 ;
 
+interface SdsLiteralType extends SdsType {
+	literalList: SdsLiteralList
+}
+
+SdsLiteralType returns SdsLiteralType:
+    'literal' literalList=SdsLiteralList
+;
+
+interface SdsLiteralList extends SdsObject {
+    literals: SdsLiteral[]
+}
+
+SdsLiteralList returns SdsLiteralList:
+    {SdsLiteralList}
+    (LESS_THAN | CALL_TYPE_ARGUMENT_LIST_START)
+    (
+        literals+=SdsLiteral
+        (',' literals+=SdsLiteral)*
+        ','?
+    )?
+    '>'
+;
+
 interface SdsNamedType extends SdsType {
 	declaration: @SdsNamedTypeDeclaration
 	typeArgumentList?: SdsTypeArgumentList
@@ -1038,6 +1062,7 @@ terminal CALL_TYPE_ARGUMENT_LIST_START:
         (   '*'                                 // Star projection as positional type argument
         |   'in'                                // Contravariant type projection as positional type argument
         |   'out'                               // Covariant type projection as positional type argument
+        |   'literal'                           // Invariant literal type as positional type argument
         |   'union'                             // Invariant union type as positional type argument
         |   '>'                                 // Empty type argument list
         |    ID /\s*/

DSL/src/language-server/helpers/astShortcuts.ts

@@ -3,8 +3,8 @@ import {
     isSdsDeclaration,
     SdsAnnotatedObject,
     SdsAnnotationCall,
-    SdsClass,
-    SdsObject,
+    SdsLiteral,
+    SdsLiteralType,
     SdsTypeArgument,
     SdsTypeArgumentList,
 } from '../generated/ast';
@@ -17,8 +17,8 @@ export const annotationCallsOrEmpty = function (node: SdsAnnotatedObject): SdsAn
     }
 };
 
-export const classMembersOrEmpty = function (node: SdsClass): SdsObject[] {
-    return node.body?.members ?? [];
+export const literalsOrEmpty = function (node: SdsLiteralType | undefined): SdsLiteral[] {
+    return node?.literalList?.literals ?? [];
 };
 
 export const typeArgumentsOrEmpty = function (node: SdsTypeArgumentList | undefined): SdsTypeArgument[] {

DSL/tests/resources/formatting/trailing commas/literal list of literal type.sdstest

@@ -0,0 +1,9 @@
+segment s(
+    f: literal<1.0 ,  null ,  >
+) {}
+
+// -----------------------------------------------------------------------------
+
+segment s(
+    f: literal<1.0, null,>
+) {}

DSL/tests/resources/formatting/types/literal types/empty.sdstest

@@ -0,0 +1,5 @@
+segment mySegment(x: literal < >) {}
+
+// -----------------------------------------------------------------------------
+
+segment mySegment(x: literal<>) {}

DSL/tests/resources/formatting/types/literal types/with literals.sdstest

@@ -0,0 +1,9 @@
+segment mySegment(
+    x: literal < 1.0 ,  null >
+) {}
+
+// -----------------------------------------------------------------------------
+
+segment mySegment(
+    x: literal<1.0, null>
+) {}

DSL/tests/resources/formatting/types/member types/receiver (literal) and member (not nullable).sdstest

@@ -0,0 +1,9 @@
+segment mySegment(
+    x: literal < > . InnerClass
+) {}
+
+// -----------------------------------------------------------------------------
+
+segment mySegment(
+    x: literal<>.InnerClass
+) {}

DSL/tests/resources/formatting/types/member types/receiver (literal) and member (nullable).sdstest

@@ -0,0 +1,9 @@
+segment mySegment(
+    x: literal < > . InnerClass ?
+) {}
+
+// -----------------------------------------------------------------------------
+
+segment mySegment(
+    x: literal<>.InnerClass?
+) {}

DSL/tests/resources/grammar/keywords as names/bad-unescaped literal.sdstest

@@ -0,0 +1,3 @@
+// $TEST$ syntax_error
+
+class literal

DSL/tests/resources/grammar/trailing commas/good-literal list of literal type.sdstest

@@ -0,0 +1,5 @@
+// $TEST$ no_syntax_error
+
+segment s(
+    f: literal<true, false, >
+) {}

DSL/tests/resources/grammar/types/literal types/bad-nested.sdstest

@@ -0,0 +1,5 @@
+// $TEST$ syntax_error
+
+segment mySegment(
+    x: literal<literal<>>
+) {}

DSL/tests/resources/grammar/types/literal types/bad-unclosed angle bracket.sdstest

@@ -0,0 +1,5 @@
+// $TEST$ syntax_error
+
+segment mySegment(
+    x: literal<
+) {}

DSL/tests/resources/grammar/types/literal types/good-empty.sdstest

@@ -0,0 +1,5 @@
+// $TEST$ no_syntax_error
+
+segment mySegment(
+    x: literal<>
+) {}

DSL/tests/resources/grammar/types/literal types/good-with literals.sdstest

@@ -0,0 +1,5 @@
+// $TEST$ no_syntax_error
+
+segment mySegment(
+    x: literal<null, true, false, 1, 1.0, "s">
+) {}

DSL/tests/resources/grammar/types/member types/bad-literal type as member.sdstest

@@ -0,0 +1,5 @@
+// $TEST$ syntax_error
+
+segment mySegment(
+    x: OuterClass.literal<>
+) {}

DSL/tests/resources/grammar/types/member types/good-receiver (literal) and member (not nullable).sdstest

@@ -0,0 +1,5 @@
+// $TEST$ no_syntax_error
+
+segment mySegment(
+    x: literal<>.InnerClass
+) {}

DSL/tests/resources/grammar/types/member types/good-receiver (literal) and member (nullable).sdstest

@@ -0,0 +1,5 @@
+// $TEST$ no_syntax_error
+
+segment mySegment(
+    x: literal<>.InnerClass?
+) {}

DSL/vitest.config.ts

@@ -10,5 +10,6 @@ export default defineConfig({
             include: ['src'],
             exclude: ['**/generated'],
         },
+        exclude: ['out'],
     },
 });