@abaplint/core 2.113.23 → 2.113.24

package/build/abaplint.d.ts

@@ -115,6 +115,7 @@ export declare abstract class AbstractType {
     /** fully qualified symbolic name of the type */
     getQualifiedName(): string | undefined;
     getRTTIName(): string | undefined;
+    getDescription(): string | undefined;
     getConversionExit(): string | undefined;
     getDDICName(): string | undefined;
     abstract toText(level: number): string;
@@ -130,6 +131,7 @@ declare type AbstractTypeData = {
     derivedFromConstant?: boolean;
     ddicName?: string;
     RTTIName?: string;
+    description?: string;
 };
 
 declare class ActivationVariant extends AbstractObject {
@@ -1632,7 +1634,16 @@ declare class DDIC {
     lookupTable(name: string | undefined): AbstractType;
     private lookupView;
     lookupTableType(name: string | undefined): ILookupResult;
-    textToType(text: string | undefined, length: string | undefined, decimals: string | undefined, infoText: string, qualifiedName?: string, conversionExit?: string, ddicName?: string): AbstractType;
+    textToType(input: {
+        text: string | undefined;
+        length: string | undefined;
+        decimals: string | undefined;
+        infoText: string;
+        qualifiedName?: string;
+        conversionExit?: string;
+        ddicName?: string;
+        description?: string;
+    }): AbstractType;
 }
 
 declare enum DDLKind {

package/build/src/abap/types/basic/_abstract_type.js

@@ -17,6 +17,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;

package/build/src/ddic.js

@@ -304,9 +304,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":
@@ -315,45 +321,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
@@ -361,37 +367,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);
         }
     }
 }

package/build/src/lsp/_lookup.js

@@ -185,6 +185,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) {

package/build/src/objects/data_element.js

@@ -38,6 +38,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) {
@@ -66,7 +67,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,
+                        }) };
                 }
             }
         }

package/build/src/objects/domain.js

@@ -37,7 +37,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;

package/build/src/objects/table.js

@@ -221,7 +221,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 {

package/build/src/objects/table_type.js

@@ -140,7 +140,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());
             }
         }

package/build/src/registry.js

@@ -67,7 +67,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/core",
-    "version": "2.113.23",
+    "version": "2.113.24",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",