@abaplint/core 2.113.247 → 2.114.1

package/build/abaplint.d.ts

@@ -1,7 +1,7 @@
 import * as LServer from 'vscode-languageserver-types';
 import { WorkspaceEdit } from 'vscode-languageserver-types';
 
-export declare class ABAPFile extends AbstractFile {
+export declare class ABAPFile extends AbstractFile implements IABAPFile {
     private readonly tokens;
     private readonly statements;
     private readonly structure;
@@ -9,8 +9,8 @@ export declare class ABAPFile extends AbstractFile {
     private readonly info;
     constructor(file: IFile, tokens: readonly Token[], statements: readonly StatementNode[], structure: StructureNode | undefined, info: IABAPFileInformation);
     getRaw(): string;
-    getInfo(): IABAPFileInformation;
     getRawRows(): string[];
+    getInfo(): IABAPFileInformation;
     getStructure(): StructureNode | undefined;
     getTokens(withPragmas?: boolean): readonly Token[];
     getStatements(): readonly StatementNode[];
@@ -2023,6 +2023,15 @@ declare class ElseIf_2 implements IStatement {
     getMatcher(): IStatementRunnable;
 }
 
+declare class EmailTemplate extends AbstractObject {
+    getType(): string;
+    getAllowedNaming(): {
+        maxLength: number;
+        allowNamespace: boolean;
+    };
+    getDescription(): string | undefined;
+}
+
 export declare class Empty implements IStatement {
     getMatcher(): IStatementRunnable;
 }
@@ -3064,6 +3073,13 @@ declare class HttpService extends AbstractObject {
     getDescription(): string | undefined;
 }
 
+export declare interface IABAPFile {
+    getInfo(): IABAPFileInformation;
+    getStructure(): StructureNode | undefined;
+    getTokens(withPragmas?: boolean): readonly Token[];
+    getStatements(): readonly StatementNode[];
+}
+
 declare interface IABAPFileInformation {
     listInterfaceDefinitions(): readonly InfoInterfaceDefinition[];
     getInterfaceDefinitionByName(name: string): InfoInterfaceDefinition | undefined;
@@ -5008,7 +5024,6 @@ declare namespace Objects {
         BRFPlusSystemApplication,
         BSPApplication,
         BusinessAddInImplementation,
-        CDSEntityBuffer,
         BusinessCatalogAppAssignment,
         BusinessCatalog,
         BusinessConfigurationMaintenanceObject,
@@ -5017,6 +5032,7 @@ declare namespace Objects {
         BusinessFunctionSetAssignment,
         BusinessObjectModel,
         BusinessObjectType,
+        CDSEntityBuffer,
         ParsedMetadataExtension,
         CDSMetadataExtension,
         CDSType,
@@ -5046,6 +5062,7 @@ declare namespace Objects {
         EcattTestConfiguration,
         EcattTestDataContainer,
         EcattTestScript,
+        EmailTemplate,
         EnhancementImplementation,
         IBadiDefinition,
         EnhancementSpot,
@@ -5142,6 +5159,7 @@ declare namespace Objects {
         TableType,
         EnhancementCategory,
         TableCategory,
+        SecondaryIndex,
         Table,
         TechnicalJobDefinition,
         TransactionVariant,
@@ -5871,6 +5889,11 @@ declare class SearchHelp extends AbstractObject {
     getDescription(): string | undefined;
 }
 
+declare type SecondaryIndex = {
+    name: string;
+    fields: string[];
+};
+
 declare class SectionContents implements IStructure {
     getMatcher(): IStructureRunnable;
 }
@@ -6963,6 +6986,7 @@ declare class Table extends AbstractObject {
     private parsedType;
     getType(): string;
     getDescription(): string | undefined;
+    getSecondaryIndexes(): SecondaryIndex[] | undefined;
     getAllowedNaming(): IAllowedNaming;
     setDirty(): void;
     listKeys(reg: IRegistry): string[];

package/build/src/abap/4_file_information/abap_file_information.js

@@ -1,27 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ABAPFileInformation = void 0;
-const Structures = require("../3_structures/structures");
-const Expressions = require("../2_statements/expressions");
-const Statements = require("../2_statements/statements");
-const _abap_file_information_1 = require("./_abap_file_information");
-const _identifier_1 = require("./_identifier");
-const Tokens = require("../1_lexer/tokens");
-const visibility_1 = require("./visibility");
 class ABAPFileInformation {
-    constructor(structure, filename) {
-        this.forms = [];
-        this.implementations = [];
-        this.interfaces = [];
-        this.classes = [];
-        this.filename = filename;
-        this.parse(structure);
+    constructor(parsed) {
+        this.parsed = parsed;
     }
     listClassImplementations() {
-        return this.implementations;
+        return this.parsed.implementations;
     }
     listInterfaceDefinitions() {
-        return this.interfaces;
+        return this.parsed.interfaces;
     }
     getInterfaceDefinitionByName(name) {
         const upper = name.toUpperCase();
@@ -33,7 +21,7 @@ class ABAPFileInformation {
         return undefined;
     }
     listClassDefinitions() {
-        return this.classes;
+        return this.parsed.classes;
     }
     getClassDefinitionByName(name) {
         const upper = name.toUpperCase();
@@ -54,322 +42,7 @@ class ABAPFileInformation {
         return undefined;
     }
     listFormDefinitions() {
-        return this.forms;
-    }
-    ///////////////////////
-    parse(structure) {
-        var _a;
-        if (structure === undefined) {
-            return;
-        }
-        this.parseClasses(structure);
-        this.parseInterfaces(structure);
-        for (const found of structure.findAllStructures(Structures.ClassImplementation)) {
-            const methods = [];
-            for (const method of found.findAllStructures(Structures.Method)) {
-                const methodName = (_a = method.findFirstExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-                if (methodName) {
-                    methods.push(new _identifier_1.Identifier(methodName, this.filename));
-                }
-            }
-            const name = found.findFirstStatement(Statements.ClassImplementation).findFirstExpression(Expressions.ClassName).getFirstToken();
-            this.implementations.push({
-                name: name.getStr(),
-                identifier: new _identifier_1.Identifier(name, this.filename),
-                methods,
-            });
-        }
-        for (const statement of structure.findAllStructures(Structures.Form)) {
-            // FORMs can contain a dash in the name
-            const pos = statement.findFirstExpression(Expressions.FormName).getFirstToken().getStart();
-            const name = statement.findFirstExpression(Expressions.FormName).concatTokens();
-            const nameToken = new Tokens.Identifier(pos, name);
-            this.forms.push({
-                name: nameToken.getStr(),
-                identifier: new _identifier_1.Identifier(nameToken, this.filename),
-            });
-        }
-    }
-    parseInterfaces(structure) {
-        for (const found of structure.findDirectStructures(Structures.Interface)) {
-            const i = found.findFirstStatement(Statements.Interface);
-            if (i === undefined) {
-                throw new Error("Interface expected, parseInterfaces");
-            }
-            const interfaceName = i.findDirectExpression(Expressions.InterfaceName).getFirstToken();
-            const methods = this.parseMethodDefinition(found, visibility_1.Visibility.Public);
-            const attributes = this.parseAttributes(found, visibility_1.Visibility.Public);
-            const aliases = this.parseAliases(found, visibility_1.Visibility.Public);
-            const constants = this.parseConstants(found, visibility_1.Visibility.Public);
-            const g = i.findDirectExpression(Expressions.ClassGlobal);
-            this.interfaces.push({
-                name: interfaceName.getStr(),
-                identifier: new _identifier_1.Identifier(interfaceName, this.filename),
-                isLocal: g === undefined,
-                isGlobal: g !== undefined,
-                interfaces: this.getImplementing(found),
-                aliases,
-                methods,
-                constants,
-                attributes,
-            });
-        }
-    }
-    parseClasses(structure) {
-        var _a;
-        for (const found of structure.findAllStructures(Structures.ClassDefinition)) {
-            const className = found.findFirstStatement(Statements.ClassDefinition).findFirstExpression(Expressions.ClassName).getFirstToken();
-            const methods = this.parseMethodDefinition(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
-            methods.push(...this.parseMethodDefinition(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
-            methods.push(...this.parseMethodDefinition(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
-            const attributes = this.parseAttributes(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
-            attributes.push(...this.parseAttributes(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
-            attributes.push(...this.parseAttributes(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
-            const aliases = this.parseAliases(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
-            aliases.push(...this.parseAliases(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
-            aliases.push(...this.parseAliases(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
-            const constants = this.parseConstants(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
-            constants.push(...this.parseConstants(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
-            constants.push(...this.parseConstants(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
-            const superClassName = (_a = found.findFirstExpression(Expressions.SuperClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr();
-            const containsGlobal = found.findFirstExpression(Expressions.ClassGlobal);
-            const cdef = found.findFirstStatement(Statements.ClassDefinition);
-            const concat = (cdef === null || cdef === void 0 ? void 0 : cdef.concatTokens().toUpperCase()) || "";
-            let riskLevel;
-            if (concat.includes("RISK LEVEL CRITICAL")) {
-                riskLevel = _abap_file_information_1.RiskLevel.critical;
-            }
-            else if (concat.includes("RISK LEVEL DANGEROUS")) {
-                riskLevel = _abap_file_information_1.RiskLevel.dangerous;
-            }
-            else if (concat.includes("RISK LEVEL HARMLESS")) {
-                riskLevel = _abap_file_information_1.RiskLevel.harmless;
-            }
-            let duration;
-            if (concat.includes("DURATION SHORT")) {
-                duration = _abap_file_information_1.Duration.short;
-            }
-            else if (concat.includes("DURATION LONG")) {
-                duration = _abap_file_information_1.Duration.long;
-            }
-            else if (concat.includes("DURATION MEDIUM")) {
-                duration = _abap_file_information_1.Duration.medium;
-            }
-            this.classes.push({
-                name: className.getStr(),
-                identifier: new _identifier_1.Identifier(className, this.filename),
-                isLocal: containsGlobal === undefined,
-                isGlobal: containsGlobal !== undefined,
-                methods,
-                superClassName,
-                interfaces: this.getImplementing(found),
-                isForTesting: concat.includes(" FOR TESTING"),
-                duration,
-                riskLevel,
-                isAbstract: (cdef === null || cdef === void 0 ? void 0 : cdef.findDirectTokenByText("ABSTRACT")) !== undefined,
-                isSharedMemory: concat.includes(" SHARED MEMORY ENABLED"),
-                isFinal: found.findFirstExpression(Expressions.ClassFinal) !== undefined,
-                aliases,
-                attributes,
-                constants,
-            });
-        }
-    }
-    ///////////////////
-    getImplementing(input) {
-        const ret = [];
-        for (const node of input.findAllStatements(Statements.InterfaceDef)) {
-            const abstract = node.findDirectExpression(Expressions.AbstractMethods);
-            const abstractMethods = [];
-            if (abstract) {
-                for (const m of abstract.findDirectExpressions(Expressions.MethodName)) {
-                    abstractMethods.push(m.concatTokens().toUpperCase());
-                }
-            }
-            const final = node.findDirectExpression(Expressions.FinalMethods);
-            const finalMethods = [];
-            if (final) {
-                for (const m of final.findDirectExpressions(Expressions.MethodName)) {
-                    finalMethods.push(m.concatTokens().toUpperCase());
-                }
-            }
-            const concat = node.concatTokens().toUpperCase();
-            const allAbstract = concat.includes(" ALL METHODS ABSTRACT");
-            const partial = concat.includes(" PARTIALLY IMPLEMENTED");
-            const name = node.findFirstExpression(Expressions.InterfaceName).getFirstToken().getStr().toUpperCase();
-            ret.push({
-                name,
-                partial,
-                allAbstract,
-                abstractMethods,
-                finalMethods,
-            });
-        }
-        return ret;
-    }
-    parseAliases(node, visibility) {
-        if (node === undefined) {
-            return [];
-        }
-        const ret = [];
-        for (const a of node.findAllStatements(Statements.Aliases)) {
-            const name = a.findFirstExpression(Expressions.SimpleName).getFirstToken();
-            const comp = a.findFirstExpression(Expressions.Field).getFirstToken();
-            ret.push({
-                name: name.getStr(),
-                identifier: new _identifier_1.Identifier(name, this.filename),
-                visibility,
-                component: comp.getStr(),
-            });
-        }
-        return ret;
-    }
-    parseConstants(node, visibility) {
-        var _a, _b;
-        if (node === undefined) {
-            return [];
-        }
-        const results = [];
-        for (const constant of node.findAllStatements(Statements.Constant)) {
-            const name = constant.findFirstExpression(Expressions.DefinitionName).getFirstToken();
-            const typeName = constant.findFirstExpression(Expressions.TypeName);
-            // VALUE `const_value` -> `const_value`
-            const literal = (_b = (_a = constant.findFirstExpression(Expressions.Value)) === null || _a === void 0 ? void 0 : _a.getTokens()[1].getStr()) !== null && _b !== void 0 ? _b : "``";
-            // `const_value` -> const_value
-            const value = literal.slice(1, (literal === null || literal === void 0 ? void 0 : literal.length) - 1);
-            results.push({
-                name: name.getStr(),
-                typeName: typeName ? typeName.getFirstToken().getStr() : "",
-                value: value,
-                identifier: new _identifier_1.Identifier(name, this.filename),
-                visibility,
-            });
-        }
-        return results;
-    }
-    parseAttributes(node, visibility) {
-        if (node === undefined) {
-            return [];
-        }
-        const contents = node.findFirstStructure(Structures.SectionContents);
-        if (contents === undefined) {
-            return [];
-        }
-        const ret = [];
-        for (const d of contents.findDirectStatements(Statements.Data)) {
-            const name = d.findFirstExpression(Expressions.DefinitionName).getFirstToken();
-            ret.push({
-                name: name.getStr(),
-                identifier: new _identifier_1.Identifier(name, this.filename),
-                level: _abap_file_information_1.AttributeLevel.Instance,
-                readOnly: d.concatTokens().toUpperCase().includes(" READ-ONLY"),
-                visibility,
-            });
-        }
-        for (const d of contents.findDirectStatements(Statements.ClassData)) {
-            const name = d.findFirstExpression(Expressions.DefinitionName).getFirstToken();
-            ret.push({
-                name: name.getStr(),
-                identifier: new _identifier_1.Identifier(name, this.filename),
-                level: _abap_file_information_1.AttributeLevel.Static,
-                readOnly: d.concatTokens().toUpperCase().includes(" READ-ONLY"),
-                visibility,
-            });
-        }
-        for (const d of contents.findDirectStatements(Statements.Constant)) {
-            const name = d.findFirstExpression(Expressions.DefinitionName).getFirstToken();
-            ret.push({
-                name: name.getStr(),
-                identifier: new _identifier_1.Identifier(name, this.filename),
-                level: _abap_file_information_1.AttributeLevel.Constant,
-                readOnly: true,
-                visibility,
-            });
-        }
-        return ret;
-    }
-    parseMethodDefinition(node, visibility) {
-        var _a;
-        if (node === undefined) {
-            return [];
-        }
-        const methods = [];
-        for (const def of node.findAllStatements(Statements.MethodDef)) {
-            const methodName = (_a = def.findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-            if (methodName === undefined) {
-                continue;
-            }
-            const parameters = this.parseMethodParameters(def);
-            methods.push({
-                name: methodName.getStr(),
-                identifier: new _identifier_1.Identifier(methodName, this.filename),
-                isRedefinition: def.findDirectExpression(Expressions.Redefinition) !== undefined,
-                isForTesting: def.concatTokens().toUpperCase().includes(" FOR TESTING"),
-                isFinal: def.concatTokens().toUpperCase().includes(" FINAL"),
-                isAbstract: def.findDirectExpression(Expressions.Abstract) !== undefined,
-                isEventHandler: def.findDirectExpression(Expressions.EventHandler) !== undefined,
-                visibility,
-                parameters,
-                exceptions: [], // todo
-            });
-        }
-        return methods;
-    }
-    // todo, refactor this method, it is too long
-    parseMethodParameters(node) {
-        var _a, _b, _c, _d;
-        const ret = [];
-        const importing = node.findFirstExpression(Expressions.MethodDefImporting);
-        if (importing) {
-            for (const param of importing.findAllExpressions(Expressions.MethodParam)) {
-                const name = (_a = param.findDirectExpression(Expressions.MethodParamName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-                if (name) {
-                    ret.push({
-                        name: name.getStr().replace("!", ""),
-                        identifier: new _identifier_1.Identifier(name, this.filename),
-                        direction: _abap_file_information_1.MethodParameterDirection.Importing,
-                    });
-                }
-            }
-        }
-        const exporting = node.findFirstExpression(Expressions.MethodDefExporting);
-        if (exporting) {
-            for (const param of exporting.findAllExpressions(Expressions.MethodParam)) {
-                const name = (_b = param.findDirectExpression(Expressions.MethodParamName)) === null || _b === void 0 ? void 0 : _b.getFirstToken();
-                if (name) {
-                    ret.push({
-                        name: name.getStr().replace("!", ""),
-                        identifier: new _identifier_1.Identifier(name, this.filename),
-                        direction: _abap_file_information_1.MethodParameterDirection.Exporting,
-                    });
-                }
-            }
-        }
-        const changing = node.findFirstExpression(Expressions.MethodDefChanging);
-        if (changing) {
-            for (const param of changing.findAllExpressions(Expressions.MethodParam)) {
-                const name = (_c = param.findDirectExpression(Expressions.MethodParamName)) === null || _c === void 0 ? void 0 : _c.getFirstToken();
-                if (name) {
-                    ret.push({
-                        name: name.getStr().replace("!", ""),
-                        identifier: new _identifier_1.Identifier(name, this.filename),
-                        direction: _abap_file_information_1.MethodParameterDirection.Changing,
-                    });
-                }
-            }
-        }
-        const returning = node.findFirstExpression(Expressions.MethodDefReturning);
-        if (returning) {
-            const name = (_d = returning.findDirectExpression(Expressions.MethodParamName)) === null || _d === void 0 ? void 0 : _d.getFirstToken();
-            if (name) {
-                ret.push({
-                    name: name.getStr().replace("!", ""),
-                    identifier: new _identifier_1.Identifier(name, this.filename),
-                    direction: _abap_file_information_1.MethodParameterDirection.Returning,
-                });
-            }
-        }
-        return ret;
+        return this.parsed.forms;
     }
 }
 exports.ABAPFileInformation = ABAPFileInformation;

package/build/src/abap/4_file_information/abap_file_information_parser.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ABAPFileInformationParser = void 0;
+const Structures = require("../3_structures/structures");
+const Expressions = require("../2_statements/expressions");
+const Statements = require("../2_statements/statements");
+const _identifier_1 = require("./_identifier");
+const Tokens = require("../1_lexer/tokens");
+const visibility_1 = require("./visibility");
+const _abap_file_information_1 = require("./_abap_file_information");
+class ABAPFileInformationParser {
+    constructor(filename) {
+        this.filename = filename;
+    }
+    parse(structure) {
+        const result = {
+            interfaces: [],
+            classes: [],
+            forms: [],
+            implementations: [],
+        };
+        if (structure === undefined) {
+            return result;
+        }
+        result.classes = this.parseClasses(structure);
+        result.interfaces = this.parseInterfaces(structure);
+        result.implementations = this.parseClassImplementations(structure);
+        result.forms = this.parseForms(structure);
+        return result;
+    }
+    parseClassImplementations(structure) {
+        var _a;
+        const implementations = [];
+        for (const found of structure.findAllStructures(Structures.ClassImplementation)) {
+            const methods = [];
+            for (const method of found.findAllStructures(Structures.Method)) {
+                const methodName = (_a = method.findFirstExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
+                if (methodName) {
+                    methods.push(new _identifier_1.Identifier(methodName, this.filename));
+                }
+            }
+            const name = found.findFirstStatement(Statements.ClassImplementation).findFirstExpression(Expressions.ClassName).getFirstToken();
+            implementations.push({
+                name: name.getStr(),
+                identifier: new _identifier_1.Identifier(name, this.filename),
+                methods,
+            });
+        }
+        return implementations;
+    }
+    parseForms(structure) {
+        const forms = [];
+        for (const statement of structure.findAllStructures(Structures.Form)) {
+            // FORMs can contain a dash in the name
+            const pos = statement.findFirstExpression(Expressions.FormName).getFirstToken().getStart();
+            const name = statement.findFirstExpression(Expressions.FormName).concatTokens();
+            const nameToken = new Tokens.Identifier(pos, name);
+            forms.push({
+                name: nameToken.getStr(),
+                identifier: new _identifier_1.Identifier(nameToken, this.filename),
+            });
+        }
+        return forms;
+    }
+    parseInterfaces(structure) {
+        const interfaces = [];
+        for (const found of structure.findDirectStructures(Structures.Interface)) {
+            const i = found.findFirstStatement(Statements.Interface);
+            if (i === undefined) {
+                throw new Error("Interface expected, parseInterfaces");
+            }
+            const interfaceName = i.findDirectExpression(Expressions.InterfaceName).getFirstToken();
+            const methods = this.parseMethodDefinition(found, visibility_1.Visibility.Public);
+            const attributes = this.parseAttributes(found, visibility_1.Visibility.Public);
+            const aliases = this.parseAliases(found, visibility_1.Visibility.Public);
+            const constants = this.parseConstants(found, visibility_1.Visibility.Public);
+            const g = i.findDirectExpression(Expressions.ClassGlobal);
+            interfaces.push({
+                name: interfaceName.getStr(),
+                identifier: new _identifier_1.Identifier(interfaceName, this.filename),
+                isLocal: g === undefined,
+                isGlobal: g !== undefined,
+                interfaces: this.getImplementing(found),
+                aliases,
+                methods,
+                constants,
+                attributes,
+            });
+        }
+        return interfaces;
+    }
+    parseClasses(structure) {
+        var _a;
+        const classes = [];
+        for (const found of structure.findAllStructures(Structures.ClassDefinition)) {
+            const className = found.findFirstStatement(Statements.ClassDefinition).findFirstExpression(Expressions.ClassName).getFirstToken();
+            const methods = this.parseMethodDefinition(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
+            methods.push(...this.parseMethodDefinition(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
+            methods.push(...this.parseMethodDefinition(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
+            const attributes = this.parseAttributes(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
+            attributes.push(...this.parseAttributes(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
+            attributes.push(...this.parseAttributes(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
+            const aliases = this.parseAliases(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
+            aliases.push(...this.parseAliases(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
+            aliases.push(...this.parseAliases(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
+            const constants = this.parseConstants(found.findFirstStructure(Structures.PublicSection), visibility_1.Visibility.Public);
+            constants.push(...this.parseConstants(found.findFirstStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected));
+            constants.push(...this.parseConstants(found.findFirstStructure(Structures.PrivateSection), visibility_1.Visibility.Private));
+            const superClassName = (_a = found.findFirstExpression(Expressions.SuperClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr();
+            const containsGlobal = found.findFirstExpression(Expressions.ClassGlobal);
+            const cdef = found.findFirstStatement(Statements.ClassDefinition);
+            const concat = (cdef === null || cdef === void 0 ? void 0 : cdef.concatTokens().toUpperCase()) || "";
+            let riskLevel;
+            if (concat.includes("RISK LEVEL CRITICAL")) {
+                riskLevel = _abap_file_information_1.RiskLevel.critical;
+            }
+            else if (concat.includes("RISK LEVEL DANGEROUS")) {
+                riskLevel = _abap_file_information_1.RiskLevel.dangerous;
+            }
+            else if (concat.includes("RISK LEVEL HARMLESS")) {
+                riskLevel = _abap_file_information_1.RiskLevel.harmless;
+            }
+            let duration;
+            if (concat.includes("DURATION SHORT")) {
+                duration = _abap_file_information_1.Duration.short;
+            }
+            else if (concat.includes("DURATION LONG")) {
+                duration = _abap_file_information_1.Duration.long;
+            }
+            else if (concat.includes("DURATION MEDIUM")) {
+                duration = _abap_file_information_1.Duration.medium;
+            }
+            classes.push({
+                name: className.getStr(),
+                identifier: new _identifier_1.Identifier(className, this.filename),
+                isLocal: containsGlobal === undefined,
+                isGlobal: containsGlobal !== undefined,
+                methods,
+                superClassName,
+                interfaces: this.getImplementing(found),
+                isForTesting: concat.includes(" FOR TESTING"),
+                duration,
+                riskLevel,
+                isAbstract: (cdef === null || cdef === void 0 ? void 0 : cdef.findDirectTokenByText("ABSTRACT")) !== undefined,
+                isSharedMemory: concat.includes(" SHARED MEMORY ENABLED"),
+                isFinal: found.findFirstExpression(Expressions.ClassFinal) !== undefined,
+                aliases,
+                attributes,
+                constants,
+            });
+        }
+        return classes;
+    }
+    ///////////////////
+    getImplementing(input) {
+        const ret = [];
+        for (const node of input.findAllStatements(Statements.InterfaceDef)) {
+            const abstract = node.findDirectExpression(Expressions.AbstractMethods);
+            const abstractMethods = [];
+            if (abstract) {
+                for (const m of abstract.findDirectExpressions(Expressions.MethodName)) {
+                    abstractMethods.push(m.concatTokens().toUpperCase());
+                }
+            }
+            const final = node.findDirectExpression(Expressions.FinalMethods);
+            const finalMethods = [];
+            if (final) {
+                for (const m of final.findDirectExpressions(Expressions.MethodName)) {
+                    finalMethods.push(m.concatTokens().toUpperCase());
+                }
+            }
+            const concat = node.concatTokens().toUpperCase();
+            const allAbstract = concat.includes(" ALL METHODS ABSTRACT");
+            const partial = concat.includes(" PARTIALLY IMPLEMENTED");
+            const name = node.findFirstExpression(Expressions.InterfaceName).getFirstToken().getStr().toUpperCase();
+            ret.push({
+                name,
+                partial,
+                allAbstract,
+                abstractMethods,
+                finalMethods,
+            });
+        }
+        return ret;
+    }
+    parseAliases(node, visibility) {
+        if (node === undefined) {
+            return [];
+        }
+        const ret = [];
+        for (const a of node.findAllStatements(Statements.Aliases)) {
+            const name = a.findFirstExpression(Expressions.SimpleName).getFirstToken();
+            const comp = a.findFirstExpression(Expressions.Field).getFirstToken();
+            ret.push({
+                name: name.getStr(),
+                identifier: new _identifier_1.Identifier(name, this.filename),
+                visibility,
+                component: comp.getStr(),
+            });
+        }
+        return ret;
+    }
+    parseConstants(node, visibility) {
+        var _a, _b;
+        if (node === undefined) {
+            return [];
+        }
+        const results = [];
+        for (const constant of node.findAllStatements(Statements.Constant)) {
+            const name = constant.findFirstExpression(Expressions.DefinitionName).getFirstToken();
+            const typeName = constant.findFirstExpression(Expressions.TypeName);
+            // VALUE `const_value` -> `const_value`
+            const literal = (_b = (_a = constant.findFirstExpression(Expressions.Value)) === null || _a === void 0 ? void 0 : _a.getTokens()[1].getStr()) !== null && _b !== void 0 ? _b : "``";
+            // `const_value` -> const_value
+            const value = literal.slice(1, (literal === null || literal === void 0 ? void 0 : literal.length) - 1);
+            results.push({
+                name: name.getStr(),
+                typeName: typeName ? typeName.getFirstToken().getStr() : "",
+                value: value,
+                identifier: new _identifier_1.Identifier(name, this.filename),
+                visibility,
+            });
+        }
+        return results;
+    }
+    parseAttributes(node, visibility) {
+        if (node === undefined) {
+            return [];
+        }
+        const contents = node.findFirstStructure(Structures.SectionContents);
+        if (contents === undefined) {
+            return [];
+        }
+        const ret = [];
+        for (const d of contents.findDirectStatements(Statements.Data)) {
+            const name = d.findFirstExpression(Expressions.DefinitionName).getFirstToken();
+            ret.push({
+                name: name.getStr(),
+                identifier: new _identifier_1.Identifier(name, this.filename),
+                level: _abap_file_information_1.AttributeLevel.Instance,
+                readOnly: d.concatTokens().toUpperCase().includes(" READ-ONLY"),
+                visibility,
+            });
+        }
+        for (const d of contents.findDirectStatements(Statements.ClassData)) {
+            const name = d.findFirstExpression(Expressions.DefinitionName).getFirstToken();
+            ret.push({
+                name: name.getStr(),
+                identifier: new _identifier_1.Identifier(name, this.filename),
+                level: _abap_file_information_1.AttributeLevel.Static,
+                readOnly: d.concatTokens().toUpperCase().includes(" READ-ONLY"),
+                visibility,
+            });
+        }
+        for (const d of contents.findDirectStatements(Statements.Constant)) {
+            const name = d.findFirstExpression(Expressions.DefinitionName).getFirstToken();
+            ret.push({
+                name: name.getStr(),
+                identifier: new _identifier_1.Identifier(name, this.filename),
+                level: _abap_file_information_1.AttributeLevel.Constant,
+                readOnly: true,
+                visibility,
+            });
+        }
+        return ret;
+    }
+    parseMethodDefinition(node, visibility) {
+        var _a;
+        if (node === undefined) {
+            return [];
+        }
+        const methods = [];
+        for (const def of node.findAllStatements(Statements.MethodDef)) {
+            const methodName = (_a = def.findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
+            if (methodName === undefined) {
+                continue;
+            }
+            const parameters = this.parseMethodParameters(def);
+            methods.push({
+                name: methodName.getStr(),
+                identifier: new _identifier_1.Identifier(methodName, this.filename),
+                isRedefinition: def.findDirectExpression(Expressions.Redefinition) !== undefined,
+                isForTesting: def.concatTokens().toUpperCase().includes(" FOR TESTING"),
+                isFinal: def.concatTokens().toUpperCase().includes(" FINAL"),
+                isAbstract: def.findDirectExpression(Expressions.Abstract) !== undefined,
+                isEventHandler: def.findDirectExpression(Expressions.EventHandler) !== undefined,
+                visibility,
+                parameters,
+                exceptions: [], // todo
+            });
+        }
+        return methods;
+    }
+    // todo, refactor this method, it is too long
+    parseMethodParameters(node) {
+        var _a, _b, _c, _d;
+        const ret = [];
+        const importing = node.findFirstExpression(Expressions.MethodDefImporting);
+        if (importing) {
+            for (const param of importing.findAllExpressions(Expressions.MethodParam)) {
+                const name = (_a = param.findDirectExpression(Expressions.MethodParamName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
+                if (name) {
+                    ret.push({
+                        name: name.getStr().replace("!", ""),
+                        identifier: new _identifier_1.Identifier(name, this.filename),
+                        direction: _abap_file_information_1.MethodParameterDirection.Importing,
+                    });
+                }
+            }
+        }
+        const exporting = node.findFirstExpression(Expressions.MethodDefExporting);
+        if (exporting) {
+            for (const param of exporting.findAllExpressions(Expressions.MethodParam)) {
+                const name = (_b = param.findDirectExpression(Expressions.MethodParamName)) === null || _b === void 0 ? void 0 : _b.getFirstToken();
+                if (name) {
+                    ret.push({
+                        name: name.getStr().replace("!", ""),
+                        identifier: new _identifier_1.Identifier(name, this.filename),
+                        direction: _abap_file_information_1.MethodParameterDirection.Exporting,
+                    });
+                }
+            }
+        }
+        const changing = node.findFirstExpression(Expressions.MethodDefChanging);
+        if (changing) {
+            for (const param of changing.findAllExpressions(Expressions.MethodParam)) {
+                const name = (_c = param.findDirectExpression(Expressions.MethodParamName)) === null || _c === void 0 ? void 0 : _c.getFirstToken();
+                if (name) {
+                    ret.push({
+                        name: name.getStr().replace("!", ""),
+                        identifier: new _identifier_1.Identifier(name, this.filename),
+                        direction: _abap_file_information_1.MethodParameterDirection.Changing,
+                    });
+                }
+            }
+        }
+        const returning = node.findFirstExpression(Expressions.MethodDefReturning);
+        if (returning) {
+            const name = (_d = returning.findDirectExpression(Expressions.MethodParamName)) === null || _d === void 0 ? void 0 : _d.getFirstToken();
+            if (name) {
+                ret.push({
+                    name: name.getStr().replace("!", ""),
+                    identifier: new _identifier_1.Identifier(name, this.filename),
+                    direction: _abap_file_information_1.MethodParameterDirection.Returning,
+                });
+            }
+        }
+        return ret;
+    }
+}
+exports.ABAPFileInformationParser = ABAPFileInformationParser;
+//# sourceMappingURL=abap_file_information_parser.js.map

package/build/src/abap/4_file_information/parsed_file_information.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=parsed_file_information.js.map

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

@@ -17,7 +17,7 @@ const _syntax_input_1 = require("../_syntax_input");
 const isSimple = /^\w+$/;
 class Select {
     static runSyntax(node, input, skipImplicitInto = false) {
-        var _a, _b;
+        var _a;
         const token = node.getFirstToken();
         let from = node.findDirectExpression(Expressions.SQLFrom);
         if (from === undefined) {
@@ -38,10 +38,8 @@ class Select {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return;
         }
-        const isSingle = ((_a = node.getChildren()[1]) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase()) === "SINGLE"
-            || node.get() instanceof Expressions.SelectLoop;
         this.checkFields(fields, dbSources, input, node);
-        this.handleInto(node, input, fields, dbSources, isSingle);
+        const intoExpression = this.handleInto(node, input, fields, dbSources);
         const fae = node.findDirectExpression(Expressions.SQLForAllEntries);
         if (fae) {
             input.scope.push(_scope_type_1.ScopeType.OpenSQL, "SELECT", token.getStart(), input.filename);
@@ -55,7 +53,7 @@ class Select {
             && node.findDirectExpression(Expressions.SQLIntoTable) === undefined
             && node.findDirectExpression(Expressions.SQLIntoList) === undefined
             && node.findDirectExpression(Expressions.SQLIntoStructure) === undefined) {
-            const fields = (_b = node.findFirstExpression(Expressions.SQLAggregation)) === null || _b === void 0 ? void 0 : _b.concatTokens();
+            const fields = (_a = node.findFirstExpression(Expressions.SQLAggregation)) === null || _a === void 0 ? void 0 : _a.concatTokens();
             const c = new RegExp(/^count\(\s*\*\s*\)$/, "i");
             if (fields === undefined || c.test(fields) === false) {
                 const nameToken = from === null || from === void 0 ? void 0 : from.findDirectExpression(Expressions.SQLFromSource);
@@ -89,8 +87,18 @@ class Select {
         for (const s of node.findAllExpressions(Expressions.SQLCompare)) {
             sql_compare_1.SQLCompare.runSyntax(s, input, dbSources);
         }
-        for (const s of node.findDirectExpressions(Expressions.SQLOrderBy)) {
-            sql_order_by_1.SQLOrderBy.runSyntax(s, input);
+        const orderBy = node.findDirectExpression(Expressions.SQLOrderBy);
+        if (orderBy) {
+            sql_order_by_1.SQLOrderBy.runSyntax(orderBy, input);
+            const where = node.findDirectExpression(Expressions.SQLCond);
+            if (intoExpression
+                && where
+                && intoExpression.getFirstToken().getStart().isBefore(orderBy.getFirstToken().getStart())
+                && where.getFirstToken().getStart().isBefore(orderBy.getFirstToken().getStart())
+                && where.getFirstToken().getStart().isBefore(intoExpression.getFirstToken().getStart())) {
+                const message = `ORDER BY must be before INTO, after WHERE`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, orderBy.getFirstToken(), message));
+            }
         }
         if (this.isStrictMode(node)) {
             this.strictModeChecks(node, input);
@@ -141,13 +149,14 @@ class Select {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
         }
     }
-    static handleInto(node, input, fields, dbSources, _isSingle) {
+    static handleInto(node, input, fields, dbSources) {
         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));
             }
+            return intoTable;
         }
         const intoStructure = node.findDirectExpression(Expressions.SQLIntoStructure);
         if (intoStructure) {
@@ -161,6 +170,7 @@ class Select {
                     inline_data_1.InlineData.runSyntax(inline, input, basic_1.VoidType.get("SELECT_todo1"));
                 }
             }
+            return intoStructure;
         }
         const intoList = node.findDirectExpression(Expressions.SQLIntoList);
         if (intoList) {
@@ -200,7 +210,9 @@ class Select {
                     inline_data_1.InlineData.runSyntax(inline, input, type);
                 }
             }
+            return intoList;
         }
+        return undefined;
     }
     static checkFields(fields, dbSources, input, node) {
         if (dbSources.length > 1) {

package/build/src/abap/abap_file.js

@@ -15,12 +15,12 @@ class ABAPFile extends _abstract_file_1.AbstractFile {
     getRaw() {
         return this.file.getRaw();
     }
-    getInfo() {
-        return this.info;
-    }
     getRawRows() {
         return this.file.getRawRows();
     }
+    getInfo() {
+        return this.info;
+    }
     getStructure() {
         return this.structure;
     }

package/build/src/abap/abap_parser.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ABAPParser = void 0;
-const version_1 = require("../version");
+const abap_file_1 = require("./abap_file");
+const abap_file_information_1 = require("./4_file_information/abap_file_information");
+const abap_file_information_parser_1 = require("./4_file_information/abap_file_information_parser");
 const lexer_1 = require("./1_lexer/lexer");
 const statement_parser_1 = require("./2_statements/statement_parser");
 const structure_parser_1 = require("./3_structures/structure_parser");
-const abap_file_information_1 = require("./4_file_information/abap_file_information");
-const abap_file_1 = require("./abap_file");
+const version_1 = require("../version");
 class ABAPParser {
     constructor(version, globalMacros, reg) {
         this.version = version ? version : version_1.defaultVersion;
@@ -31,7 +32,9 @@ class ABAPParser {
         for (const f of statementResult) {
             const result = structure_parser_1.StructureParser.run(f);
             // 4: file information
-            const info = new abap_file_information_1.ABAPFileInformation(result.node, f.file.getFilename());
+            const parser = new abap_file_information_parser_1.ABAPFileInformationParser(f.file.getFilename());
+            const parsed = parser.parse(result.node);
+            const info = new abap_file_information_1.ABAPFileInformation(parsed);
             output.push(new abap_file_1.ABAPFile(f.file, f.tokens, f.statements, result.node, info));
             issues.push(...result.issues);
         }

package/build/src/abap/iabap_file.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=iabap_file.js.map

package/build/src/objects/email_template.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailTemplate = void 0;
+const _abstract_object_1 = require("./_abstract_object");
+class EmailTemplate extends _abstract_object_1.AbstractObject {
+    getType() {
+        return "SMTG";
+    }
+    getAllowedNaming() {
+        return {
+            maxLength: 60, // todo
+            allowNamespace: true,
+        };
+    }
+    getDescription() {
+        // todo
+        return undefined;
+    }
+}
+exports.EmailTemplate = EmailTemplate;
+//# sourceMappingURL=email_template.js.map

package/build/src/objects/function_group.js

@@ -27,6 +27,8 @@ class FunctionGroup extends _abap_object_1.ABAPObject {
         super.setDirty();
         this.includes = undefined;
         this.modules = undefined;
+        this.description = undefined;
+        this.dynpros = undefined;
     }
     getAllowedNaming() {
         return {

package/build/src/objects/index.js

@@ -36,7 +36,6 @@ __exportStar(require("./behavior_definition"), exports);
 __exportStar(require("./brf_plus_system_application"), exports);
 __exportStar(require("./bsp_application"), exports);
 __exportStar(require("./business_add_in_implementation"), exports);
-__exportStar(require("./cds_entity_buffer"), exports);
 __exportStar(require("./business_catalog_app_assignment"), exports);
 __exportStar(require("./business_catalog"), exports);
 __exportStar(require("./business_configuration_maintenance_object"), exports);
@@ -45,6 +44,7 @@ __exportStar(require("./business_function_assignment"), exports);
 __exportStar(require("./business_function_set_assignment"), exports);
 __exportStar(require("./business_object_model"), exports);
 __exportStar(require("./business_object_type"), exports);
+__exportStar(require("./cds_entity_buffer"), exports);
 __exportStar(require("./cds_metadata_extension"), exports);
 __exportStar(require("./cds_type"), exports);
 __exportStar(require("./change_document"), exports);
@@ -70,6 +70,7 @@ __exportStar(require("./domain"), exports);
 __exportStar(require("./ecatt_test_configuration"), exports);
 __exportStar(require("./ecatt_test_data_container"), exports);
 __exportStar(require("./ecatt_test_script"), exports);
+__exportStar(require("./email_template"), exports);
 __exportStar(require("./enhancement_implementation"), exports);
 __exportStar(require("./enhancement_spot"), exports);
 __exportStar(require("./entity_type"), exports);

package/build/src/objects/table.js

@@ -40,6 +40,13 @@ class Table extends _abstract_object_1.AbstractObject {
         }
         return (_a = this.parsedData) === null || _a === void 0 ? void 0 : _a.description;
     }
+    getSecondaryIndexes() {
+        var _a;
+        if (this.parsedData === undefined) {
+            this.parseXML();
+        }
+        return (_a = this.parsedData) === null || _a === void 0 ? void 0 : _a.secondaryIndexes;
+    }
     getAllowedNaming() {
         let length = 30;
         const regex = /^((\/[A-Z_\d]{3,8}\/)|[a-zA-Z0-9]{3}|CI_)\w+$/;
@@ -267,7 +274,7 @@ class Table extends _abstract_object_1.AbstractObject {
     }
     ///////////////
     parseXML() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         const parsed = super.parseRaw2();
         if (parsed === undefined) {
             return;
@@ -306,6 +313,25 @@ class Table extends _abstract_object_1.AbstractObject {
                 DDTEXT: field.DDTEXT,
             });
         }
+        // secondary indexes
+        const indexes = (_m = parsed.abapGit["asx:abap"]["asx:values"]) === null || _m === void 0 ? void 0 : _m.DD12V;
+        ;
+        this.parsedData.secondaryIndexes = [];
+        for (const index of (0, xml_utils_1.xmlToArray)(indexes === null || indexes === void 0 ? void 0 : indexes.DD12V)) {
+            const indexName = index.INDEXNAME;
+            const indexFields = [];
+            const indexFieldsXml = (_o = parsed.abapGit["asx:abap"]["asx:values"]) === null || _o === void 0 ? void 0 : _o.DD17V;
+            for (const indexField of (0, xml_utils_1.xmlToArray)(indexFieldsXml === null || indexFieldsXml === void 0 ? void 0 : indexFieldsXml.DD17V)) {
+                if (indexField.INDEXNAME === indexName) {
+                    // assumption: fields are listed by POSITION in the xml
+                    indexFields.push(indexField.FIELDNAME);
+                }
+            }
+            this.parsedData.secondaryIndexes.push({
+                name: indexName,
+                fields: indexFields,
+            });
+        }
     }
 }
 exports.Table = Table;

package/build/src/registry.js

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

package/build/src/rules/check_include.js

@@ -8,6 +8,10 @@ const _irule_1 = require("./_irule");
 const objects_1 = require("../objects");
 const severity_1 = require("../severity");
 class CheckIncludeConf extends _basic_rule_config_1.BasicRuleConfig {
+    constructor() {
+        super(...arguments);
+        this.allowUnused = false;
+    }
 }
 exports.CheckIncludeConf = CheckIncludeConf;
 class CheckInclude {
@@ -35,7 +39,7 @@ class CheckInclude {
     }
     initialize(reg) {
         this.reg = reg;
-        this.graph = new include_graph_1.IncludeGraph(this.reg, this.getConfig().severity || severity_1.Severity.Error);
+        this.graph = new include_graph_1.IncludeGraph(this.reg, this.getConfig().severity || severity_1.Severity.Error, this.getConfig().allowUnused || false);
         return this;
     }
     run(obj) {

package/build/src/rules/implicit_start_of_selection.js

@@ -28,8 +28,7 @@ https://help.sap.com/doc/abapdocu_751_index_htm/7.51/en-us/abapstart-of-selectio
             tags: [_irule_1.RuleTag.SingleFile],
             badExample: `REPORT zfoo.
 WRITE 'hello'.`,
-            goodExample: `
-START-OF-SELECTION.
+            goodExample: `START-OF-SELECTION.
   WRITE 'hello'.`,
         };
     }

package/build/src/rules/index.js

@@ -83,6 +83,7 @@ __exportStar(require("./implement_methods"), exports);
 __exportStar(require("./implicit_start_of_selection"), exports);
 __exportStar(require("./in_statement_indentation"), exports);
 __exportStar(require("./indentation"), exports);
+__exportStar(require("./index_completely_contained"), exports);
 __exportStar(require("./inline_data_old_versions"), exports);
 __exportStar(require("./intf_referencing_clas"), exports);
 __exportStar(require("./invalid_table_index"), exports);

package/build/src/rules/index_completely_contained.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexCompletelyContained = exports.IndexCompletelyContainedConf = void 0;
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const issue_1 = require("../issue");
+const position_1 = require("../position");
+const Objects = require("../objects");
+class IndexCompletelyContainedConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.IndexCompletelyContainedConf = IndexCompletelyContainedConf;
+class IndexCompletelyContained {
+    constructor() {
+        this.conf = new IndexCompletelyContainedConf();
+    }
+    getMetadata() {
+        return {
+            key: "index_completely_contained",
+            title: "Check if database table indexes are completely contained",
+            shortDescription: `If indexes are completely contained in other indexes, they can be removed to improve performance.`,
+            tags: [_irule_1.RuleTag.Performance, _irule_1.RuleTag.SingleFile],
+        };
+    }
+    initialize() {
+        return this;
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    run(obj) {
+        if (!(obj instanceof Objects.Table)) {
+            return [];
+        }
+        const indexes = obj.getSecondaryIndexes();
+        if (indexes === undefined || indexes.length === 0) {
+            return [];
+        }
+        const issues = [];
+        for (let i = 0; i < indexes.length; i++) {
+            const indexA = indexes[i];
+            for (let j = 0; j < indexes.length; j++) {
+                if (i === j) {
+                    continue;
+                }
+                const indexB = indexes[j];
+                let contained = true;
+                for (const field of indexA.fields) {
+                    if (indexB.fields.indexOf(field) === -1) {
+                        contained = false;
+                        break;
+                    }
+                }
+                if (contained) {
+                    const position = new position_1.Position(1, 1);
+                    const message = `Index "${indexA.name}" is completely contained in index "${indexB.name}"`;
+                    issues.push(issue_1.Issue.atPosition(obj.getFiles()[0], position, message, this.getMetadata().key, this.conf.severity));
+                }
+            }
+        }
+        return issues;
+    }
+}
+exports.IndexCompletelyContained = IndexCompletelyContained;
+//# sourceMappingURL=index_completely_contained.js.map

package/build/src/utils/include_graph.js

@@ -60,11 +60,12 @@ class Graph {
     }
 }
 class IncludeGraph {
-    constructor(reg, severity = severity_1.Severity.Error) {
+    constructor(reg, severity = severity_1.Severity.Error, allowUnused = false) {
         this.reg = reg;
         this.issues = [];
         this.graph = new Graph();
         this.severity = severity;
+        this.allowUnused = allowUnused;
         this.build();
     }
     listMainForInclude(filename) {
@@ -88,6 +89,7 @@ class IncludeGraph {
         }
         const v = this.graph.findVertexByFilename(file.getFilename());
         if (v !== undefined
+            && this.allowUnused === false
             && v.include === true
             && this.listMainForInclude(v.filename).length === 0) {
             const f = this.reg.getFileByName(v.filename);

package/package.json

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