@abaplint/core 2.95.41 → 2.95.43

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

@@ -1,353 +1,353 @@
-"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);
-    }
-    listClassImplementations() {
-        return this.implementations;
-    }
-    listInterfaceDefinitions() {
-        return this.interfaces;
-    }
-    getInterfaceDefinitionByName(name) {
-        const upper = name.toUpperCase();
-        for (const i of this.listInterfaceDefinitions()) {
-            if (i.identifier.getName().toUpperCase() === upper) {
-                return i;
-            }
-        }
-        return undefined;
-    }
-    listClassDefinitions() {
-        return this.classes;
-    }
-    getClassDefinitionByName(name) {
-        const upper = name.toUpperCase();
-        for (const d of this.listClassDefinitions()) {
-            if (d.identifier.getName().toUpperCase() === upper) {
-                return d;
-            }
-        }
-        return undefined;
-    }
-    getClassImplementationByName(name) {
-        const upper = name.toUpperCase();
-        for (const impl of this.listClassImplementations()) {
-            if (impl.identifier.getName().toUpperCase() === upper) {
-                return impl;
-            }
-        }
-        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()) || "";
-            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"),
-                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"),
-                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.ABAPFileInformation = ABAPFileInformation;
+"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);
+    }
+    listClassImplementations() {
+        return this.implementations;
+    }
+    listInterfaceDefinitions() {
+        return this.interfaces;
+    }
+    getInterfaceDefinitionByName(name) {
+        const upper = name.toUpperCase();
+        for (const i of this.listInterfaceDefinitions()) {
+            if (i.identifier.getName().toUpperCase() === upper) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+    listClassDefinitions() {
+        return this.classes;
+    }
+    getClassDefinitionByName(name) {
+        const upper = name.toUpperCase();
+        for (const d of this.listClassDefinitions()) {
+            if (d.identifier.getName().toUpperCase() === upper) {
+                return d;
+            }
+        }
+        return undefined;
+    }
+    getClassImplementationByName(name) {
+        const upper = name.toUpperCase();
+        for (const impl of this.listClassImplementations()) {
+            if (impl.identifier.getName().toUpperCase() === upper) {
+                return impl;
+            }
+        }
+        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()) || "";
+            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"),
+                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"),
+                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.ABAPFileInformation = ABAPFileInformation;
 //# sourceMappingURL=abap_file_information.js.map