@abaplint/core 2.93.85 → 2.93.87

package/build/abaplint.d.ts

@@ -359,6 +359,7 @@ declare namespace BasicTypes {
         IStructureComponent,
         StructureType,
         TableAccessType,
+        ITableKey,
         ITableOptions,
         TableType_2 as TableType,
         TimeType,
@@ -3551,11 +3552,17 @@ declare interface ISyntaxSettings {
     globalMacros?: string[];
 }
 
-declare type ITableOptions = {
+declare type ITableKey = {
+    name: string;
     type?: TableAccessType;
-    keyFields?: string[];
-    isUnique?: boolean;
+    keyFields: string[];
+    isUnique: boolean;
+};
+
+declare type ITableOptions = {
     withHeader: boolean;
+    primaryKey?: ITableKey;
+    secondary?: ITableKey[];
 };
 
 declare interface ITextDocumentPositionParams {

package/build/src/abap/2_statements/statement_parser.js

@@ -108,6 +108,7 @@ class StatementParser {
                 const concat = statement.concatTokens().toUpperCase();
                 if (concat.startsWith("CALL METHOD ") === false
                     && concat.startsWith("RAISE EXCEPTION TYPE ") === false
+                    && concat.startsWith("LOOP AT ") === false
                     && concat.startsWith("CALL FUNCTION ") === false) {
                     for (const { first, second } of this.buildSplits(statement.getTokens())) {
                         if (second.length === 1) {

package/build/src/abap/5_syntax/basic_types.js

@@ -262,34 +262,55 @@ class BasicTypes {
         return undefined;
     }
     parseTable(node, name) {
-        var _a, _b;
+        var _a, _b, _c;
         const typename = node.findFirstExpression(Expressions.TypeName);
         const text = (_a = node.findFirstExpression(Expressions.TypeTable)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase();
         if (text === undefined) {
             return undefined;
         }
         let type = undefined;
-        if (text.includes(" STANDARD TABLE ")) {
+        if (text.startsWith("TYPE STANDARD TABLE ") || text.startsWith("LIKE STANDARD TABLE ")) {
             type = basic_1.TableAccessType.standard;
         }
-        else if (text.includes(" SORTED TABLE ")) {
+        else if (text.startsWith("TYPE SORTED TABLE ") || text.startsWith("LIKE SORTED TABLE ")) {
             type = basic_1.TableAccessType.sorted;
         }
-        else if (text.includes(" HASHED TABLE ")) {
+        else if (text.startsWith("TYPE HASHED TABLE ") || text.startsWith("LIKE HASHED TABLE ")) {
             type = basic_1.TableAccessType.hashed;
         }
-        const keyFields = [];
-        if (type) {
-            const keys = node.findFirstExpression(expressions_1.TypeTableKey);
-            for (const k of (keys === null || keys === void 0 ? void 0 : keys.findDirectExpressions(expressions_1.FieldSub)) || []) {
-                keyFields.push(k.concatTokens().toUpperCase());
-            }
+        const typeTableKeys = node.findAllExpressions(expressions_1.TypeTableKey);
+        const firstKey = typeTableKeys[0];
+        const primaryKey = {
+            name: "primary_key",
+            type: type,
+            isUnique: (firstKey === null || firstKey === void 0 ? void 0 : firstKey.concatTokens().toUpperCase().includes("WITH UNIQUE ")) === true,
+            keyFields: [],
+        };
+        for (const k of (firstKey === null || firstKey === void 0 ? void 0 : firstKey.findDirectExpressions(expressions_1.FieldSub)) || []) {
+            primaryKey.keyFields.push(k.concatTokens().toUpperCase());
+        }
+        const secondaryKeys = [];
+        for (let i = 1; i < typeTableKeys.length; i++) {
+            const row = typeTableKeys[i];
+            const name = (_b = row.findDirectExpression(expressions_1.Field)) === null || _b === void 0 ? void 0 : _b.concatTokens();
+            if (name === undefined) {
+                continue;
+            }
+            const secondary = {
+                name: name,
+                type: row.findDirectTokenByText("SORTED") ? basic_1.TableAccessType.sorted : basic_1.TableAccessType.hashed,
+                isUnique: (row === null || row === void 0 ? void 0 : row.concatTokens().toUpperCase().includes("WITH UNIQUE ")) === true,
+                keyFields: [],
+            };
+            for (const k of (row === null || row === void 0 ? void 0 : row.findDirectExpressions(expressions_1.FieldSub)) || []) {
+                secondary.keyFields.push(k.concatTokens().toUpperCase());
+            }
+            secondaryKeys.push(secondary);
         }
         const options = {
             withHeader: text.includes(" WITH HEADER LINE"),
-            type: type,
-            isUnique: text.includes(" WITH UNIQUE"),
-            keyFields: keyFields,
+            primaryKey: primaryKey,
+            secondary: secondaryKeys,
         };
         let found = undefined;
         if (text.startsWith("TYPE TABLE OF REF TO ")
@@ -357,7 +378,7 @@ class BasicTypes {
         else if (typename && (text.startsWith("TYPE TABLE FOR CREATE ")
             || text.startsWith("TYPE TABLE FOR UPDATE "))) {
             const name = typename.concatTokens();
-            const type = (_b = this.scope.getDDIC().lookupDDLS(name)) === null || _b === void 0 ? void 0 : _b.type;
+            const type = (_c = this.scope.getDDIC().lookupDDLS(name)) === null || _c === void 0 ? void 0 : _c.type;
             if (type) {
                 return new Types.TableType(new basic_1.VoidType("RapTodo"), options);
             }

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

@@ -23,13 +23,14 @@ class TableType extends _abstract_type_1.AbstractType {
         return this.options.withHeader;
     }
     getAccessType() {
-        return this.options.type;
+        var _a;
+        return (_a = this.options.primaryKey) === null || _a === void 0 ? void 0 : _a.type;
     }
     getRowType() {
         return this.rowType;
     }
     toABAP() {
-        // this is used for downport, so use default key for now
+        // todo, this is used for downport, so use default key for now
         return "STANDARD TABLE OF " + this.rowType.toABAP() + " WITH DEFAULT KEY";
     }
     toText(level) {

package/build/src/registry.js

@@ -63,7 +63,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.93.85";
+        return "2.93.87";
     }
     getDDICReferences() {
         return this.references;

package/build/src/rules/downport.js

@@ -225,6 +225,8 @@ Only one transformation is applied to a statement at a time, so multiple steps m
                 ret.push(Issue.atStatement(lowFile, lowStatements[0], message, this.getMetadata().key));
                 */
                 // hmm, add some way to disable lazyUnknown() in statement_parser.ts
+                // alternatively explicit enable it in vscode, its only relevant when a user is
+                // actively editing the files
                 continue;
             }
             for (let i = 0; i < lowStatements.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.93.85",
+    "version": "2.93.87",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",