@abaplint/core 2.120.25 → 2.120.27

package/build/abaplint.d.ts

@@ -1790,6 +1790,9 @@ declare class DataElement extends AbstractObject {
     };
     setDirty(): void;
     getDomainName(): string | undefined;
+    /** parseType() cannot distinguish DEC, CURR, and QUAN because they all become PackedType.
+     * Return the original DDIC datatype instead, resolving domain-backed data elements when possible. */
+    getDataType(reg?: IRegistry): string | undefined;
     getTexts(): {
         short?: string;
         medium?: string;
@@ -2053,6 +2056,7 @@ declare class Domain extends AbstractObject {
     getType(): string;
     getDescription(): string | undefined;
     getConversionExit(): string | undefined;
+    getDataType(): string | undefined;
     getAllowedNaming(): {
         maxLength: number;
         allowNamespace: boolean;

package/build/src/abap/5_syntax/expressions/_check_database_fields.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDatabaseFields = checkDatabaseFields;
+const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
+function checkDatabaseFields(fields, dbSources, input, token) {
+    if (dbSources.length > 1) {
+        return;
+    }
+    const first = dbSources[0];
+    if (first === undefined) {
+        // then its voided
+        return;
+    }
+    const type = first.parseType(input.scope.getRegistry());
+    if (type instanceof basic_1.VoidType || type instanceof basic_1.UnknownType) {
+        return;
+    }
+    if (!(type instanceof basic_1.StructureType)) {
+        const message = "checkFields, expected structure, " + type.constructor.name;
+        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, token, message));
+        return;
+    }
+    for (const field of fields) {
+        if (field === "*") {
+            continue;
+        }
+        if (/^\w+$/.test(field) && type.getComponentByName(field) === undefined) {
+            const message = `checkFields, field ${field} not found`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, token, message));
+            return;
+        }
+    }
+}
+//# sourceMappingURL=_check_database_fields.js.map

package/build/src/abap/5_syntax/expressions/select.js

@@ -48,6 +48,7 @@ const dynamic_1 = require("./dynamic");
 const _reference_1 = require("../_reference");
 const _syntax_input_1 = require("../_syntax_input");
 const version_1 = require("../../../version");
