@abaplint/core 2.120.26 → 2.120.28

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/2_statements/expressions/sql_group_by.js

@@ -9,7 +9,7 @@ const sql_field_1 = require("./sql_field");
 const sql_grouping_sets_1 = require("./sql_grouping_sets");
 class SQLGroupBy extends combi_1.Expression {
     getRunnable() {
-        const fieldName = (0, combi_1.alt)(sql_field_name_1.SQLFieldName, dynamic_1.Dynamic);
+        const fieldName = (0, combi_1.seq)((0, combi_1.stopBefore)("ORDER", "BY"), (0, combi_1.alt)(sql_field_name_1.SQLFieldName, dynamic_1.Dynamic));
         const expr = (0, combi_1.ver)(version_1.Release.v740sp02, sql_field_1.SQLField, { also: combi_1.AlsoIn.OpenABAP });
         const newGroup = (0, combi_1.ver)(version_1.Release.v740sp02, (0, combi_1.seq)("GROUP BY", expr, (0, combi_1.altPrio)((0, combi_1.plus)((0, combi_1.seq)(",", expr)), (0, combi_1.optPrio)((0, combi_1.plus)(fieldName)))), { also: combi_1.AlsoIn.OpenABAP });
         const old = (0, combi_1.seq)((0, combi_1.plus)((0, combi_1.seq)(fieldName, ",")), fieldName);

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

@@ -25,7 +25,7 @@ function checkDatabaseFields(fields, dbSources, input, token) {
         if (field === "*") {
             continue;
         }
-        if (/^\w+$/.test(field) && type.getComponentByName(field) === undefined) {
+        if (/^[A-Z_]\w*$/i.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;

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

@@ -74,7 +74,7 @@ class Select {
             return;
         }
         (0, _check_database_fields_1.checkDatabaseFields)(fields.map(field => field.code), dbSources, input, node.getFirstToken());
-        const intoExpression = this.handleInto(node, input, fields, dbSources);
+        const intoExpression = this.handleInto(node, input, fields, dbSources, from);
         const fae = node.findDirectExpression(Expressions.SQLForAllEntries);
         if (fae) {
             input.scope.push(_scope_type_1.ScopeType.OpenSQL, "SELECT", token.getStart(), input.filename);
@@ -235,12 +235,12 @@ class Select {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
         }
     }
-    static handleInto(node, input, fields, dbSources) {
+    static handleInto(node, input, fields, dbSources, from) {
         const intoTable = node.findDirectExpression(Expressions.SQLIntoTable);
         if (intoTable) {
             const inline = intoTable.findFirstExpression(Expressions.InlineData);
             if (inline) {
-                inline_data_1.InlineData.runSyntax(inline, input, this.buildTableType(fields, dbSources, input.scope));
+                inline_data_1.InlineData.runSyntax(inline, input, this.buildTableType(fields, dbSources, input.scope, from));
             }
             return intoTable;
         }
@@ -388,11 +388,36 @@ class Select {
             return basic_1.VoidType.get("SELECT_todo13");
         }
     }
-    static buildTableType(fields, dbSources, scope) {
-        if (dbSources.length !== 1) {
+    static buildTableType(fields, dbSources, scope, from) {
+        var _a;
+        const tableOptions = { withHeader: false, keyType: basic_1.TableKeyType.empty };
+        if (dbSources.length > 1) {
+            const sourceInfos = this.buildDatabaseSourceInfos(from, dbSources);
+            if (fields.length === 1 && fields[0].code === "*") {
+                const components = [];
+                for (const info of sourceInfos) {
+                    const type = (_a = info.source) === null || _a === void 0 ? void 0 : _a.parseType(scope.getRegistry());
+                    if (!(type instanceof basic_1.StructureType)) {
+                        return basic_1.VoidType.get("SELECT_todo3");
+                    }
+                    components.push({ name: info.alias || info.name, type });
+                }
+                return new basic_1.TableType(new basic_1.StructureType(components), tableOptions, undefined);
+            }
+            const components = [];
+            for (const field of fields) {
+                const type = this.findFieldType(field.code, sourceInfos, scope);
+                if (type === undefined) {
+                    return basic_1.VoidType.get("SELECT_todo3");
+                }
+                const name = field.as || field.code.split("~").pop();
+                components.push({ name, type });
+            }
+            return new basic_1.TableType(new basic_1.StructureType(components), tableOptions, undefined);
+        }
+        else if (dbSources.length !== 1) {
             return basic_1.VoidType.get("SELECT_todo3");
         }
-        const tableOptions = { withHeader: false, keyType: basic_1.TableKeyType.empty };
         if (dbSources[0] === undefined) {
             // then its a voided table
             return new basic_1.TableType(basic_1.VoidType.get("SELECT_todo4"), tableOptions, undefined);
@@ -418,6 +443,39 @@ class Select {
         }
         return basic_1.VoidType.get("SELECT_todo7");
     }
+    static buildDatabaseSourceInfos(from, dbSources) {
+        const fromSources = from.findAllExpressions(Expressions.SQLFromSource);
+        return dbSources.map((source, index) => {
+            var _a, _b;
+            const fromSource = fromSources[index];
+            const name = ((_a = fromSource === null || fromSource === void 0 ? void 0 : fromSource.findFirstExpression(Expressions.DatabaseTable)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr().replace(/^\*/, "").toUpperCase()) || "";
+            const alias = ((_b = fromSource === null || fromSource === void 0 ? void 0 : fromSource.findDirectExpression(Expressions.SQLAsName)) === null || _b === void 0 ? void 0 : _b.concatTokens().toUpperCase()) || "";
+            return { source, name, alias };
+        });
+    }
+    static findFieldType(code, sourceInfos, scope) {
+        var _a;
+        const separator = code.indexOf("~");
+        const qualifier = separator >= 0 ? code.substring(0, separator) : undefined;
+        const fieldName = separator >= 0 ? code.substring(separator + 1) : code;
+        const candidates = qualifier === undefined
+            ? sourceInfos
+            : sourceInfos.filter(info => info.alias === qualifier || info.name === qualifier);
+        for (const candidate of candidates) {
+            let type = (_a = candidate.source) === null || _a === void 0 ? void 0 : _a.parseType(scope.getRegistry());
+            for (const component of fieldName.split("-")) {
+                if (!(type instanceof basic_1.StructureType)) {
+                    type = undefined;
+                    break;
+                }
+                type = type.getComponentByName(component);
+            }
+            if (type) {
+                return type;
+            }
+        }
+        return undefined;
+    }
     static findFields(node, input) {
         var _a, _b;
         let expr = undefined;
@@ -431,7 +489,7 @@ class Select {
             let code = field.concatTokens().toUpperCase();
             const as = ((_b = field.findDirectExpression(Expressions.SQLAsName)) === null || _b === void 0 ? void 0 : _b.concatTokens()) || "";
             if (as !== "") {
-                code = code.replace(" AS " + as, "");
+                code = code.replace(" AS " + as.toUpperCase(), "");
             }
             ret.push({ code, as, expression: field });
         }

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

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueBody = void 0;
+const nodes_1 = require("../../nodes");
 const Expressions = __importStar(require("../../2_statements/expressions"));
 const for_1 = require("./for");
 const source_1 = require("./source");
@@ -43,7 +44,7 @@ const basic_1 = require("../../types/basic");
 const _syntax_input_1 = require("../_syntax_input");
 class ValueBody {
     static runSyntax(node, input, targetType) {
-        var _a, _b;
+        var _a, _b, _c;
         if (node === undefined) {
             return targetType;
         }
@@ -60,26 +61,45 @@ class ValueBody {
             }
         }
         const fields = new Set();
-        for (const s of node.findDirectExpressions(Expressions.FieldAssignment)) {
-            field_assignment_1.FieldAssignment.runSyntax(s, input, targetType);
-            if (node.findDirectExpression(Expressions.ValueBodyLine) === undefined) {
-                // todo: refine, still needs to be checked when there are table lines
-                const fieldname = (_a = s.findDirectExpression(Expressions.FieldSub)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase();
+        const hasTableLines = node.findDirectExpression(Expressions.ValueBodyLine) !== undefined;
+        for (const child of node.getChildren()) {
+            if (!(child instanceof nodes_1.ExpressionNode)) {
+                continue;
+            }
+            else if (child.get() instanceof Expressions.FieldAssignment) {
+                const fieldname = (_a = child.findDirectExpression(Expressions.FieldSub)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase();
+                if (fieldname && hasTableLines === false && fields.has(fieldname)) {
+                    const message = "Duplicate field assignment";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, child.getFirstToken(), message));
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+                }
                 if (fieldname) {
-                    if (fields.has(fieldname)) {
+                    fields.add(fieldname);
+                }
+            }
+            else if (child.get() instanceof Expressions.ValueBodyLine) {
+                const rowFields = new Set(fields);
+                for (const assignment of child.findDirectExpressions(Expressions.FieldAssignment)) {
+                    const fieldname = (_b = assignment.findDirectExpression(Expressions.FieldSub)) === null || _b === void 0 ? void 0 : _b.concatTokens().toUpperCase();
+                    if (fieldname && rowFields.has(fieldname)) {
                         const message = "Duplicate field assignment";
-                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, s.getFirstToken(), message));
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, assignment.getFirstToken(), message));
                         return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                     }
-                    fields.add(fieldname);
+                    if (fieldname) {
+                        rowFields.add(fieldname);
+                    }
                 }
             }
         }
+        for (const s of node.findDirectExpressions(Expressions.FieldAssignment)) {
+            field_assignment_1.FieldAssignment.runSyntax(s, input, targetType);
+        }
         let type = undefined; // todo, this is only correct if there is a single source in the body
         for (const s of node.findDirectExpressions(Expressions.Source)) {
             type = source_1.Source.runSyntax(s, input, type);
         }
-        for (const s of ((_b = node.findDirectExpression(Expressions.ValueBase)) === null || _b === void 0 ? void 0 : _b.findDirectExpressions(Expressions.Source)) || []) {
+        for (const s of ((_c = node.findDirectExpression(Expressions.ValueBase)) === null || _c === void 0 ? void 0 : _c.findDirectExpressions(Expressions.Source)) || []) {
             type = source_1.Source.runSyntax(s, input, type);
         }
         for (const foo of node.findDirectExpressions(Expressions.ValueBodyLine)) {

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.26";
+        return "2.120.28";
     }
     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.26",
+    "version": "2.120.28",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",