fix: don't show this error for classes without constructor

Author: lars-reimann

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

@@ -1,46 +1,47 @@
-import { isSdsCallable, isSdsParameterList, isSdsUnionType, SdsTypeParameter } from '../../../generated/ast.js';
+import {
+    isSdsCallable,
+    isSdsClass,
+    isSdsParameterList,
+    isSdsUnionType,
+    SdsTypeParameter,
+} from '../../../generated/ast.js';
 import { findLocalReferences, getContainerOfType, hasContainerOfType, ValidationAcceptor } from 'langium';
-import { SafeDsServices } from '../../../safe-ds-module.js';
 
 export const CODE_TYPE_PARAMETER_INSUFFICIENT_CONTEXT = 'type-parameter/insufficient-context';
 
-export const typeParameterMustHaveSufficientContext = (services: SafeDsServices) => {
-    const builtinClasses = services.builtins.Classes;
+export const typeParameterMustHaveSufficientContext = (node: SdsTypeParameter, accept: ValidationAcceptor) => {
+    const containingCallable = getContainerOfType(node, isSdsCallable);
+    /* c8 ignore start */
+    if (!containingCallable) {
+        return;
+    }
+    /* c8 ignore stop */
 
-    return (node: SdsTypeParameter, accept: ValidationAcceptor) => {
-        const containingCallable = getContainerOfType(node, isSdsCallable);
-        /* c8 ignore start */
-        if (!containingCallable) {
-            return;
-        }
-        /* c8 ignore stop */
+    // Classes without constructor can only be used as named types, where type arguments are manifest
+    if (isSdsClass(containingCallable) && !containingCallable.parameterList) {
+        return;
+    }
 
-        // Lists and maps are created using literals
-        if (containingCallable === builtinClasses.List || containingCallable === builtinClasses.Map) {
-            return;
-        }
+    // A type parameter must be referenced in the parameter list of the containing callable...
+    let typeParameterHasInsufficientContext =
+        !containingCallable.parameterList ||
+        findLocalReferences(node, containingCallable.parameterList)
+            // ...but references in a union type or in the parameter list of a callable type don't count
+            .filter((reference) => {
+                const referenceNode = reference.$refNode?.astNode;
+                const containingParameterList = getContainerOfType(referenceNode, isSdsParameterList);
 
-        // A type parameter must be referenced in the parameter list of the containing callable...
-        let typeParameterHasInsufficientContext =
-            !containingCallable.parameterList ||
-            findLocalReferences(node, containingCallable.parameterList)
-                // ...but references in a union type or in the parameter list of a callable type don't count
-                .filter((reference) => {
-                    const referenceNode = reference.$refNode?.astNode;
-                    const containingParameterList = getContainerOfType(referenceNode, isSdsParameterList);
+                return (
+                    !hasContainerOfType(referenceNode, isSdsUnionType) &&
+                    containingParameterList === containingCallable.parameterList
+                );
+            })
+            .isEmpty();
 
-                    return (
-                        !hasContainerOfType(referenceNode, isSdsUnionType) &&
-                        containingParameterList === containingCallable.parameterList
-                    );
-                })
-                .isEmpty();
-
-        if (typeParameterHasInsufficientContext) {
-            accept('error', 'Insufficient context to infer this type parameter.', {
-                node,
-                code: CODE_TYPE_PARAMETER_INSUFFICIENT_CONTEXT,
-            });
-        }
-    };
+    if (typeParameterHasInsufficientContext) {
+        accept('error', 'Insufficient context to infer this type parameter.', {
+            node,
+            code: CODE_TYPE_PARAMETER_INSUFFICIENT_CONTEXT,
+        });
+    }
 };

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

@@ -284,7 +284,7 @@ export const registerValidationChecks = function (services: SafeDsServices) {
             segmentResultListShouldNotBeEmpty,
         ],
         SdsTemplateString: [templateStringMustHaveExpressionBetweenTwoStringParts],
-        SdsTypeParameter: [typeParameterMustHaveSufficientContext(services)],
+        SdsTypeParameter: [typeParameterMustHaveSufficientContext],
         SdsTypeParameterConstraint: [typeParameterConstraintLeftOperandMustBeOwnTypeParameter],
         SdsTypeParameterList: [typeParameterListShouldNotBeEmpty],
         SdsUnionType: [

tests/resources/validation/other/declarations/type parameters/insufficient context/main.sdstest

@@ -1,27 +1,29 @@
 package tests.validation.other.declarations.typeParameters.insufficientContext
 
-// $TEST$ error "Insufficient context to infer this type parameter."
+// $TEST$ no error "Insufficient context to infer this type parameter."
 class MyClass1<»T«>
 // $TEST$ error "Insufficient context to infer this type parameter."
-class MyClass2<»T«> {
+class MyClass2<»T«>()
+// $TEST$ error "Insufficient context to infer this type parameter."
+class MyClass3<»T«>() {
     attr myAttr: T
 }
 // $TEST$ no error "Insufficient context to infer this type parameter."
-class MyClass3<»T«>(param: T)
+class MyClass4<»T«>(param: T)
 // $TEST$ no error "Insufficient context to infer this type parameter."
-class MyClass4<»T«>(param: MyClass4<T>?)
+class MyClass5<»T«>(param: MyClass4<T>?)
 // $TEST$ no error "Insufficient context to infer this type parameter."
-class MyClass5<»T«>(param: MyEnum.MyEnumVariant1<T>)
+class MyClass6<»T«>(param: MyEnum.MyEnumVariant1<T>)
 // $TEST$ no error "Insufficient context to infer this type parameter."
-class MyClass6<»T«>(param: () -> (r: T))
+class MyClass7<»T«>(param: () -> (r: T))
 // $TEST$ error "Insufficient context to infer this type parameter."
-class MyClass7<»T«>(param: (p: T) -> ())
+class MyClass8<»T«>(param: (p: T) -> ())
 // $TEST$ error "Insufficient context to infer this type parameter."
-class MyClass8<»T«>(param: () -> (r: (p: T) -> ()))
+class MyClass9<»T«>(param: () -> (r: (p: T) -> ()))
 // $TEST$ error "Insufficient context to infer this type parameter."
-class MyClass9<»T«>(param: union<T>)
+class MyClass10<»T«>(param: union<T>)
 // $TEST$ error "Insufficient context to infer this type parameter."
-class MyClass10<»T«>(param: union<T, Int>)
+class MyClass11<»T«>(param: union<T, Int>)
 
 enum MyEnum {
     // $TEST$ error "Insufficient context to infer this type parameter."