feat: const modifier to replace @Constant annotation

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

@@ -9,12 +9,13 @@ import {
     isAstNode,
 } from 'langium';
 import * as ast from '../generated/ast.js';
+import { annotationCallsOrEmpty, literalsOrEmpty, typeArgumentsOrEmpty } from '../helpers/nodeProperties.js';
+import { last } from 'radash';
 import noSpace = Formatting.noSpace;
 import newLine = Formatting.newLine;
 import newLines = Formatting.newLines;
 import oneSpace = Formatting.oneSpace;
 import indent = Formatting.indent;
-import { annotationCallsOrEmpty, literalsOrEmpty, typeArgumentsOrEmpty } from '../helpers/nodeProperties.js';
 
 const newLinesWithIndent = function (count: number, options?: FormattingActionOptions): FormattingAction {
     return {
@@ -549,14 +550,13 @@ export class SafeDsFormatter extends AbstractFormatter {
     private formatSdsParameter(node: ast.SdsParameter): void {
         const formatter = this.getNodeFormatter(node);
 
-        if (annotationCallsOrEmpty(node).length === 0) {
-            if (node.isVariadic) {
-                formatter.property('name').prepend(oneSpace());
-            }
-        } else {
-            formatter.property('name').prepend(newLine());
+        const lastAnnotationCall = last(annotationCallsOrEmpty(node));
+        if (lastAnnotationCall) {
+            formatter.node(lastAnnotationCall).append(newLine());
         }
 
+        formatter.keyword('const').append(oneSpace());
+        formatter.keyword('vararg').append(oneSpace());
         formatter.keyword(':').prepend(noSpace()).append(oneSpace());
         formatter.keyword('=').surround(oneSpace());
     }

src/language/grammar/safe-ds.langium

@@ -416,14 +416,15 @@ SdsParameterList returns SdsParameterList:
 ;
 
 interface SdsParameter extends SdsLocalVariable {
+    isConstant: boolean
     isVariadic: boolean
     ^type?: SdsType
     defaultValue?: SdsExpression
 }
 
 SdsParameter returns SdsParameter:
     annotationCalls+=SdsAnnotationCall*
-    isVariadic?='vararg'?
+    (isConstant?='const' & isVariadic?='vararg')
     name=ID
     (':' ^type=SdsType)?
     ('=' defaultValue=SdsExpression)?

src/language/validation/other/declarations/annotations.ts

@@ -0,0 +1,17 @@
+import { SdsAnnotation } from '../../../generated/ast.js';
+import { ValidationAcceptor } from 'langium';
+import { parametersOrEmpty } from '../../../helpers/nodeProperties.js';
+
+export const CODE_ANNOTATION_PARAMETER_CONST_MODIFIER = 'annotation/parameter-const-modifier';
+
+export const annotationParameterShouldNotHaveConstModifier = (node: SdsAnnotation, accept: ValidationAcceptor) => {
+    for (const parameter of parametersOrEmpty(node)) {
+        if (parameter.isConstant) {
+            accept('info', 'Parameters of annotations implicitly have the const modifier.', {
+                node: parameter,
+                property: 'name',
+                code: CODE_ANNOTATION_PARAMETER_CONST_MODIFIER,
+            });
+        }
+    }
+};

src/language/validation/other/expressions/lambdas.ts

@@ -0,0 +1,17 @@
+import { SdsLambda } from '../../../generated/ast.js';
+import { ValidationAcceptor } from 'langium';
+import { parametersOrEmpty } from '../../../helpers/nodeProperties.js';
+
+export const CODE_LAMBDA_CONST_MODIFIER = 'lambda/const-modifier';
+
+export const lambdaParameterMustNotHaveConstModifier = (node: SdsLambda, accept: ValidationAcceptor): void => {
+    for (const parameter of parametersOrEmpty(node)) {
+        if (parameter.isConstant) {
+            accept('error', 'The const modifier is not applicable to parameters of lambdas.', {
+                node: parameter,
+                property: 'name',
+                code: CODE_LAMBDA_CONST_MODIFIER,
+            });
+        }
+    }
+};

src/language/validation/other/types/callableTypes.ts

@@ -3,8 +3,24 @@ import { ValidationAcceptor } from 'langium';
 
 import { parametersOrEmpty } from '../../../helpers/nodeProperties.js';
 
+export const CODE_CALLABLE_TYPE_CONST_MODIFIER = 'callable-type/const-modifier';
 export const CODE_CALLABLE_TYPE_NO_OPTIONAL_PARAMETERS = 'callable-type/no-optional-parameters';
 
+export const callableTypeParameterMustNotHaveConstModifier = (
+    node: SdsCallableType,
+    accept: ValidationAcceptor,
+): void => {
+    for (const parameter of parametersOrEmpty(node)) {
+        if (parameter.isConstant) {
+            accept('error', 'The const modifier is not applicable to parameters of callable types.', {
+                node: parameter,
+                property: 'name',
+                code: CODE_CALLABLE_TYPE_CONST_MODIFIER,
+            });
+        }
+    }
+};
+
 export const callableTypeMustNotHaveOptionalParameters = (node: SdsCallableType, accept: ValidationAcceptor): void => {
     for (const parameter of parametersOrEmpty(node)) {
         if (parameter.defaultValue && !parameter.isVariadic) {

src/language/validation/safe-ds-validator.ts

@@ -42,7 +42,10 @@ import {
     parameterListVariadicParameterMustBeLast,
 } from './other/declarations/parameterLists.js';
 import { unionTypeMustHaveTypeArguments } from './other/types/unionTypes.js';
-import { callableTypeMustNotHaveOptionalParameters } from './other/types/callableTypes.js';
+import {
+    callableTypeMustNotHaveOptionalParameters,
+    callableTypeParameterMustNotHaveConstModifier,
+} from './other/types/callableTypes.js';
 import { typeArgumentListMustNotHavePositionalArgumentsAfterNamedArguments } from './other/types/typeArgumentLists.js';
 import { argumentListMustNotHavePositionalArgumentsAfterNamedArguments } from './other/argumentLists.js';
 import { parameterMustNotBeVariadicAndOptional } from './other/declarations/parameters.js';
@@ -63,6 +66,8 @@ import {
 } from './builtins/experimental.js';
 import { placeholderShouldBeUsed } from './other/declarations/placeholders.js';
 import { segmentParameterShouldBeUsed, segmentResultMustBeAssignedExactlyOnce } from './other/declarations/segments.js';
+import { annotationParameterShouldNotHaveConstModifier } from './other/declarations/annotations.js';
+import { lambdaParameterMustNotHaveConstModifier } from './other/expressions/lambdas.js';
 
 /**
  * Register custom validation checks.
@@ -75,7 +80,11 @@ export const registerValidationChecks = function (services: SafeDsServices) {
             assigneeAssignedResultShouldNotBeExperimental(services),
         ],
         SdsAssignment: [assignmentShouldHaveMoreThanWildcardsAsAssignees],
-        SdsAnnotation: [annotationMustContainUniqueNames, annotationParameterListShouldNotBeEmpty],
+        SdsAnnotation: [
+            annotationMustContainUniqueNames,
+            annotationParameterListShouldNotBeEmpty,
+            annotationParameterShouldNotHaveConstModifier,
+        ],
         SdsAnnotationCall: [
             annotationCallAnnotationShouldNotBeDeprecated(services),
             annotationCallAnnotationShouldNotBeExperimental(services),
@@ -89,7 +98,11 @@ export const registerValidationChecks = function (services: SafeDsServices) {
         SdsAttribute: [attributeMustHaveTypeHint],
         SdsBlockLambda: [blockLambdaMustContainUniqueNames],
         SdsCall: [callArgumentListShouldBeNeeded(services)],
-        SdsCallableType: [callableTypeMustContainUniqueNames, callableTypeMustNotHaveOptionalParameters],
+        SdsCallableType: [
+            callableTypeMustContainUniqueNames,
+            callableTypeMustNotHaveOptionalParameters,
+            callableTypeParameterMustNotHaveConstModifier,
+        ],
         SdsClass: [classMustContainUniqueNames],
         SdsClassBody: [classBodyShouldNotBeEmpty],
         SdsConstraintList: [constraintListShouldNotBeEmpty],
@@ -99,6 +112,7 @@ export const registerValidationChecks = function (services: SafeDsServices) {
         SdsEnumVariant: [enumVariantMustContainUniqueNames, enumVariantParameterListShouldNotBeEmpty],
         SdsExpressionLambda: [expressionLambdaMustContainUniqueNames],
         SdsFunction: [functionMustContainUniqueNames, functionResultListShouldNotBeEmpty],
+        SdsLambda: [lambdaParameterMustNotHaveConstModifier],
         SdsMemberAccess: [memberAccessNullSafetyShouldBeNeeded(services)],
         SdsModule: [moduleDeclarationsMustMatchFileKind, moduleWithDeclarationsMustStatePackage],
         SdsNamedType: [

src/resources/builtins/safeds/lang/coreAnnotations.sdsstub

@@ -97,7 +97,3 @@ annotation Pure
 @Description("The function has no side effects.")
 @Target(AnnotationTarget.Function)
 annotation NoSideEffects
-
-@Description("Values assigned to this parameter must be constant.")
-@Target(AnnotationTarget.Parameter)
-annotation Constant

tests/language/formatting/creator.ts

@@ -44,6 +44,7 @@ const createFormattingTest = async (uri: URI): Promise<FormattingTest> => {
         testName: `[${shortenedResourceName}] should be formatted correctly`,
         originalCode,
         expectedFormattedCode,
+        uri,
     };
 };
 
@@ -59,6 +60,7 @@ const invalidTest = (uri: URI, error: Error): FormattingTest => {
         testName: `INVALID TEST FILE [${shortenedResourceName}]`,
         originalCode: '',
         expectedFormattedCode: '',
+        uri: URI.file(''),
         error,
     };
 };
@@ -86,6 +88,11 @@ interface FormattingTest extends TestDescription {
      * The expected formatted code.
      */
     expectedFormattedCode: string;
+
+    /**
+     * The URI of the corresponding file.
+     */
+    uri: URI;
 }
 
 /**

tests/language/grammar/creator.ts

@@ -44,6 +44,7 @@ const createGrammarTest = (uri: URI): GrammarTest => {
         testName,
         code,
         expectedResult: comment,
+        uri,
     };
 };
 
@@ -59,6 +60,7 @@ const invalidTest = (uri: URI, error: Error): GrammarTest => {
         testName: `INVALID TEST FILE [${shortenedResourceName}]`,
         code: '',
         expectedResult: 'invalid',
+        uri: URI.file(''),
         error,
     };
 };
@@ -76,6 +78,11 @@ interface GrammarTest extends TestDescription {
      * The expected result after parsing the program.
      */
     expectedResult: 'syntax_error' | 'no_syntax_error' | 'invalid';
+
+    /**
+     * The URI of the corresponding file.
+     */
+    uri: URI;
 }
 
 /**

tests/language/grammar/testGrammar.test.ts

@@ -26,7 +26,7 @@ describe('grammar', () => {
         if (test.expectedResult === 'syntax_error') {
             if (actualSyntaxErrors.length === 0) {
                 throw new AssertionError({
-                    message: 'Expected syntax errors but found none.',
+                    message: `Expected syntax errors in ${test.uri} but found none.`,
                     actual: actualSyntaxErrors,
                     expected: [],
                 });
@@ -37,7 +37,7 @@ describe('grammar', () => {
         else if (test.expectedResult === 'no_syntax_error') {
             if (actualSyntaxErrors.length > 0) {
                 throw new AssertionError({
-                    message: 'Expected no syntax errors but found some.',
+                    message: `Expected no syntax errors in ${test.uri} but found some.`,
                     actual: actualSyntaxErrors,
                     expected: [],
                 });

tests/resources/formatting/declarations/annotations/multiple parameters.sdstest

@@ -1,33 +1,73 @@
 annotation  MyAnnotation (
 
-   @Annotation  a ,
+   @Annotation  a1 ,
 
-     b  =  0 ,
+     b1  =  0 ,
 
-   vararg  c ,
+   vararg  c1 ,
 
-     vararg  d :  Int  =  1 ,
+     vararg  d1 :  Int  =  1 ,
 
-   e :  Int ,
+   e1 :  Int ,
 
-     f :  Int  =  2 ,
+     f1 :  Int  =  2 ,
 
-   vararg  g :  Int ,
+   vararg  g1 :  Int ,
 
-     vararg  h :  Int  =  3
+     vararg  h1 :  Int  =  3 ,
 
+        @Annotation  const  a2 ,
+
+          const  b2  =  0 ,
+
+        const  vararg  c2 ,
+
+          const  vararg  d2 :  Int  =  1 ,
+
+        const  e2 :  Int ,
+
+          const  f2 :  Int  =  2 ,
+
+        const  vararg  g2 :  Int ,
+
+          const  vararg  h2 :  Int  =  3 ,
+
+@Annotation  vararg  const  a3 ,
+
+             vararg  const  c3 ,
+
+               vararg  const  d3 :  Int  =  1 ,
+
+             vararg  const  g3 :  Int ,
+
+               vararg  const  h3 :  Int  =  3
  )
 
 // -----------------------------------------------------------------------------
 
 annotation MyAnnotation(
     @Annotation
-    a,
-    b = 0,
-    vararg c,
-    vararg d: Int = 1,
-    e: Int,
-    f: Int = 2,
-    vararg g: Int,
-    vararg h: Int = 3
+    a1,
+    b1 = 0,
+    vararg c1,
+    vararg d1: Int = 1,
+    e1: Int,
+    f1: Int = 2,
+    vararg g1: Int,
+    vararg h1: Int = 3,
+    @Annotation
+    const a2,
+    const b2 = 0,
+    const vararg c2,
+    const vararg d2: Int = 1,
+    const e2: Int,
+    const f2: Int = 2,
+    const vararg g2: Int,
+    const vararg h2: Int = 3,
+    @Annotation
+    vararg const a3,
+    vararg const c3,
+    vararg const d3: Int = 1,
+    vararg const g3: Int,
+    vararg const h3: Int = 3
 )

tests/resources/formatting/declarations/annotations/with const typed optional parameter.sdstest

@@ -0,0 +1,5 @@
+annotation  MyAnnotation ( const  a :  Int  =  1 )
+
+// -----------------------------------------------------------------------------
+
+annotation MyAnnotation(const a: Int = 1)

tests/resources/formatting/declarations/annotations/with const typed required parameter.sdstest

@@ -0,0 +1,5 @@
+annotation  MyAnnotation ( const  a :  Int )
+
+// -----------------------------------------------------------------------------
+
+annotation MyAnnotation(const a: Int)

tests/resources/formatting/declarations/annotations/with const typed variadic parameter (with default value).sdstest

@@ -0,0 +1,9 @@
+annotation  MyAnnotation1 ( const  vararg  a :  Int  =  1 )
+
+annotation  MyAnnotation2 ( vararg  const  a :  Int  =  1 )
+
+// -----------------------------------------------------------------------------
+
+annotation MyAnnotation1(const vararg a: Int = 1)
+
+annotation MyAnnotation2(vararg const a: Int = 1)

tests/resources/formatting/declarations/annotations/with const typed variadic parameter.sdstest

@@ -0,0 +1,9 @@
+annotation  MyAnnotation1 ( const  vararg  a :  Int )
+
+annotation  MyAnnotation2 ( vararg  const  a :  Int )
+
+// -----------------------------------------------------------------------------
+
+annotation MyAnnotation1(const vararg a: Int)
+
+annotation MyAnnotation2(vararg const a: Int)

tests/resources/formatting/declarations/annotations/with const untyped optional parameter.sdstest

@@ -0,0 +1,5 @@
+annotation  MyAnnotation ( const  a  =  1 )
+
+// -----------------------------------------------------------------------------
+
+annotation MyAnnotation(const a = 1)

tests/resources/formatting/declarations/annotations/with const untyped required parameter.sdstest

@@ -0,0 +1,5 @@
+annotation  MyAnnotation ( const  a )
+
+// -----------------------------------------------------------------------------
+
+annotation MyAnnotation(const a)

tests/resources/formatting/declarations/annotations/with const untyped variadic parameter (with default value).sdstest

@@ -0,0 +1,9 @@
+annotation  MyAnnotation1 ( const  vararg  a  =  1 )
+
+annotation  MyAnnotation2 ( vararg  const  a  =  1 )
+
+// -----------------------------------------------------------------------------
+
+annotation MyAnnotation1(const vararg a = 1)
+
+annotation MyAnnotation2(vararg const a = 1)