+const _check_database_fields_1 = require("./_check_database_fields");
 const isSimple = /^\w+$/;
 class Select {
     static runSyntax(node, input, skipImplicitInto = false, selectLoop = false) {
@@ -72,7 +73,7 @@ class Select {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return;
         }
-        this.checkFields(fields, dbSources, input, node);
+        (0, _check_database_fields_1.checkDatabaseFields)(fields.map(field => field.code), dbSources, input, node.getFirstToken());
         const intoExpression = this.handleInto(node, input, fields, dbSources);
         const fae = node.findDirectExpression(Expressions.SQLForAllEntries);
         if (fae) {
@@ -299,35 +300,6 @@ class Select {
         }
         return undefined;
     }
-    static checkFields(fields, dbSources, input, node) {
-        if (dbSources.length > 1) {
-            return;
-        }
-        const first = dbSources[0];
-        if (first === undefined) {
-            // then its voided
-            return;
-        }
-        const type = first.parseType(input.scope.getRegistry());
-        if (type instanceof basic_1.VoidType || type instanceof basic_1.UnknownType) {
-            return;
-        }
-        if (!(type instanceof basic_1.StructureType)) {
-            const message = "checkFields, expected structure, " + type.constructor.name;
-            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-            return;
-        }
-        for (const field of fields) {
-            if (field.code === "*") {
-                continue;
-            }
-            if (isSimple.test(field.code) && type.getComponentByName(field.code) === undefined) {
-                const message = `checkFields, field ${field.code} not found`;
-                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-                return;
-            }
-        }
-    }
     static countResultType(scope) {
         if ((0, version_1.releaseAtLeast)(scope.getRelease(), version_1.Release.v750)
             || scope.getOpenABAP()

package/build/src/abap/5_syntax/statements/delete_database.js

@@ -38,6 +38,7 @@ const Expressions = __importStar(require("../../2_statements/expressions"));
 const source_1 = require("../expressions/source");
 const dynamic_1 = require("../expressions/dynamic");
 const database_table_1 = require("../expressions/database_table");
+const _check_database_fields_1 = require("../expressions/_check_database_fields");
 class DeleteDatabase {
     runSyntax(node, input) {
         for (const s of node.findAllExpressions(Expressions.Source)) {
@@ -51,7 +52,14 @@ class DeleteDatabase {
         }
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
-            database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const fields = node.findAllExpressions(Expressions.SQLCompare)
+                .map(compare => { var _a; return (_a = compare.findDirectExpression(Expressions.SQLFieldName)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase(); })
+                .filter(field => field !== undefined);
+            for (const orderBy of node.findAllExpressions(Expressions.SQLOrderBy)) {
+                fields.push(...orderBy.findAllExpressions(Expressions.SQLFieldName).map(field => field.concatTokens().toUpperCase()));
+            }
+            (0, _check_database_fields_1.checkDatabaseFields)(fields, [dbSource], input, node.getFirstToken());
         }
     }
 }

package/build/src/abap/5_syntax/statements/update_database.js

@@ -42,11 +42,19 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const identifier_1 = require("../../1_lexer/tokens/identifier");
 const database_table_1 = require("../expressions/database_table");
 const dynamic_1 = require("../expressions/dynamic");
+const _check_database_fields_1 = require("../expressions/_check_database_fields");
 class UpdateDatabase {
     runSyntax(node, input) {
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
-            database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const fields = node.findAllExpressions(Expressions.SQLFieldAndValue)
+                .flatMap(fieldAndValue => fieldAndValue.findDirectExpressions(Expressions.SQLFieldName))
+                .map(field => field.concatTokens().toUpperCase());
+            fields.push(...node.findAllExpressions(Expressions.SQLCompare)
+                .map(compare => { var _a; return (_a = compare.findDirectExpression(Expressions.SQLFieldName)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase(); })
+                .filter(field => field !== undefined));
+            (0, _check_database_fields_1.checkDatabaseFields)(fields, [dbSource], input, node.getFirstToken());
         }
         const tableName = node.findDirectExpression(Expressions.DatabaseTable);
         const tokenName = tableName === null || tableName === void 0 ? void 0 : tableName.getFirstToken();

package/build/src/objects/data_element.js

@@ -38,6 +38,7 @@ const _abstract_object_1 = require("./_abstract_object");
 const ddic_1 = require("../ddic");
 const Types = __importStar(require("../abap/types/basic"));
 const xml_utils_1 = require("../xml_utils");
+const domain_1 = require("./domain");
 class DataElement extends _abstract_object_1.AbstractObject {
     constructor() {
         super(...arguments);
@@ -68,6 +69,22 @@ class DataElement extends _abstract_object_1.AbstractObject {
         this.parse();
         return (_a = this.parsedXML) === null || _a === void 0 ? void 0 : _a.domname;
     }
+    /** parseType() cannot distinguish DEC, CURR, and QUAN because they all become PackedType.
+     * Return the original DDIC datatype instead, resolving domain-backed data elements when possible. */
+    getDataType(reg) {
+        var _a, _b;
+        this.parse();
+        if ((_a = this.parsedXML) === null || _a === void 0 ? void 0 : _a.datatype) {
+            return this.parsedXML.datatype;
+        }
+        if (reg && ((_b = this.parsedXML) === null || _b === void 0 ? void 0 : _b.refkind) === "D" && this.parsedXML.domname) {
+            const domain = reg.getObject("DOMA", this.parsedXML.domname);
+            if (domain instanceof domain_1.Domain) {
+                return domain.getDataType();
+            }
+        }
+        return undefined;
+    }
     getTexts() {
         var _a;
         this.parse();

package/build/src/objects/domain.js

@@ -50,6 +50,11 @@ class Domain extends _abstract_object_1.AbstractObject {
         var _a;
         return (_a = this.parsedXML) === null || _a === void 0 ? void 0 : _a.conversionExit;
     }
+    getDataType() {
+        var _a;
+        this.parse();
+        return (_a = this.parsedXML) === null || _a === void 0 ? void 0 : _a.datatype;
+    }
     getAllowedNaming() {
         return {
             maxLength: 30,

package/build/src/registry.js

@@ -75,7 +75,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.25";
+        return "2.120.27";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/cds_check_syntax.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDSCheckSyntax = exports.CDSCheckSyntaxConf = void 0;
+const nodes_1 = require("../abap/nodes");
+const basic_1 = require("../abap/types/basic");
+const expressions_1 = require("../cds/expressions");
+const ddic_1 = require("../ddic");
+const issue_1 = require("../issue");
+const objects_1 = require("../objects");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+class CDSCheckSyntaxConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.CDSCheckSyntaxConf = CDSCheckSyntaxConf;
+const KNOWN_QUAN_DATA_ELEMENTS = ["MENGE_D"];
+const KNOWN_CURR_DATA_ELEMENTS = ["BWERT", "DZWERT"];
+class CDSCheckSyntax {
+    constructor() {
+        this.conf = new CDSCheckSyntaxConf();
+    }
+    getMetadata() {
+        return {
+            key: "cds_check_syntax",
+            title: "CDS Check Syntax",
+            shortDescription: "Checks CDS source, field, type, and semantic annotation references",
+            extendedInformation: `Performs semantic checks which require other DDIC objects to be available.
+
+Missing objects are only reported when their names match the configured errorNamespace.`,
+            tags: [_irule_1.RuleTag.Syntax],
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    initialize(reg) {
+        this.reg = reg;
+        return this;
+    }
+    run(object) {
+        if (!(object instanceof objects_1.DataDefinition)) {
+            return [];
+        }
+        const tree = object.getTree();
+        const file = object.findSourceFile();
+        if (tree === undefined || file === undefined) {
+            return [];
+        }
+        const issues = [];
+        const ddic = new ddic_1.DDIC(this.reg);
+        const sources = this.findSources(tree, ddic, issues, file);
+        this.checkRelations(tree, ddic, issues, file);
+        this.checkTypes(tree, ddic, issues, file);
+        this.checkRootProjection(tree, ddic, issues, file);
+        this.checkFieldAnnotations(tree, ddic, issues, file);
+        this.checkFields(tree, sources, object, issues, file);
+        return issues;
+    }
+    findSources(tree, ddic, issues, file) {
+        var _a;
+        const sources = [];
+        for (const node of tree.findAllExpressionsRecursive(expressions_1.CDSSource)) {
+            const prefixed = node.findDirectExpression(expressions_1.CDSPrefixedName);
+            const entityNode = prefixed === null || prefixed === void 0 ? void 0 : prefixed.findDirectExpression(expressions_1.CDSName);
+            if (entityNode === undefined) {
+                continue;
+            }
+            const entity = this.name(entityNode);
+            const asName = (_a = node.findDirectExpression(expressions_1.CDSAs)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(expressions_1.CDSName);
+            const bareAlias = node.findDirectExpression(expressions_1.CDSName);
+            const alias = asName === undefined ? bareAlias : asName;
+            const lookup = ddic.lookupTableOrView(entity);
+            if (lookup.type instanceof basic_1.UnknownType && lookup.object === undefined && this.reg.inErrorNamespace(entity)) {
+                issues.push(issue_1.Issue.atToken(file, entityNode.getFirstToken(), `CDS source "${entity}" not found`, this.getMetadata().key, this.conf.severity));
+            }
+            if (lookup.type instanceof basic_1.StructureType || lookup.type instanceof basic_1.UnknownType || lookup.type instanceof basic_1.VoidType) {
+                const names = [entity.toUpperCase()];
+                if (alias) {
+                    names.push(this.name(alias).toUpperCase());
+                }
+                sources.push({ entity, names, type: lookup.type });
+            }
+        }
+        return sources;
+    }
+    checkRelations(tree, ddic, issues, file) {
+        for (const relation of tree.findAllExpressionsRecursive(expressions_1.CDSRelation)) {
+            const directTokens = relation.getDirectTokens();
+            if (directTokens.length === 0) {
+                continue;
+            }
+            const entity = directTokens.map(t => t.getStr()).join("");
+            const lookup = ddic.lookupTableOrView(entity);
+            if (lookup.type instanceof basic_1.UnknownType && lookup.object === undefined && this.reg.inErrorNamespace(entity)) {
+                issues.push(issue_1.Issue.atToken(file, directTokens[0], `CDS source "${entity}" not found`, this.getMetadata().key, this.conf.severity));
+            }
+        }
+    }
+    checkTypes(tree, ddic, issues, file) {
+        for (const typeNode of tree.findAllExpressionsRecursive(expressions_1.CDSType)) {
+            const typeName = typeNode.findDirectExpressions(expressions_1.CDSName).map(n => this.name(n)).join(".");
+            if (typeName === "" || typeName.toUpperCase().startsWith("ABAP.")) {
+                continue;
+            }
+            const lookup = ddic.lookup(typeName);
+            if (lookup.type instanceof basic_1.UnknownType && lookup.object === undefined && this.reg.inErrorNamespace(typeName)) {
+                issues.push(issue_1.Issue.atToken(file, typeNode.getFirstToken(), `CDS type "${typeName}" not found`, this.getMetadata().key, this.conf.severity));
+            }
+        }
+    }
+    checkRootProjection(tree, ddic, issues, file) {
+        var _a;
+        const projection = tree.findFirstExpression(expressions_1.CDSDefineProjection);
+        const rootToken = projection === null || projection === void 0 ? void 0 : projection.findDirectTokenByText("ROOT");
+        if (projection === undefined || rootToken === undefined) {
+            return;
+        }
+        const names = projection.findDirectExpressions(expressions_1.CDSName);
+        const projectedEntityNode = names[1];
+        if (projectedEntityNode === undefined) {
+            return;
+        }
+        const projectedEntityName = this.name(projectedEntityNode);
+        const projectedEntity = ddic.lookupTableOrView(projectedEntityName).object;
+        if (projectedEntity instanceof objects_1.DataDefinition
+            && ((_a = projectedEntity.getTree()) === null || _a === void 0 ? void 0 : _a.findDirectTokenByText("ROOT")) === undefined) {
+            const message = `ROOT keyword not valid since ${projectedEntityName} is not a root property`;
+            issues.push(issue_1.Issue.atToken(file, rootToken, message, this.getMetadata().key, this.conf.severity));
+        }
+    }
+    checkFieldAnnotations(tree, ddic, issues, file) {
+        const definition = tree.findFirstExpression(expressions_1.CDSDefineAbstract);
+        if (definition === undefined) {
+            return;
+        }
+        let definitionNameSeen = false;
+        let fieldName;
+        let annotations = [];
+        const fields = [];
+        for (const child of definition.getChildren()) {
+            if (child instanceof nodes_1.TokenNode) {
+                if (child.get().getStr() === ";") {
+                    fieldName = undefined;
+                    annotations = [];
+                }
+                continue;
+            }
+            else if (child.get() instanceof expressions_1.CDSAnnotation) {
+                annotations.push(child);
+            }
+            else if (child.get() instanceof expressions_1.CDSName) {
+                if (definitionNameSeen === false) {
+                    definitionNameSeen = true;
+                    annotations = [];
+                }
+                else {
+                    fieldName = child;
+                }
+            }
+            else if (child.get() instanceof expressions_1.CDSType && fieldName !== undefined) {
+                const semanticType = this.determineSemanticType(child, ddic);
+                const normalizedAnnotations = annotations.map(a => a.concatTokens().replace(/\s/g, ""));
+                fields.push({ name: this.name(fieldName), node: fieldName, annotations: normalizedAnnotations, semanticType });
+                fieldName = undefined;
+                annotations = [];
+            }
+        }
+        const reportedCompanionFields = new Set();
+        for (const field of fields) {
+            if (field.semanticType === undefined) {
+                continue;
+            }
+            const quantity = field.semanticType === "QUAN";
+            const referenceAnnotation = quantity ? "@Semantics.quantity.unitOfMeasure" : "@Semantics.amount.currencyCode";
+            const companionAnnotation = quantity ? "@Semantics.unitOfMeasure: true" : "@Semantics.currencyCode: true";
+            const reference = this.findSemanticReference(field.annotations, field.semanticType);
+            if (reference === undefined) {
+                const kind = quantity ? "quantity" : "amount";
+                const message = `CDS ${kind} field "${field.name}" requires ${referenceAnnotation}`;
+                issues.push(issue_1.Issue.atToken(file, field.node.getFirstToken(), message, this.getMetadata().key, this.conf.severity));
+                continue;
+            }
+            const companion = fields.find(f => f.name.toUpperCase() === reference.toUpperCase());
+            if (companion === undefined) {
+                const kind = quantity ? "unit" : "currency";
+                const message = `CDS field "${field.name}" references missing ${kind} field "${reference}"`;
+                issues.push(issue_1.Issue.atToken(file, field.node.getFirstToken(), message, this.getMetadata().key, this.conf.severity));
+                continue;
+            }
+            const companionKey = field.semanticType + ":" + companion.name.toUpperCase();
+            if (reportedCompanionFields.has(companionKey) === false
+                && this.hasCompanionAnnotation(companion.annotations, field.semanticType) === false) {
+                const message = `CDS field "${companion.name}" requires ${companionAnnotation}`;
+                issues.push(issue_1.Issue.atToken(file, companion.node.getFirstToken(), message, this.getMetadata().key, this.conf.severity));
+                reportedCompanionFields.add(companionKey);
+            }
+        }
+    }
+    determineSemanticType(typeNode, ddic) {
+        var _a;
+        const typeName = typeNode.findDirectExpressions(expressions_1.CDSName).map(n => this.name(n)).join(".");
+        const upper = typeName.toUpperCase();
+        if (upper === "ABAP.QUAN" || KNOWN_QUAN_DATA_ELEMENTS.includes(upper)) {
+            return "QUAN";
+        }
+        else if (upper === "ABAP.CURR" || KNOWN_CURR_DATA_ELEMENTS.includes(upper)) {
+            return "CURR";
+        }
+        const object = ddic.lookup(typeName).object;
+        if (object instanceof objects_1.DataElement) {
+            const dataType = (_a = object.getDataType(this.reg)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+            if (dataType === "QUAN" || dataType === "CURR") {
+                return dataType;
+            }
+        }
+        return undefined;
+    }
+    findSemanticReference(annotations, type) {
+        const expression = type === "QUAN"
+            ? /(?:SEMANTICS\.QUANTITY|SEMANTICS:\{QUANTITY:\{)\.?UNITOFMEASURE:'([^']+)'/i
+            : /(?:SEMANTICS\.AMOUNT|SEMANTICS:\{AMOUNT:\{)\.?CURRENCYCODE:'([^']+)'/i;
+        for (const annotation of annotations) {
+            const match = annotation.match(expression);
+            if (match) {
+                return match[1];
+            }
+        }
+        return undefined;
+    }
+    hasCompanionAnnotation(annotations, type) {
+        if (type === "QUAN") {
+            return annotations.some(a => a.toUpperCase().includes("@SEMANTICS.UNITOFMEASURE:TRUE")
+                || a.toUpperCase().includes("@SEMANTICS:{UNITOFMEASURE:TRUE"));
+        }
+        else {
+            return annotations.some(a => a.toUpperCase().includes("@SEMANTICS.CURRENCYCODE:TRUE")
+                || a.toUpperCase().includes("@SEMANTICS:{CURRENCYCODE:TRUE"));
+        }
+    }
+    checkFields(tree, sources, object, issues, file) {
+        var _a;
+        const associationNames = new Set();
+        for (const association of ((_a = object.getParsedData()) === null || _a === void 0 ? void 0 : _a.associations) || []) {
+            associationNames.add(association.name.toUpperCase());
+            if (association.as) {
+                associationNames.add(association.as.toUpperCase());
+            }
+        }
+        for (const element of tree.findAllExpressionsRecursive(expressions_1.CDSElement)) {
+            const prefixed = element.findDirectExpression(expressions_1.CDSPrefixedName);
+            if (prefixed === undefined) {
+                continue;
+            }
+            const names = prefixed.findDirectExpressions(expressions_1.CDSName);
+            if (names.length === 0) {
+                continue;
+            }
+            const first = this.name(names[0]);
+            if (first === "*" || first.startsWith("$") || first.startsWith("#") || associationNames.has(first.toUpperCase())) {
+                continue;
+            }
+            if (names.length > 1) {
+                const matchingSources = sources.filter(s => s.names.includes(first.toUpperCase()));
+                if (matchingSources.length !== 1) {
+                    continue;
+                }
+                const source = matchingSources[0];
+                const sourceType = source.type;
+                if (!(sourceType instanceof basic_1.StructureType)) {
+                    continue;
+                }
+                const field = this.name(names[1]);
+                if (field !== "*" && sourceType.getComponentByName(field) === undefined) {
+                    issues.push(issue_1.Issue.atToken(file, names[1].getFirstToken(), `CDS field "${field}" not found in "${source.entity}"`, this.getMetadata().key, this.conf.severity));
+                }
+                continue;
+            }
+            // Do not guess across joins or when a dependency is absent.
+            if (sources.length !== 1) {
+                continue;
+            }
+            const source = sources[0];
+            const sourceType = source.type;
+            if (!(sourceType instanceof basic_1.StructureType)) {
+                continue;
+            }
+            if (sourceType.getComponentByName(first) === undefined) {
+                issues.push(issue_1.Issue.atToken(file, names[0].getFirstToken(), `CDS field "${first}" not found in "${source.entity}"`, this.getMetadata().key, this.conf.severity));
+            }
+        }
+    }
+    name(node) {
+        return node.concatTokens().replace(/ /g, "");
+    }
+}
+exports.CDSCheckSyntax = CDSCheckSyntax;
+//# sourceMappingURL=cds_check_syntax.js.map

package/build/src/rules/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./begin_single_include"), exports);
 __exportStar(require("./call_transaction_authority_check"), exports);
 __exportStar(require("./catch_and_raise"), exports);
 __exportStar(require("./cds_association_name"), exports);
+__exportStar(require("./cds_check_syntax"), exports);
 __exportStar(require("./cds_comment_style"), exports);
 __exportStar(require("./cds_field_order"), exports);
 __exportStar(require("./cds_legacy_view"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.120.25",
+    "version": "2.120.27",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",