@abaplint/cli 2.113.23 → 2.113.24

package/build/cli.js

@@ -36737,6 +36737,10 @@ class AbstractType {
         var _a;
         return (_a = this.data) === null || _a === void 0 ? void 0 : _a.RTTIName;
     }
+    getDescription() {
+        var _a;
+        return (_a = this.data) === null || _a === void 0 ? void 0 : _a.description;
+    }
     getConversionExit() {
         var _a;
         return (_a = this.data) === null || _a === void 0 ? void 0 : _a.conversionExit;
@@ -41327,9 +41331,15 @@ class DDIC {
             return { type: new Types.VoidType(name) };
         }
     }
-    textToType(text, length, decimals, infoText, qualifiedName, conversionExit, ddicName) {
+    textToType(input) {
         // todo: support short strings, and length of different integers, NUMC vs CHAR, min/max length
-        switch (text) {
+        const extra = {
+            qualifiedName: input.qualifiedName,
+            conversionExit: input.conversionExit,
+            ddicName: input.ddicName,
+            description: input.description,
+        };
+        switch (input.text) {
             case "DEC": // 1 <= len <= 31
             case "D16F": // 1 <= len <= 31
             case "D16D":
@@ -41338,45 +41348,45 @@ class DDIC {
             case "DF34_DEC": // 1 <= len <= 31
             case "CURR": // 1 <= len <= 31
             case "QUAN": // 1 <= len <= 31
-                if (length === undefined) {
-                    return new Types.UnknownType(text + " unknown length, " + infoText, infoText);
+                if (input.length === undefined) {
+                    return new Types.UnknownType(input.text + " unknown length, " + input.infoText, input.infoText);
                 }
-                else if (decimals === undefined) {
-                    return new Types.PackedType(parseInt(length, 10), 0, { qualifiedName, conversionExit, ddicName });
+                else if (input.decimals === undefined) {
+                    return new Types.PackedType(parseInt(input.length, 10), 0, extra);
                 }
-                return new Types.PackedType(parseInt(length, 10), parseInt(decimals, 10), { qualifiedName, conversionExit, ddicName });
+                return new Types.PackedType(parseInt(input.length, 10), parseInt(input.decimals, 10), extra);
             case "ACCP":
-                return new Types.CharacterType(6, { qualifiedName, conversionExit, ddicName }); // YYYYMM
+                return new Types.CharacterType(6, extra); // YYYYMM
             case "LANG":
-                return new Types.CharacterType(1, { qualifiedName, conversionExit, ddicName });
+                return new Types.CharacterType(1, extra);
             case "CLNT":
-                return new Types.CharacterType(3, { qualifiedName, conversionExit, ddicName });
+                return new Types.CharacterType(3, extra);
             case "CUKY":
-                return new Types.CharacterType(5, { qualifiedName, conversionExit, ddicName });
+                return new Types.CharacterType(5, extra);
             case "UNIT": // 2 <= len <= 3
-                return new Types.CharacterType(3, { qualifiedName, conversionExit, ddicName });
+                return new Types.CharacterType(3, extra);
             case "UTCLONG":
-                return new Types.CharacterType(27, { qualifiedName, conversionExit, ddicName });
+                return new Types.CharacterType(27, extra);
             case "NUMC": // 1 <= len <= 255
-                if (length === undefined) {
-                    return new Types.UnknownType(text + " unknown length", infoText);
+                if (input.length === undefined) {
+                    return new Types.UnknownType(input.text + " unknown length", input.infoText);
                 }
-                return new Types.NumericType(parseInt(length, 10), qualifiedName);
+                return new Types.NumericType(parseInt(input.length, 10), input.qualifiedName);
             case "CHAR": // 1 <= len <= 30000 (1333 for table fields)
             case "LCHR": // 256 <= len <= 32000
-                if (length === undefined) {
-                    return new Types.UnknownType(text + " unknown length", infoText);
+                if (input.length === undefined) {
+                    return new Types.UnknownType(input.text + " unknown length", input.infoText);
                 }
-                return new Types.CharacterType(parseInt(length, 10), { qualifiedName, conversionExit, ddicName });
+                return new Types.CharacterType(parseInt(input.length, 10), extra);
             case "RAW": // 1 <= len <= 32000
             case "LRAW": // 256 <= len <= 32000
-                if (length === undefined) {
-                    return new Types.UnknownType(text + " unknown length", infoText);
+                if (input.length === undefined) {
+                    return new Types.UnknownType(input.text + " unknown length", input.infoText);
                 }
-                return new Types.HexType(parseInt(length, 10), qualifiedName);
+                return new Types.HexType(parseInt(input.length, 10), input.qualifiedName);
             case "TIMN": // Native HANA
             case "TIMS":
-                return new Types.TimeType({ qualifiedName: qualifiedName }); //HHMMSS
+                return new Types.TimeType({ qualifiedName: input.qualifiedName }); //HHMMSS
             case "DECFLOAT16": // len = 16
             case "DECFLOAT34": // len = 34
             case "D16R": // len = 16
@@ -41384,37 +41394,37 @@ class DDIC {
             case "DF16_RAW": // len = 16
             case "DF34_RAW": // len = 34
             case "FLTP": // len = 16
-                if (length === undefined) {
-                    return new Types.UnknownType(text + " unknown length", infoText);
+                if (input.length === undefined) {
+                    return new Types.UnknownType(input.text + " unknown length", input.infoText);
                 }
-                return new Types.FloatingPointType(parseInt(length, 10), qualifiedName);
+                return new Types.FloatingPointType(parseInt(input.length, 10), input.qualifiedName);
             case "DATN": // Native HANA
             case "DATS":
-                return new Types.DateType({ qualifiedName: qualifiedName }); //YYYYMMDD
+                return new Types.DateType({ qualifiedName: input.qualifiedName }); //YYYYMMDD
             case "INT1":
             case "INT2":
             case "INT4":
-                return Types.IntegerType.get({ qualifiedName: qualifiedName });
+                return Types.IntegerType.get({ qualifiedName: input.qualifiedName });
             case "INT8":
-                return new Types.Integer8Type({ qualifiedName: qualifiedName });
+                return new Types.Integer8Type({ qualifiedName: input.qualifiedName });
             case "SSTR": // 1 <= len <= 1333
             case "SSTRING": // 1 <= len <= 1333
             case "STRG": // 256 <= len
             case "STRING": // 256 <= len
-                return Types.StringType.get({ qualifiedName: qualifiedName });
+                return Types.StringType.get({ qualifiedName: input.qualifiedName });
             case "RSTR": // 256 <= len
             case "RAWSTRING": // 256 <= len
             case "GEOM_EWKB":
-                return new Types.XStringType({ qualifiedName: qualifiedName });
+                return new Types.XStringType({ qualifiedName: input.qualifiedName });
             case "D16S":
             case "D34S":
             case "DF16_SCL":
             case "DF34_SCL":
             case "PREC":
             case "VARC":
-                return new Types.UnknownType(text + " is an obsolete data type", infoText);
+                return new Types.UnknownType(input.text + " is an obsolete data type", input.infoText);
             default:
-                return new Types.UnknownType(text + " unknown", infoText);
+                return new Types.UnknownType(input.text + " unknown", input.infoText);
         }
     }
 }
@@ -42709,6 +42719,9 @@ class LSPLookup {
         if (variable.getType().getDDICName() !== undefined) {
             value += "\n\nDDIC Name: ```" + variable.getType().getDDICName() + "```";
         }
+        if (variable.getType().getDescription() !== undefined) {
+            value += "\n\nDescription: " + variable.getType().getDescription();
+        }
         return value;
     }
     static referenceHover(ref, scope, reg) {
@@ -46733,6 +46746,7 @@ class DataElement extends _abstract_object_1.AbstractObject {
         return (_a = this.parsedXML) === null || _a === void 0 ? void 0 : _a.texts;
     }
     parseType(reg) {
+        var _a;
         const references = [];
         let lookup = undefined;
         if (this.parsedXML === undefined) {
@@ -46761,7 +46775,16 @@ class DataElement extends _abstract_object_1.AbstractObject {
                     lookup = { type: new Types.UnknownType("DATATYPE unexpectely empty in " + this.getName()) };
                 }
                 else {
-                    lookup = { type: ddic.textToType(this.parsedXML.datatype, this.parsedXML.leng, this.parsedXML.decimals, this.getName(), this.getName(), undefined, this.getName()) };
+                    lookup = { type: ddic.textToType({
+                            text: this.parsedXML.datatype,
+                            length: this.parsedXML.leng,
+                            decimals: this.parsedXML.decimals,
+                            infoText: this.getName(),
+                            qualifiedName: this.getName(),
+                            conversionExit: undefined,
+                            ddicName: this.getName(),
+                            description: (_a = this.parsedXML.texts) === null || _a === void 0 ? void 0 : _a.heading,
+                        }) };
                 }
             }
         }
@@ -46914,7 +46937,15 @@ class Domain extends _abstract_object_1.AbstractObject {
             return new Types.UnknownType("Domain " + this.getName() + " parser error", this.getName());
         }
         const ddic = new ddic_1.DDIC(reg);
-        return ddic.textToType(this.parsedXML.datatype, this.parsedXML.length, this.parsedXML.decimals, this.getName(), dataElement, this.parsedXML.conversionExit, dataElement);
+        return ddic.textToType({
+            text: this.parsedXML.datatype,
+            length: this.parsedXML.length,
+            decimals: this.parsedXML.decimals,
+            infoText: this.getName(),
+            qualifiedName: dataElement,
+            conversionExit: this.parsedXML.conversionExit,
+            ddicName: dataElement,
+        });
     }
     parse() {
         var _a, _b, _c, _d, _e, _f, _g;
@@ -51428,7 +51459,12 @@ class Table extends _abstract_object_1.AbstractObject {
                 const length = field.LENG ? field.LENG : field.INTLEN;
                 components.push({
                     name: field.FIELDNAME,
-                    type: ddic.textToType(datatype, length, field.DECIMALS, this.getName() + "-" + field.FIELDNAME)
+                    type: ddic.textToType({
+                        text: datatype,
+                        length: length,
+                        decimals: field.DECIMALS,
+                        infoText: this.getName() + "-" + field.FIELDNAME,
+                    })
                 });
             }
             else {
@@ -51663,7 +51699,12 @@ class TableType extends _abstract_object_1.AbstractObject {
                 type = new Types.UnknownType("Table Type, empty DATATYPE" + this.getName(), this.getName());
             }
             else {
-                const row = ddic.textToType(this.parsedXML.datatype, this.parsedXML.leng, this.parsedXML.decimals, this.getName());
+                const row = ddic.textToType({
+                    text: this.parsedXML.datatype,
+                    length: this.parsedXML.leng,
+                    decimals: this.parsedXML.decimals,
+                    infoText: this.getName(),
+                });
                 type = new Types.TableType(row, tableOptions, this.getName());
             }
         }
@@ -52780,7 +52821,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.113.23";
+        return "2.113.24";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/cli",
-    "version": "2.113.23",
+    "version": "2.113.24",
     "description": "abaplint - Command Line Interface",
     "funding": "https://github.com/sponsors/larshp",
     "bin": {
@@ -38,7 +38,7 @@
     },
     "homepage": "https://abaplint.org",
     "devDependencies": {
-        "@abaplint/core": "^2.113.23",
+        "@abaplint/core": "^2.113.24",
         "@types/chai": "^4.3.20",
         "@types/glob": "^8.1.0",
         "@types/minimist": "^1.2.5",