@abaplint/core 2.113.32 → 2.113.34

package/build/abaplint.d.ts

@@ -1630,7 +1630,7 @@ declare class DDIC {
     } | undefined;
     /** lookup with voiding and unknown types */
     lookup(name: string): ILookupResult;
-    lookupDomain(name: string, dataElement?: string): ILookupResult;
+    lookupDomain(name: string, dataElement?: string, description?: string): ILookupResult;
     lookupDataElement(name: string | undefined): ILookupResult;
     lookupTableOrView(name: string | undefined): ILookupResult;
     /** this method only looks up the object, does not parse the type */
@@ -1810,7 +1810,7 @@ declare class Domain extends AbstractObject {
         allowNamespace: boolean;
     };
     setDirty(): void;
-    parseType(reg: IRegistry, dataElement?: string): AbstractType;
+    parseType(reg: IRegistry, dataElement?: string, description?: string): AbstractType;
     parse(): {
         updated: boolean;
         runtime: number;
@@ -5108,6 +5108,7 @@ declare type ParsedDataDefinition = {
     fields: {
         key: boolean;
         name: string;
+        prefix: string;
         annotations: string[];
     }[];
     sources: {

package/build/src/cds/cds_determine_types.js

@@ -2,20 +2,71 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CDSDetermineTypes = void 0;
 const basic_1 = require("../abap/types/basic");
+const ddic_1 = require("../ddic");
 class CDSDetermineTypes {
-    parseType(_reg, parsedData) {
+    parseType(reg, parsedData) {
+        const ddic = new ddic_1.DDIC(reg);
         if ((parsedData === null || parsedData === void 0 ? void 0 : parsedData.fields.length) === 0) {
             return new basic_1.VoidType("DDLS:todo");
         }
         else {
             const components = [];
             for (const f of (parsedData === null || parsedData === void 0 ? void 0 : parsedData.fields) || []) {
-                components.push({
-                    name: f.name,
-                    type: new basic_1.VoidType("DDLS:fieldname"),
-                });
+                if (f.prefix !== "") {
+                    const source = parsedData.sources.find((s) => { var _a; return ((_a = s.as) === null || _a === void 0 ? void 0 : _a.toUpperCase()) === f.prefix.toUpperCase(); });
+                    if ((source === null || source === void 0 ? void 0 : source.name) === undefined) {
+                        components.push({
+                            name: f.name,
+                            type: new basic_1.UnknownType("CDS parser error, unknown source"),
+                        });
+                        continue;
+                    }
+                    const lookup = ddic.lookupTableOrView(source.name);
+                    if (lookup.type) {
+                        if (lookup.type instanceof basic_1.StructureType) {
+                            const type = lookup.type.getComponentByName(f.name);
+                            if (type) {
+                                components.push({
+                                    name: f.name,
+                                    type: type,
+                                });
+                            }
+                            else {
+                                components.push({
+                                    name: f.name,
+                                    type: new basic_1.UnknownType(f.name + " not found in " + source.name + ", CDSDetermineTypes"),
+                                });
+                            }
+                        }
+                        else {
+                            // its void or unknown
+                            components.push({
+                                name: f.name,
+                                type: lookup.type,
+                            });
+                        }
+                    }
+                    else if (reg.inErrorNamespace(source.name)) {
+                        components.push({
+                            name: f.name,
+                            type: new basic_1.UnknownType(source.name + " not found, CDSDetermineTypes"),
+                        });
+                    }
+                    else {
+                        components.push({
+                            name: f.name,
+                            type: new basic_1.VoidType(source.name),
+                        });
+                    }
+                }
+                else {
+                    components.push({
+                        name: f.name,
+                        type: new basic_1.VoidType("DDLS:fieldname"),
+                    });
+                }
             }
-            return new basic_1.StructureType(components);
+            return new basic_1.StructureType(components, parsedData.definitionName, parsedData.definitionName, parsedData.description);
         }
     }
 }

package/build/src/ddic.js

@@ -199,10 +199,10 @@ class DDIC {
             return { type: new Types.VoidType(name) };
         }
     }
-    lookupDomain(name, dataElement) {
+    lookupDomain(name, dataElement, description) {
         const found = this.reg.getObject("DOMA", name);
         if (found) {
-            return { type: found.parseType(this.reg, dataElement), object: found };
+            return { type: found.parseType(this.reg, dataElement, description), object: found };
         }
         else if (this.reg.inErrorNamespace(name)) {
             return { type: new Types.UnknownType(name + ", lookupDomain"), object: undefined };

package/build/src/objects/data_definition.js

@@ -126,6 +126,7 @@ class DataDefinition extends _abstract_object_1.AbstractObject {
             expr = tree.findFirstExpression(expressions_1.CDSDefineProjection);
         }
         for (const e of (expr === null || expr === void 0 ? void 0 : expr.findDirectExpressions(expressions_1.CDSElement)) || []) {
+            let prefix = "";
             let found = (_a = e.findDirectExpression(expressions_1.CDSAs)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(expressions_1.CDSName);
             if (found === undefined) {
                 const list = e.findAllExpressions(expressions_1.CDSName);
@@ -134,6 +135,9 @@ class DataDefinition extends _abstract_object_1.AbstractObject {
                 }
                 else {
                     found = list[list.length - 1];
+                    if (list.length > 1) {
+                        prefix = list[0].concatTokens();
+                    }
                 }
             }
             if (found === undefined) {
@@ -150,6 +154,7 @@ class DataDefinition extends _abstract_object_1.AbstractObject {
             this.parsedData.fields.push({
                 name: name,
                 annotations: annotations,
+                prefix: prefix,
                 key: e.findDirectTokenByText("KEY") !== undefined,
             });
         }

package/build/src/objects/data_element.js

@@ -51,7 +51,7 @@ class DataElement extends _abstract_object_1.AbstractObject {
                     lookup = { type: new Types.UnknownType("DOMNAME unexpectely empty in " + this.getName()) };
                 }
                 else {
-                    lookup = ddic.lookupDomain(this.parsedXML.domname, this.getName());
+                    lookup = ddic.lookupDomain(this.parsedXML.domname, this.getName(), this.getDescription());
                 }
             }
             else if (this.parsedXML.refkind === "R") {

package/build/src/objects/domain.js

@@ -27,7 +27,7 @@ class Domain extends _abstract_object_1.AbstractObject {
         this.parsedXML = undefined;
         super.setDirty();
     }
-    parseType(reg, dataElement) {
+    parseType(reg, dataElement, description) {
         // dont cache the DOMA parsed type, they are cached on DTEL level
         // also note that the type carries the name of the DTEL
         if (this.parsedXML === undefined) {
@@ -45,6 +45,7 @@ class Domain extends _abstract_object_1.AbstractObject {
             qualifiedName: dataElement,
             conversionExit: this.parsedXML.conversionExit,
             ddicName: dataElement,
+            description: description,
         });
     }
     parse() {

package/build/src/registry.js

@@ -67,7 +67,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.113.32";
+        return "2.113.34";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.113.32",
+    "version": "2.113.34",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -53,10 +53,10 @@
         "@microsoft/api-extractor": "^7.47.11",
         "@types/chai": "^4.3.20",
         "@types/mocha": "^10.0.9",
-        "@types/node": "^22.8.1",
+        "@types/node": "^22.8.4",
         "chai": "^4.5.0",
         "eslint": "^9.13.0",
-        "mocha": "^10.7.3",
+        "mocha": "^10.8.1",
         "c8": "^10.1.2",
         "source-map-support": "^0.5.21",
         "ts-json-schema-generator": "^2.3.0",