feat: error if type parameters don't have sufficient context (#687)

lars-reimann · web-flow · commit ea8fe29c87ee · 2023-10-24T11:17:04.000+02:00
### Summary of Changes

Show an error if we already know at the declaration-site that we won't
be able to infer type parameters in a call. A type parameter must occur
in the parameter list of the containing callable. However, it does not
suffice if they appear inside a union type or the parameter list of a
callable type.
diff --git a/src/cli/generator.ts b/src/cli/generator.ts
@@ -528,7 +528,7 @@ const getExternalReferenceNeededImport = function (
         if (isSdsQualifiedImport(value)) {
             const importedDeclarations = getImportedDeclarations(value);
             for (const importedDeclaration of importedDeclarations) {
-                if (declaration === importedDeclaration.declaration.ref) {
+                if (declaration === importedDeclaration.declaration?.ref) {
                     if (importedDeclaration.alias !== undefined) {
                         return {
                             importPath: services.builtins.Annotations.getPythonModule(targetModule) || value.package,
diff --git a/src/language/grammar/safe-ds.langium b/src/language/grammar/safe-ds.langium
@@ -77,7 +77,7 @@ SdsImportedDeclarationList returns SdsImportedDeclarationList:
 ;
 
 interface SdsImportedDeclaration extends SdsObject {
-    declaration: @SdsModuleMember;
+    declaration?: @SdsModuleMember;
     alias?: SdsImportedDeclarationAlias;
 }
 
@@ -384,7 +384,7 @@ SdsConstraint returns SdsConstraint:
 ;
 
 interface SdsTypeParameterConstraint extends SdsConstraint {
-    leftOperand: @SdsTypeParameter
+    leftOperand?: @SdsTypeParameter
     operator: string
     rightOperand: SdsType
 }
@@ -922,7 +922,7 @@ SdsLiteralList returns SdsLiteralList:
 ;
 
 interface SdsNamedType extends SdsType {
-    declaration: @SdsNamedTypeDeclaration
+    declaration?: @SdsNamedTypeDeclaration
     typeArgumentList?: SdsTypeArgumentList
     isNullable: boolean
 }
diff --git a/src/language/helpers/safe-ds-node-mapper.ts b/src/language/helpers/safe-ds-node-mapper.ts
@@ -239,7 +239,7 @@ export class SafeDsNodeMapper {
         }
 
         // Find type parameter at the same position
-        const namedTypeDeclaration = containingType.declaration.ref;
+        const namedTypeDeclaration = containingType.declaration?.ref;
         const typeParameters = getTypeParameters(namedTypeDeclaration);
         return typeParameters[typeArgumentPosition];
     }
diff --git a/src/language/lsp/safe-ds-semantic-token-provider.ts b/src/language/lsp/safe-ds-semantic-token-provider.ts
@@ -87,7 +87,7 @@ export class SafeDsSemanticTokenProvider extends AbstractSemanticTokenProvider {
                 type: SemanticTokenTypes.namespace,
             });
         } else if (isSdsImportedDeclaration(node)) {
-            const info = this.computeSemanticTokenInfoForDeclaration(node.declaration.ref);
+            const info = this.computeSemanticTokenInfoForDeclaration(node.declaration?.ref);
             if (info) {
                 acceptor({
                     node,
@@ -96,7 +96,7 @@ export class SafeDsSemanticTokenProvider extends AbstractSemanticTokenProvider {
                 });
             }
         } else if (isSdsNamedType(node)) {
-            const info = this.computeSemanticTokenInfoForDeclaration(node.declaration.ref);
+            const info = this.computeSemanticTokenInfoForDeclaration(node.declaration?.ref);
             if (info) {
                 acceptor({
                     node,
diff --git a/src/language/scoping/safe-ds-scope-provider.ts b/src/language/scoping/safe-ds-scope-provider.ts
@@ -52,16 +52,16 @@ import { isContainedIn } from '../helpers/astUtils.js';
 import {
     getAbstractResults,
     getAssignees,
-    getMatchingClassMembers,
     getEnumVariants,
     getImportedDeclarations,
     getImports,
-    isStatic,
+    getMatchingClassMembers,
     getPackageName,
     getParameters,
     getResults,
     getStatements,
     getTypeParameters,
+    isStatic,
 } from '../helpers/nodeProperties.js';
 import { SafeDsServices } from '../safe-ds-module.js';
 import { SafeDsTypeComputer } from '../typing/safe-ds-type-computer.js';
@@ -165,7 +165,7 @@ export class SafeDsScopeProvider extends DefaultScopeProvider {
      */
     private getUniqueReferencedDeclarationForType(node: SdsType): SdsNamedTypeDeclaration | undefined {
         if (isSdsNamedType(node)) {
-            return node.declaration.ref;
+            return node.declaration?.ref;
         } else if (isSdsMemberType(node)) {
             return node.member?.declaration?.ref;
         } else {
@@ -335,7 +335,7 @@ export class SafeDsScopeProvider extends DefaultScopeProvider {
             return EMPTY_SCOPE;
         }
 
-        const namedTypeDeclaration = containingNamedType.declaration.ref;
+        const namedTypeDeclaration = containingNamedType.declaration?.ref;
         if (isSdsClass(namedTypeDeclaration)) {
             const typeParameters = getTypeParameters(namedTypeDeclaration.typeParameterList);
             return this.createScopeForNodes(typeParameters);
@@ -403,7 +403,7 @@ export class SafeDsScopeProvider extends DefaultScopeProvider {
         for (const imp of imports) {
             if (isSdsQualifiedImport(imp)) {
                 for (const importedDeclaration of getImportedDeclarations(imp)) {
-                    const description = importedDeclaration.declaration.$nodeDescription;
+                    const description = importedDeclaration.declaration?.$nodeDescription;
                     if (!description || !this.astReflection.isSubtype(description.type, referenceType)) {
                         continue;
                     }
diff --git a/src/language/typing/safe-ds-type-checker.ts b/src/language/typing/safe-ds-type-checker.ts
@@ -198,6 +198,7 @@ export class SafeDsTypeChecker {
     }
 
     private unionTypeIsAssignableTo(type: UnionType, other: Type): boolean {
+        //     return this.possibleTypes.all { it.isSubstitutableFor(other) }
         return type.equals(other);
     }
 }
diff --git a/src/language/typing/safe-ds-type-computer.ts b/src/language/typing/safe-ds-type-computer.ts
@@ -75,11 +75,11 @@ import {
 import { SafeDsNodeMapper } from '../helpers/safe-ds-node-mapper.js';
 import {
     getAssignees,
-    streamBlockLambdaResults,
     getLiterals,
     getParameters,
     getResults,
     getTypeArguments,
+    streamBlockLambdaResults,
 } from '../helpers/nodeProperties.js';
 import { SafeDsPartialEvaluator } from '../partialEvaluation/safe-ds-partial-evaluator.js';
 import { Constant, isConstant } from '../partialEvaluation/model.js';
@@ -453,7 +453,7 @@ export class SafeDsTypeComputer {
         } else if (isSdsMemberType(node)) {
             return this.computeType(node.member);
         } else if (isSdsNamedType(node)) {
-            return this.computeType(node.declaration.ref).copyWithNullability(node.isNullable);
+            return this.computeType(node.declaration?.ref).copyWithNullability(node.isNullable);
         } else if (isSdsUnionType(node)) {
             const typeArguments = getTypeArguments(node.typeArgumentList);
             return new UnionType(typeArguments.map((typeArgument) => this.computeType(typeArgument.value)));
diff --git a/src/language/typing/typeConformance.ts b/src/language/typing/typeConformance.ts
diff --git a/src/language/validation/builtins/deprecated.ts b/src/language/validation/builtins/deprecated.ts
@@ -76,7 +76,7 @@ export const argumentCorrespondingParameterShouldNotBeDeprecated =
 
 export const namedTypeDeclarationShouldNotBeDeprecated =
     (services: SafeDsServices) => (node: SdsNamedType, accept: ValidationAcceptor) => {
-        const declaration = node.declaration.ref;
+        const declaration = node.declaration?.ref;
         if (!declaration) {
             return;
         }
diff --git a/src/language/validation/builtins/experimental.ts b/src/language/validation/builtins/experimental.ts
@@ -68,7 +68,7 @@ export const argumentCorrespondingParameterShouldNotBeExperimental =
 
 export const namedTypeDeclarationShouldNotBeExperimental =
     (services: SafeDsServices) => (node: SdsNamedType, accept: ValidationAcceptor) => {
-        const declaration = node.declaration.ref;
+        const declaration = node.declaration?.ref;
         if (!declaration) {
             return;
         }
diff --git a/src/language/validation/experimentalLanguageFeatures.ts b/src/language/validation/experimentalLanguageFeatures.ts
@@ -25,6 +25,7 @@ export const indexedAccessesShouldBeUsedWithCaution = (node: SdsIndexedAccess, a
 export const literalTypesShouldBeUsedWithCaution = (node: SdsLiteralType, accept: ValidationAcceptor): void => {
     accept('warning', 'Literal types are experimental and may change without prior notice.', {
         node,
+        keyword: 'literal',
         code: CODE_EXPERIMENTAL_LANGUAGE_FEATURE,
     });
 };
@@ -47,6 +48,7 @@ export const unionTypesShouldBeUsedWithCaution = (node: SdsUnionType, accept: Va
 
     accept('warning', 'Union types are experimental and may change without prior notice.', {
         node,
+        keyword: 'union',
         code: CODE_EXPERIMENTAL_LANGUAGE_FEATURE,
     });
 };
diff --git a/src/language/validation/names.ts b/src/language/validation/names.ts
@@ -305,7 +305,7 @@ export const moduleMustContainUniqueNames = (node: SdsModule, accept: Validation
 };
 
 const importedDeclarationName = (node: SdsImportedDeclaration | undefined): string | undefined => {
-    return node?.alias?.alias ?? node?.declaration.ref?.name;
+    return node?.alias?.alias ?? node?.declaration?.ref?.name;
 };
 
 export const pipelineMustContainUniqueNames = (node: SdsPipeline, accept: ValidationAcceptor): void => {
diff --git a/src/language/validation/other/declarations/typeParameterConstraints.ts b/src/language/validation/other/declarations/typeParameterConstraints.ts
@@ -7,7 +7,7 @@ export const typeParameterConstraintLeftOperandMustBeOwnTypeParameter = (
     node: SdsTypeParameterConstraint,
     accept: ValidationAcceptor,
 ) => {
-    const typeParameter = node.leftOperand.ref;
+    const typeParameter = node.leftOperand?.ref;
     if (!typeParameter) {
         return;
     }
diff --git a/src/language/validation/other/declarations/typeParameters.ts b/src/language/validation/other/declarations/typeParameters.ts
@@ -0,0 +1,47 @@
+import {
+    isSdsCallable,
+    isSdsClass,
+    isSdsParameterList,
+    isSdsUnionType,
+    SdsTypeParameter,
+} from '../../../generated/ast.js';
+import { findLocalReferences, getContainerOfType, hasContainerOfType, ValidationAcceptor } from 'langium';
+
+export const CODE_TYPE_PARAMETER_INSUFFICIENT_CONTEXT = 'type-parameter/insufficient-context';
+
+export const typeParameterMustHaveSufficientContext = (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;
+    }
+
+    // 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();
+
+    if (typeParameterHasInsufficientContext) {
+        accept('error', 'Insufficient context to infer this type parameter.', {
+            node,
+            code: CODE_TYPE_PARAMETER_INSUFFICIENT_CONTEXT,
+        });
+    }
+};
diff --git a/src/language/validation/other/types/namedTypes.ts b/src/language/validation/other/types/namedTypes.ts
@@ -51,11 +51,12 @@ export const namedTypeTypeArgumentListMustNotHavePositionalArgumentsAfterNamedAr
 
 export const namedTypeMustNotHaveTooManyTypeArguments = (node: SdsNamedType, accept: ValidationAcceptor): void => {
     // If the declaration is unresolved, we already show another error
-    if (!node.declaration.ref) {
+    const namedTypeDeclaration = node.declaration?.ref;
+    if (!namedTypeDeclaration) {
         return;
     }
 
-    const typeParameters = getTypeParameters(node.declaration.ref);
+    const typeParameters = getTypeParameters(namedTypeDeclaration);
     const typeArguments = getTypeArguments(node.typeArgumentList);
 
     if (typeArguments.length > typeParameters.length) {
diff --git a/src/language/validation/safe-ds-validator.ts b/src/language/validation/safe-ds-validator.ts
diff --git a/src/language/validation/style.ts b/src/language/validation/style.ts
diff --git a/src/language/validation/types.ts b/src/language/validation/types.ts
diff --git a/tests/resources/validation/experimental language feature/literal types/main.sdstest b/tests/resources/validation/experimental language feature/literal types/main.sdstest
diff --git a/tests/resources/validation/experimental language feature/union types/main.sdstest b/tests/resources/validation/experimental language feature/union types/main.sdstest
diff --git a/tests/resources/validation/other/declarations/type parameters/insufficient context/main.sdstest b/tests/resources/validation/other/declarations/type parameters/insufficient context/main.sdstest

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ SdsImportedDeclarationList returns SdsImportedDeclarationList:`
`77`	`77`	`;`
`78`	`78`
`79`	`79`	`interface SdsImportedDeclaration extends SdsObject {`
`80`		`- declaration: @SdsModuleMember;`
	`80`	`+ declaration?: @SdsModuleMember;`
`81`	`81`	`alias?: SdsImportedDeclarationAlias;`
`82`	`82`	`}`
`83`	`83`
`@@ -384,7 +384,7 @@ SdsConstraint returns SdsConstraint:`
`384`	`384`	`;`
`385`	`385`
`386`	`386`	`interface SdsTypeParameterConstraint extends SdsConstraint {`
`387`		`- leftOperand: @SdsTypeParameter`
	`387`	`+ leftOperand?: @SdsTypeParameter`
`388`	`388`	`operator: string`
`389`	`389`	`rightOperand: SdsType`
`390`	`390`	`}`
`@@ -922,7 +922,7 @@ SdsLiteralList returns SdsLiteralList:`
`922`	`922`	`;`
`923`	`923`
`924`	`924`	`interface SdsNamedType extends SdsType {`
`925`		`- declaration: @SdsNamedTypeDeclaration`
	`925`	`+ declaration?: @SdsNamedTypeDeclaration`
`926`	`926`	`typeArgumentList?: SdsTypeArgumentList`
`927`	`927`	`isNullable: boolean`
`928`	`928`	`}`
Original file line number	Diff line number	Diff line change
`@@ -239,7 +239,7 @@ export class SafeDsNodeMapper {`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`// Find type parameter at the same position`
`242`		`- const namedTypeDeclaration = containingType.declaration.ref;`
	`242`	`+ const namedTypeDeclaration = containingType.declaration?.ref;`
`243`	`243`	`const typeParameters = getTypeParameters(namedTypeDeclaration);`
`244`	`244`	`return typeParameters[typeArgumentPosition];`
`245`	`245`	`}`
Original file line number	Diff line number	Diff line change
`@@ -198,6 +198,7 @@ export class SafeDsTypeChecker {`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`private unionTypeIsAssignableTo(type: UnionType, other: Type): boolean {`
	`201`	`+ // return this.possibleTypes.all { it.isSubstitutableFor(other) }`
`201`	`202`	`return type.equals(other);`
`202`	`203`	`}`
`203`	`204`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ export const argumentCorrespondingParameterShouldNotBeDeprecated =`
`76`	`76`
`77`	`77`	`export const namedTypeDeclarationShouldNotBeDeprecated =`
`78`	`78`	`(services: SafeDsServices) => (node: SdsNamedType, accept: ValidationAcceptor) => {`
`79`		`- const declaration = node.declaration.ref;`
	`79`	`+ const declaration = node.declaration?.ref;`
`80`	`80`	`if (!declaration) {`
`81`	`81`	`return;`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ export const argumentCorrespondingParameterShouldNotBeExperimental =`
`68`	`68`
`69`	`69`	`export const namedTypeDeclarationShouldNotBeExperimental =`
`70`	`70`	`(services: SafeDsServices) => (node: SdsNamedType, accept: ValidationAcceptor) => {`
`71`		`- const declaration = node.declaration.ref;`
	`71`	`+ const declaration = node.declaration?.ref;`
`72`	`72`	`if (!declaration) {`
`73`	`73`	`return;`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ export const typeParameterConstraintLeftOperandMustBeOwnTypeParameter = (`
`7`	`7`	`node: SdsTypeParameterConstraint,`
`8`	`8`	`accept: ValidationAcceptor,`
`9`	`9`	`) => {`
`10`		`- const typeParameter = node.leftOperand.ref;`
	`10`	`+ const typeParameter = node.leftOperand?.ref;`
`11`	`11`	`if (!typeParameter) {`
`12`	`12`	`return;`
`13`	`13`	`}`