refactor: rename methods to access node properties

Author: lars-reimann

src/cli/generator.ts

@@ -57,14 +57,14 @@ import chalk from 'chalk';
 import { createSafeDsServices, SafeDsServices } from '../language/safe-ds-module.js';
 import { NodeFileSystem } from 'langium/node';
 import {
-    abstractResultsOrEmpty,
-    assigneesOrEmpty,
-    blockLambdaResultsOrEmpty,
-    importedDeclarationsOrEmpty,
-    importsOrEmpty,
+    getAbstractResults,
+    getAssignees,
+    streamBlockLambdaResults,
+    getImportedDeclarations,
+    getImports,
     isRequiredParameter,
-    moduleMembersOrEmpty,
-    statementsOrEmpty,
+    getModuleMembers,
+    getStatements,
 } from '../language/helpers/nodeProperties.js';
 import { IdManager } from '../language/helpers/idManager.js';
 import { isInStubFile } from '../language/helpers/fileExtensions.js';
@@ -150,10 +150,10 @@ const formatGeneratedFileName = function (baseName: string): string {
 
 const generateModule = function (services: SafeDsServices, module: SdsModule): string {
     const importSet = new Map<String, ImportData>();
-    const segments = moduleMembersOrEmpty(module)
+    const segments = getModuleMembers(module)
         .filter(isSdsSegment)
         .map((segment) => generateSegment(services, segment, importSet));
-    const pipelines = moduleMembersOrEmpty(module)
+    const pipelines = getModuleMembers(module)
         .filter(isSdsPipeline)
         .map((pipeline) => generatePipeline(services, pipeline, importSet));
     const imports = generateImports(Array.from(importSet.values()));
@@ -266,7 +266,7 @@ const generateQualifiedImport = function (importStmt: ImportData): string {
 
 const generateBlock = function (block: SdsBlock, frame: GenerationInfoFrame): string {
     // TODO filter withEffect
-    let statements = statementsOrEmpty(block);
+    let statements = getStatements(block);
     if (statements.length === 0) {
         return 'pass';
     }
@@ -291,10 +291,10 @@ const generateStatement = function (statement: SdsStatement, frame: GenerationIn
 
 const generateAssignment = function (assignment: SdsAssignment, frame: GenerationInfoFrame): string {
     const requiredAssignees = isSdsCall(assignment.expression)
-        ? abstractResultsOrEmpty(frame.getServices().helpers.NodeMapper.callToCallable(assignment.expression)).length
+        ? getAbstractResults(frame.getServices().helpers.NodeMapper.callToCallable(assignment.expression)).length
         : /* c8 ignore next */
           1;
-    const assignees = assigneesOrEmpty(assignment);
+    const assignees = getAssignees(assignment);
     if (assignees.some((value) => !isSdsWildcard(value))) {
         const actualAssignees = assignees.map(generateAssignee);
         if (requiredAssignees === actualAssignees.length) {
@@ -325,12 +325,10 @@ const generateAssignee = function (assignee: SdsAssignee): string {
 };
 
 const generateBlockLambda = function (blockLambda: SdsBlockLambda, frame: GenerationInfoFrame): string {
-    const lambdaResult = blockLambdaResultsOrEmpty(blockLambda);
+    const results = streamBlockLambdaResults(blockLambda);
     let lambdaBlock = generateBlock(blockLambda.body, frame);
-    if (lambdaResult.length !== 0 && lambdaBlock !== 'pass') {
-        lambdaBlock += `\nreturn ${lambdaResult
-            .map((result) => `${BLOCK_LAMBDA_RESULT_PREFIX}${result.name}`)
-            .join(', ')}`;
+    if (!results.isEmpty()) {
+        lambdaBlock += `\nreturn ${results.map((result) => `${BLOCK_LAMBDA_RESULT_PREFIX}${result.name}`).join(', ')}`;
     }
     return expandToString`def ${frame.getUniqueLambdaBlockName(blockLambda)}(${generateParameters(
         blockLambda.parameterList,
@@ -429,7 +427,7 @@ const generateExpression = function (expression: SdsExpression, frame: Generatio
             const suffix = isSdsCall(expression.$container) ? '' : '()';
             return `${receiver}.${enumMember}${suffix}`;
         } else if (isSdsAbstractResult(member)) {
-            const resultList = abstractResultsOrEmpty(getContainerOfType(member, isSdsCallable));
+            const resultList = getAbstractResults(getContainerOfType(member, isSdsCallable));
             if (resultList.length === 1) {
                 return receiver;
             }
@@ -500,13 +498,13 @@ const getExternalReferenceNeededImport = function (
     // Root Node is always a module.
     const currentModule = <SdsModule>findRootNode(expression);
     const targetModule = <SdsModule>findRootNode(declaration);
-    for (const value of importsOrEmpty(currentModule)) {
+    for (const value of getImports(currentModule)) {
         // Verify same package
         if (value.package !== targetModule.name) {
             continue;
         }
         if (isSdsQualifiedImport(value)) {
-            const importedDeclarations = importedDeclarationsOrEmpty(value);
+            const importedDeclarations = getImportedDeclarations(value);
             for (const importedDeclaration of importedDeclarations) {
                 if (declaration === importedDeclaration.declaration.ref) {
                     if (importedDeclaration.alias !== undefined) {

src/language/builtins/safe-ds-annotations.ts

@@ -1,5 +1,5 @@
 import { isSdsAnnotation, SdsAnnotatedObject, SdsAnnotation, SdsModule, SdsParameter } from '../generated/ast.js';
-import { argumentsOrEmpty, findFirstAnnotationCallOf, hasAnnotationCallOf } from '../helpers/nodeProperties.js';
+import { getArguments, findFirstAnnotationCallOf, hasAnnotationCallOf } from '../helpers/nodeProperties.js';
 import { SafeDsModuleMembers } from './safe-ds-module-members.js';
 import { resourceNameToUri } from '../../helpers/resources.js';
 import { URI } from 'langium';
@@ -96,7 +96,7 @@ export class SafeDsAnnotations extends SafeDsModuleMembers<SdsAnnotation> {
         parameterName: string,
     ): EvaluatedNode {
         const annotationCall = findFirstAnnotationCallOf(node, annotation);
-        const argumentValue = argumentsOrEmpty(annotationCall).find(
+        const argumentValue = getArguments(annotationCall).find(
             (it) => this.nodeMapper.argumentToParameter(it)?.name === parameterName,
         )?.value;
         return this.partialEvaluator.evaluate(argumentValue);

src/language/builtins/safe-ds-module-members.ts

@@ -1,7 +1,7 @@
 import { SafeDsServices } from '../safe-ds-module.js';
 import { isSdsModule, SdsModuleMember } from '../generated/ast.js';
 import { LangiumDocuments, URI, WorkspaceCache } from 'langium';
-import { moduleMembersOrEmpty } from '../helpers/nodeProperties.js';
+import { getModuleMembers } from '../helpers/nodeProperties.js';
 
 export abstract class SafeDsModuleMembers<T extends SdsModuleMember> {
     private readonly langiumDocuments: LangiumDocuments;
@@ -31,7 +31,7 @@ export abstract class SafeDsModuleMembers<T extends SdsModuleMember> {
             return undefined;
         }
 
-        const firstMatchingModuleMember = moduleMembersOrEmpty(root).find((m) => m.name === name);
+        const firstMatchingModuleMember = getModuleMembers(root).find((m) => m.name === name);
         if (!predicate(firstMatchingModuleMember)) {
             /* c8 ignore next 2 */
             return undefined;

src/language/helpers/nodeProperties.ts

@@ -57,7 +57,7 @@ import {
     SdsTypeParameter,
     SdsTypeParameterList,
 } from '../generated/ast.js';
-import { AstNode, getContainerOfType, stream } from 'langium';
+import { AstNode, getContainerOfType, Stream, stream } from 'langium';
 
 // -------------------------------------------------------------------------------------------------
 // Checks
@@ -67,7 +67,7 @@ export const hasAnnotationCallOf = (
     node: SdsAnnotatedObject | undefined,
     expected: SdsAnnotation | undefined,
 ): boolean => {
-    return annotationCallsOrEmpty(node).some((it) => {
+    return getAnnotationCalls(node).some((it) => {
         const actual = it.annotation?.ref;
         return actual === expected;
     });
@@ -121,25 +121,25 @@ export const isStatic = (node: SdsClassMember): boolean => {
 // Accessors for list elements
 // -------------------------------------------------------------------------------------------------
 
-export const abstractResultsOrEmpty = (node: SdsCallable | undefined): SdsAbstractResult[] => {
+export const getAbstractResults = (node: SdsCallable | undefined): SdsAbstractResult[] => {
     if (!node) {
         return [];
     }
 
     if (isSdsBlockLambda(node)) {
-        return blockLambdaResultsOrEmpty(node);
+        return streamBlockLambdaResults(node).toArray();
     } else if (isSdsCallableType(node)) {
-        return resultsOrEmpty(node.resultList);
+        return getResults(node.resultList);
     } else if (isSdsFunction(node)) {
-        return resultsOrEmpty(node.resultList);
+        return getResults(node.resultList);
     } else if (isSdsSegment(node)) {
-        return resultsOrEmpty(node.resultList);
+        return getResults(node.resultList);
     } /* c8 ignore start */ else {
         return [];
     } /* c8 ignore stop */
 };
 
-export const annotationCallsOrEmpty = (node: SdsAnnotatedObject | undefined): SdsAnnotationCall[] => {
+export const getAnnotationCalls = (node: SdsAnnotatedObject | undefined): SdsAnnotationCall[] => {
     if (!node) {
         /* c8 ignore next 2 */
         return [];
@@ -157,96 +157,91 @@ export const findFirstAnnotationCallOf = (
     node: SdsAnnotatedObject | undefined,
     expected: SdsAnnotation | undefined,
 ): SdsAnnotationCall | undefined => {
-    return annotationCallsOrEmpty(node).find((it) => {
+    return getAnnotationCalls(node).find((it) => {
         const actual = it.annotation?.ref;
         return actual === expected;
     });
 };
 
-export const argumentsOrEmpty = (node: SdsArgumentList | SdsAbstractCall | undefined): SdsArgument[] => {
+export const getArguments = (node: SdsArgumentList | SdsAbstractCall | undefined): SdsArgument[] => {
     if (isSdsArgumentList(node)) {
         return node.arguments;
     } else {
         return node?.argumentList?.arguments ?? [];
     }
 };
 
-export const assigneesOrEmpty = (node: SdsAssignment | undefined): SdsAssignee[] => {
+export const getAssignees = (node: SdsAssignment | undefined): SdsAssignee[] => {
     return node?.assigneeList?.assignees ?? [];
 };
 
-export const blockLambdaResultsOrEmpty = (node: SdsBlockLambda | undefined): SdsBlockLambdaResult[] => {
-    return stream(statementsOrEmpty(node?.body))
+export const streamBlockLambdaResults = (node: SdsBlockLambda | undefined): Stream<SdsBlockLambdaResult> => {
+    return stream(getStatements(node?.body))
         .filter(isSdsAssignment)
-        .flatMap(assigneesOrEmpty)
-        .filter(isSdsBlockLambdaResult)
-        .toArray();
+        .flatMap(getAssignees)
+        .filter(isSdsBlockLambdaResult);
 };
 
-export const classMembersOrEmpty = (
+export const getMatchingClassMembers = (
     node: SdsClass | undefined,
     filterFunction: (member: SdsClassMember) => boolean = () => true,
 ): SdsClassMember[] => {
     return node?.body?.members?.filter(filterFunction) ?? [];
 };
 
-export const columnsOrEmpty = (node: SdsSchema | undefined): SdsColumn[] => {
+export const getColumns = (node: SdsSchema | undefined): SdsColumn[] => {
     return node?.columnList?.columns ?? [];
 };
 
-export const enumVariantsOrEmpty = (node: SdsEnum | undefined): SdsEnumVariant[] => {
+export const getEnumVariants = (node: SdsEnum | undefined): SdsEnumVariant[] => {
     return node?.body?.variants ?? [];
 };
 
-export const importsOrEmpty = (node: SdsModule | undefined): SdsImport[] => {
+export const getImports = (node: SdsModule | undefined): SdsImport[] => {
     return node?.imports ?? [];
 };
 
-export const importedDeclarationsOrEmpty = (node: SdsQualifiedImport | undefined): SdsImportedDeclaration[] => {
+export const getImportedDeclarations = (node: SdsQualifiedImport | undefined): SdsImportedDeclaration[] => {
     return node?.importedDeclarationList?.importedDeclarations ?? [];
 };
 
-export const literalsOrEmpty = (node: SdsLiteralType | undefined): SdsLiteral[] => {
+export const getLiterals = (node: SdsLiteralType | undefined): SdsLiteral[] => {
     return node?.literalList?.literals ?? [];
 };
 
-export const moduleMembersOrEmpty = (node: SdsModule | undefined): SdsModuleMember[] => {
+export const getModuleMembers = (node: SdsModule | undefined): SdsModuleMember[] => {
     return node?.members?.filter(isSdsModuleMember) ?? [];
 };
 
-export const packageNameOrUndefined = (node: AstNode | undefined): string | undefined => {
+export const getPackageName = (node: AstNode | undefined): string | undefined => {
     return getContainerOfType(node, isSdsModule)?.name;
 };
 
-export const parametersOrEmpty = (node: SdsCallable | undefined): SdsParameter[] => {
+export const getParameters = (node: SdsCallable | undefined): SdsParameter[] => {
     return node?.parameterList?.parameters ?? [];
 };
 
-export const parentTypesOrEmpty = (node: SdsClass | undefined): SdsType[] => {
+export const getParentTypes = (node: SdsClass | undefined): SdsType[] => {
     return node?.parentTypeList?.parentTypes ?? [];
 };
 
-export const placeholdersOrEmpty = (node: SdsBlock | undefined): SdsPlaceholder[] => {
-    return stream(statementsOrEmpty(node))
-        .filter(isSdsAssignment)
-        .flatMap(assigneesOrEmpty)
-        .filter(isSdsPlaceholder)
-        .toArray();
+export const streamPlaceholders = (node: SdsBlock | undefined): Stream<SdsPlaceholder> => {
+    return stream(getStatements(node)).filter(isSdsAssignment).flatMap(getAssignees).filter(isSdsPlaceholder);
 };
 
-export const resultsOrEmpty = (node: SdsResultList | undefined): SdsResult[] => {
+export const getResults = (node: SdsResultList | undefined): SdsResult[] => {
     return node?.results ?? [];
 };
 
-export const statementsOrEmpty = (node: SdsBlock | undefined): SdsStatement[] => {
+export const getStatements = (node: SdsBlock | undefined): SdsStatement[] => {
     return node?.statements ?? [];
 };
 
-export const typeArgumentsOrEmpty = (node: SdsTypeArgumentList | undefined): SdsTypeArgument[] => {
+export const getTypeArguments = (node: SdsTypeArgumentList | undefined): SdsTypeArgument[] => {
     return node?.typeArguments ?? [];
 };
 
-export const typeParametersOrEmpty = (
+export const getTypeParameters = (
     node: SdsTypeParameterList | SdsNamedTypeDeclaration | undefined,
 ): SdsTypeParameter[] => {
     if (!node) {
@@ -256,9 +251,9 @@ export const typeParametersOrEmpty = (
     if (isSdsTypeParameterList(node)) {
         return node.typeParameters;
     } else if (isSdsClass(node)) {
-        return typeParametersOrEmpty(node.typeParameterList);
+        return getTypeParameters(node.typeParameterList);
     } else if (isSdsEnumVariant(node)) {
-        return typeParametersOrEmpty(node.typeParameterList);
+        return getTypeParameters(node.typeParameterList);
     } /* c8 ignore start */ else {
         return [];
     } /* c8 ignore stop */

src/language/helpers/safe-ds-node-mapper.ts

@@ -31,13 +31,13 @@ import {
 import { CallableType, StaticType } from '../typing/model.js';
 import { findLocalReferences, getContainerOfType, Stream, stream } from 'langium';
 import {
-    abstractResultsOrEmpty,
-    argumentsOrEmpty,
+    getAbstractResults,
+    getArguments,
     isNamedArgument,
     isNamedTypeArgument,
-    parametersOrEmpty,
-    typeArgumentsOrEmpty,
-    typeParametersOrEmpty,
+    getParameters,
+    getTypeArguments,
+    getTypeParameters,
 } from './nodeProperties.js';
 
 export class SafeDsNodeMapper {
@@ -62,7 +62,7 @@ export class SafeDsNodeMapper {
 
         // Positional argument
         const containingAbstractCall = getContainerOfType(node, isSdsAbstractCall)!;
-        const args = argumentsOrEmpty(containingAbstractCall);
+        const args = getArguments(containingAbstractCall);
         const argumentPosition = node.$containerIndex ?? -1;
 
         // A prior argument is named
@@ -74,7 +74,7 @@ export class SafeDsNodeMapper {
 
         // Find parameter at the same position
         const callable = this.callToCallable(containingAbstractCall);
-        const parameters = parametersOrEmpty(callable);
+        const parameters = getParameters(callable);
         if (argumentPosition < parameters.length) {
             return parameters[argumentPosition];
         }
@@ -121,7 +121,7 @@ export class SafeDsNodeMapper {
         }
 
         // Otherwise, the assignee gets the result at the same position
-        const abstractResults = abstractResultsOrEmpty(callable);
+        const abstractResults = getAbstractResults(callable);
         return abstractResults[assigneePosition];
     }
 
@@ -228,7 +228,7 @@ export class SafeDsNodeMapper {
             return undefined;
         }
 
-        const typeArguments = typeArgumentsOrEmpty(containingType.typeArgumentList);
+        const typeArguments = getTypeArguments(containingType.typeArgumentList);
         const typeArgumentPosition = node.$containerIndex ?? -1;
 
         // A prior type argument is named
@@ -240,7 +240,7 @@ export class SafeDsNodeMapper {
 
         // Find type parameter at the same position
         const namedTypeDeclaration = containingType.declaration.ref;
-        const typeParameters = typeParametersOrEmpty(namedTypeDeclaration);
+        const typeParameters = getTypeParameters(namedTypeDeclaration);
         return typeParameters[typeArgumentPosition];
     }
 }