@abaplint/cli 2.120.26 → 2.120.27

package/build/cli.js

@@ -62507,6 +62507,7 @@ const _abstract_object_1 = __webpack_require__(/*! ./_abstract_object */ "../cor
 const ddic_1 = __webpack_require__(/*! ../ddic */ "../core/build/src/ddic.js");
 const Types = __importStar(__webpack_require__(/*! ../abap/types/basic */ "../core/build/src/abap/types/basic/index.js"));
 const xml_utils_1 = __webpack_require__(/*! ../xml_utils */ "../core/build/src/xml_utils.js");
+const domain_1 = __webpack_require__(/*! ./domain */ "../core/build/src/objects/domain.js");
 class DataElement extends _abstract_object_1.AbstractObject {
     constructor() {
         super(...arguments);
@@ -62537,6 +62538,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();
@@ -62820,6 +62837,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,
@@ -69751,7 +69773,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.26";
+        return "2.120.27";
     }
     getDDICReferences() {
         return this.ddicReferences;
@@ -72415,6 +72437,315 @@ exports.CDSAssociationName = CDSAssociationName;
 
 /***/ },
 
+/***/ "../core/build/src/rules/cds_check_syntax.js"
+/*!***************************************************!*\
+  !*** ../core/build/src/rules/cds_check_syntax.js ***!
+  \***************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CDSCheckSyntax = exports.CDSCheckSyntaxConf = void 0;
+const nodes_1 = __webpack_require__(/*! ../abap/nodes */ "../core/build/src/abap/nodes/index.js");
+const basic_1 = __webpack_require__(/*! ../abap/types/basic */ "../core/build/src/abap/types/basic/index.js");
+const expressions_1 = __webpack_require__(/*! ../cds/expressions */ "../core/build/src/cds/expressions/index.js");
+const ddic_1 = __webpack_require__(/*! ../ddic */ "../core/build/src/ddic.js");
+const issue_1 = __webpack_require__(/*! ../issue */ "../core/build/src/issue.js");
+const objects_1 = __webpack_require__(/*! ../objects */ "../core/build/src/objects/index.js");
+const _basic_rule_config_1 = __webpack_require__(/*! ./_basic_rule_config */ "../core/build/src/rules/_basic_rule_config.js");
+const _irule_1 = __webpack_require__(/*! ./_irule */ "../core/build/src/rules/_irule.js");
+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
+
+/***/ },
+
 /***/ "../core/build/src/rules/cds_comment_style.js"
 /*!****************************************************!*\
   !*** ../core/build/src/rules/cds_comment_style.js ***!
@@ -83509,6 +83840,7 @@ __exportStar(__webpack_require__(/*! ./begin_single_include */ "../core/build/sr
 __exportStar(__webpack_require__(/*! ./call_transaction_authority_check */ "../core/build/src/rules/call_transaction_authority_check.js"), exports);
 __exportStar(__webpack_require__(/*! ./catch_and_raise */ "../core/build/src/rules/catch_and_raise.js"), exports);
 __exportStar(__webpack_require__(/*! ./cds_association_name */ "../core/build/src/rules/cds_association_name.js"), exports);
+__exportStar(__webpack_require__(/*! ./cds_check_syntax */ "../core/build/src/rules/cds_check_syntax.js"), exports);
 __exportStar(__webpack_require__(/*! ./cds_comment_style */ "../core/build/src/rules/cds_comment_style.js"), exports);
 __exportStar(__webpack_require__(/*! ./cds_field_order */ "../core/build/src/rules/cds_field_order.js"), exports);
 __exportStar(__webpack_require__(/*! ./cds_legacy_view */ "../core/build/src/rules/cds_legacy_view.js"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/cli",
-    "version": "2.120.26",
+    "version": "2.120.27",
     "description": "abaplint - Command Line Interface",
     "funding": "https://github.com/sponsors/larshp",
     "bin": {
@@ -39,7 +39,7 @@
     },
     "homepage": "https://abaplint.org",
     "devDependencies": {
-        "@abaplint/core": "^2.120.26",
+        "@abaplint/core": "^2.120.27",
         "@types/chai": "^4.3.20",
         "@types/minimist": "^1.2.5",
         "@types/mocha": "^10.0.10",