@abaplint/core 2.120.74 → 2.120.76

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

@@ -63,6 +63,11 @@ class Compare {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), initialMessage));
             return;
         }
+        const predicateMessage = this.checkPredicateOperand(sources, input);
+        if (predicateMessage !== undefined) {
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), predicateMessage));
+            return;
+        }
         const typeUtils = new _type_utils_1.TypeUtils(input.scope);
         const compareOperator = (_a = node.findDirectExpression(Expressions.CompareOperator)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase();
         if (compareOperator === "CS"
@@ -103,6 +108,31 @@ class Compare {
         if ((chain === null || chain === void 0 ? void 0 : chain.length) === 4 && chain[0] instanceof nodes_1.TokenNode && (first === "XSDBOOL" || first === "BOOLC")) {
             return `Built-in function "${chain[0].getFirstToken().getStr()}" cannot be the operand of IS INITIAL`;
         }
+        const name = this.builtinCallName(node.findDirectExpression(Expressions.Source), input);
+        const returning = (_d = (_c = _builtin_1.BuiltIn.searchBuiltin(name)) === null || _c === void 0 ? void 0 : _c.getParameters().getReturning()) === null || _d === void 0 ? void 0 : _d.getType();
+        if (returning instanceof basic_1.StringType || returning instanceof basic_1.CharacterType) {
+            return `Built-in function "${name}" cannot be the operand of IS INITIAL`;
+        }
+        return undefined;
+    }
+    // a predicate function, contains( ) or line_exists( ), is a relational expression and not a value,
+    // it can stand alone as a condition or inside boolc( ) or xsdbool( ), but cannot be an operand of a comparison
+    static checkPredicateOperand(sources, input) {
+        if (input.scope.getOpenABAP()) {
+            return undefined;
+        }
+        for (const source of sources) {
+            const name = this.builtinCallName(source, input);
+            if (_builtin_1.BuiltIn.isPredicate(name) === true) {
+                return `Predicate function "${name}" cannot be the operand of a comparison`;
+            }
+        }
+        return undefined;
+    }
+    // the name of the built-in function when the source is exactly one call of it, not hidden by a method of the same name
+    static builtinCallName(source, input) {
+        var _a;
+        const chain = source === null || source === void 0 ? void 0 : source.getChildren();
         if ((chain === null || chain === void 0 ? void 0 : chain.length) !== 1 || !(chain[0] instanceof nodes_1.ExpressionNode) || !(chain[0].get() instanceof Expressions.MethodCallChain)) {
             return undefined;
         }
@@ -110,9 +140,8 @@ class Compare {
         if (calls.length !== 1 || !(calls[0] instanceof nodes_1.ExpressionNode) || !(calls[0].get() instanceof Expressions.MethodCall)) {
             return undefined;
         }
-        const name = (_c = calls[0].findDirectExpression(Expressions.MethodName)) === null || _c === void 0 ? void 0 : _c.concatTokens();
-        const builtin = _builtin_1.BuiltIn.searchBuiltin(name);
-        if (name === undefined || builtin === undefined) {
+        const name = (_a = calls[0].findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
+        if (name === undefined || _builtin_1.BuiltIn.searchBuiltin(name) === undefined) {
             return undefined;
         }
         // a method of the same name hides the built-in function
@@ -120,11 +149,7 @@ class Compare {
         if (enclosing !== undefined && new _object_oriented_1.ObjectOriented(input.scope).searchMethodName(enclosing, name).method !== undefined) {
             return undefined;
         }
-        const returning = (_d = builtin.getParameters().getReturning()) === null || _d === void 0 ? void 0 : _d.getType();
-        if (returning instanceof basic_1.StringType || returning instanceof basic_1.CharacterType) {
-            return `Built-in function "${name}" cannot be the operand of IS INITIAL`;
-        }
-        return undefined;
+        return name;
     }
 }
 exports.Compare = Compare;

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

@@ -48,6 +48,7 @@ const expressions_1 = require("../../2_statements/expressions");
 const dereference_1 = require("./dereference");
 const source_field_symbol_1 = require("./source_field_symbol");
 const source_field_1 = require("./source_field");
+const _substring_1 = require("./_substring");
 const _syntax_input_1 = require("../_syntax_input");
 const version_1 = require("../../../version");
 class FieldChain {
@@ -160,24 +161,14 @@ class FieldChain {
             }
             else if (current.get() instanceof Expressions.FieldOffset && current instanceof nodes_1.ExpressionNode) {
                 const offset = field_offset_1.FieldOffset.runSyntax(current, input);
-                if (offset) {
-                    if (context instanceof basic_1.CharacterType) {
-                        context = new basic_1.CharacterType(context.getLength() - offset);
-                    }
-                    else if (context instanceof basic_1.HexType) {
-                        context = new basic_1.HexType(context.getLength() - offset);
-                    }
+                if (!(0, _substring_1.isFieldSymbolItself)(children, i)) {
+                    context = (0, _substring_1.substringType)(context, offset, undefined, current, input);
                 }
             }
             else if (current.get() instanceof Expressions.FieldLength && current instanceof nodes_1.ExpressionNode) {
                 const length = field_length_1.FieldLength.runSyntax(current, input);
-                if (length) {
-                    if (context instanceof basic_1.CharacterType) {
-                        context = new basic_1.CharacterType(length);
-                    }
-                    else if (context instanceof basic_1.HexType) {
-                        context = new basic_1.HexType(length);
-                    }
+                if (!(0, _substring_1.isFieldSymbolItself)(children, i)) {
+                    context = (0, _substring_1.substringType)(context, undefined, length, current, input);
                 }
             }
             prev = current.concatTokens();

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

@@ -141,7 +141,12 @@ class MethodCallChain {
                 }
                 const param = current.findDirectExpression(Expressions.MethodCallParam);
                 if (param && method) {
-                    method_call_param_1.MethodCallParam.runSyntax(param, input, method);
+                    const argumentType = method_call_param_1.MethodCallParam.runSyntax(param, input, method);
+                    if (method instanceof _builtin_1.BuiltInMethod
+                        && _builtin_1.BuiltIn.returnsArgumentType(methodName)
+                        && this.isNumeric(argumentType)) {
+                        context = argumentType;
+                    }
                 }
                 else if (param && context instanceof basic_1.VoidType) {
                     method_call_param_1.MethodCallParam.runSyntax(param, input, context);
@@ -158,6 +163,16 @@ class MethodCallChain {
         return context;
     }
     //////////////////////////////////////
+    static isNumeric(type) {
+        return type instanceof basic_1.IntegerType
+            || type instanceof basic_1.Integer8Type
+            || type instanceof basic_1.PackedType
+            || type instanceof basic_1.FloatType
+            || type instanceof basic_1.FloatingPointType
+            || type instanceof basic_1.DecFloatType
+            || type instanceof basic_1.DecFloat16Type
+            || type instanceof basic_1.DecFloat34Type;
+    }
     static findTop(first, input, targetType) {
         var _a;
         if (first.get() instanceof Expressions.ClassName) {

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

@@ -46,6 +46,7 @@ const constant_1 = require("./constant");
 const _check_offset_length_1 = require("./_check_offset_length");
 const _check_text_symbol_1 = require("./_check_text_symbol");
 class MethodCallParam {
+    /** returns the type of the unnamed argument, if any */
     static runSyntax(node, input, method) {
         if (!(node.get() instanceof Expressions.MethodCallParam)) {
             const message = "MethodCallParam, unexpected input";
@@ -125,6 +126,7 @@ class MethodCallParam {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return;
             }
+            return sourceType;
         }
         else if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.ParameterListS) {
             new method_parameters_1.MethodParameters().checkExporting(child, input, method);
@@ -137,6 +139,7 @@ class MethodCallParam {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return;
         }
+        return undefined;
     }
 }
 exports.MethodCallParam = MethodCallParam;

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

@@ -47,6 +47,7 @@ const table_expression_1 = require("./table_expression");
 const expressions_1 = require("../../2_statements/expressions");
 const field_length_1 = require("./field_length");
 const cast_1 = require("./cast");
+const _substring_1 = require("./_substring");
 const _syntax_input_1 = require("../_syntax_input");
 const version_1 = require("../../../version");
 class Target {
@@ -154,6 +155,8 @@ class Target {
                 context = attribute_name_1.AttributeName.runSyntax(context, current, input, type);
             }
         }
+        // the substring is checked, but the type of the whole field is returned
+        let substring = context;
         const offset = node.findDirectExpression(Expressions.FieldOffset);
         if (offset) {
             if (context instanceof basic_1.XStringType || context instanceof basic_1.StringType) {
@@ -161,7 +164,10 @@ class Target {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
-            field_offset_1.FieldOffset.runSyntax(offset, input);
+            const value = field_offset_1.FieldOffset.runSyntax(offset, input);
+            if (!(0, _substring_1.isFieldSymbolItself)(children, children.indexOf(offset))) {
+                substring = (0, _substring_1.substringType)(substring, value, undefined, offset, input);
+            }
         }
         const length = node.findDirectExpression(Expressions.FieldLength);
         if (length) {
@@ -170,7 +176,13 @@ class Target {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
-            field_length_1.FieldLength.runSyntax(length, input);
+            const value = field_length_1.FieldLength.runSyntax(length, input);
+            if (!(0, _substring_1.isFieldSymbolItself)(children, children.indexOf(length))) {
+                substring = (0, _substring_1.substringType)(substring, undefined, value, length, input);
+            }
+        }
+        if (substring instanceof basic_1.VoidType && !(context instanceof basic_1.VoidType)) {
+            return substring;
         }
         return context;
     }

package/build/src/abap/5_syntax/statements/append.js

@@ -50,6 +50,12 @@ class Append {
         if (target) {
             targetType = target_1.Target.runSyntax(target, input);
         }
+        // a hashed table has no index, APPEND adds at the end
+        if (targetType instanceof basic_1.TableType && targetType.getAccessType() === basic_1.TableAccessType.hashed) {
+            const message = "Implicit or explicit index operation on hashed table is not possible";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
+        }
         const fsTarget = node.findExpressionAfterToken("ASSIGNING");
         if (fsTarget && fsTarget.get() instanceof Expressions.FSTarget) {
             if (!(targetType instanceof basic_1.TableType) && !(targetType instanceof basic_1.VoidType) && !(targetType instanceof basic_1.UnknownType)) {

package/build/src/abap/5_syntax/statements/read_table.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadTable = void 0;
 const Expressions = __importStar(require("../../2_statements/expressions"));
+const nodes_1 = require("../../nodes");
 const basic_1 = require("../../types/basic");
 const source_1 = require("../expressions/source");
 const inline_data_1 = require("../expressions/inline_data");
@@ -43,6 +44,9 @@ const fstarget_1 = require("../expressions/fstarget");
 const component_compare_simple_1 = require("../expressions/component_compare_simple");
 const _type_utils_1 = require("../_type_utils");
 const _syntax_input_1 = require("../_syntax_input");
+const _builtin_1 = require("../_builtin");
+const _object_oriented_1 = require("../_object_oriented");
+const version_1 = require("../../../version");
 class ReadTable {
     runSyntax(node, input) {
         const concat = node.concatTokens().toUpperCase();
@@ -69,6 +73,11 @@ class ReadTable {
         const components = node.findDirectExpression(Expressions.ComponentCompareSimple);
         if (components !== undefined) {
             component_compare_simple_1.ComponentCompareSimple.runSyntax(components, input, rowType);
+            const keyMessage = this.checkKeyOperands(components, input);
+            if (keyMessage !== undefined) {
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), keyMessage));
+                return;
+            }
         }
         const indexSource = node.findExpressionAfterToken("INDEX");
         if (indexSource) {
@@ -164,6 +173,36 @@ class ReadTable {
             }
         }
     }
+    // before 7.40 a WITH [TABLE] KEY operand is not an expression position, a built-in function from 7.02 on
+    // is read as a functional method call there, "method TO_UPPER is unknown" on a system, while
+    // functional methods and the older built-in functions like lines( ) are accepted
+    checkKeyOperands(node, input) {
+        var _a, _b;
+        if (input.scope.getOpenABAP() || (0, version_1.releaseAtLeast)(input.scope.getRelease(), version_1.Release.v740sp02)) {
+            return undefined;
+        }
+        for (const operand of node.findDirectExpressionsMulti([Expressions.Source, Expressions.SimpleSource4])) {
+            const chain = operand.getChildren();
+            if (chain.length !== 1 || !(chain[0] instanceof nodes_1.ExpressionNode) || !(chain[0].get() instanceof Expressions.MethodCallChain)) {
+                continue;
+            }
+            const calls = chain[0].getChildren();
+            if (calls.length !== 1 || !(calls[0] instanceof nodes_1.ExpressionNode) || !(calls[0].get() instanceof Expressions.MethodCall)) {
+                continue;
+            }
+            const name = (_a = calls[0].findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
+            if (name === undefined || ((_b = _builtin_1.BuiltIn.methods[name.toUpperCase()]) === null || _b === void 0 ? void 0 : _b.release) === undefined) {
+                continue;
+            }
+            // a method of the same name hides the built-in function
+            const enclosing = input.scope.findClassDefinition(input.scope.getEnclosingClassName());
+            if (enclosing !== undefined && new _object_oriented_1.ObjectOriented(input.scope).searchMethodName(enclosing, name).method !== undefined) {
+                continue;
+            }
+            return `Built-in function "${name}" cannot be a READ TABLE key operand before 7.40`;
+        }
+        return undefined;
+    }
 }
 exports.ReadTable = ReadTable;
 //# sourceMappingURL=read_table.js.map

package/build/src/abap/5_syntax/structures/cleanup.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cleanup = void 0;
+const Statements = __importStar(require("../../2_statements/statements"));
+const Structures = __importStar(require("../../3_structures/structures"));
+const nodes_1 = require("../../nodes");
+const _syntax_input_1 = require("../_syntax_input");
+const LOOPS = [
+    Structures.Loop,
+    Structures.LoopAtScreen,
+    Structures.LoopExtract,
+    Structures.Do,
+    Structures.While,
+    Structures.Select,
+    Structures.With,
+    Structures.Provide,
+];
+// a CLEANUP block cannot contain statements that statically leave it: RETURN, and EXIT, CONTINUE or CHECK
+// that do not belong to a loop inside the block, these end a loop outside the TRY or the processing block
+class Cleanup {
+    static runSyntax(node, input) {
+        if (input.scope.getOpenABAP()) {
+            return;
+        }
+        const body = node.findDirectStructure(Structures.Body);
+        if (body !== undefined) {
+            this.walk(body, false, input);
+        }
+    }
+    static walk(node, inLoop, input) {
+        for (const child of node.getChildren()) {
+            if (child instanceof nodes_1.StructureNode) {
+                const stru = child.get();
+                // a nested CLEANUP block is checked on its own, macro definitions and test injections do not run here
+                if (stru instanceof Structures.Cleanup
+                    || stru instanceof Structures.Define
+                    || stru instanceof Structures.TestInjection) {
+                    continue;
+                }
+                this.walk(child, inLoop || LOOPS.some(l => stru instanceof l), input);
+            }
+            else if (child instanceof nodes_1.StatementNode) {
+                const name = this.leavingStatement(child, inLoop);
+                if (name !== undefined) {
+                    const message = `${name} cannot leave a CLEANUP block`;
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, child.getFirstToken(), message));
+                }
+            }
+        }
+    }
+    static leavingStatement(node, inLoop) {
+        const s = node.get();
+        if (s instanceof Statements.Return) {
+            return "RETURN";
+        }
+        else if (inLoop === true) {
+            return undefined;
+        }
+        else if (s instanceof Statements.Exit && node.findDirectTokenByText("FROM") === undefined) {
+            return "EXIT";
+        }
+        else if (s instanceof Statements.Continue) {
+            return "CONTINUE";
+        }
+        else if (s instanceof Statements.Check) {
+            return "CHECK";
+        }
+        return undefined;
+    }
+}
+exports.Cleanup = Cleanup;
+//# sourceMappingURL=cleanup.js.map

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

@@ -50,6 +50,7 @@ const type_mesh_1 = require("./structures/type_mesh");
 const types_1 = require("./structures/types");
 const statics_1 = require("./structures/statics");
 const constants_1 = require("./structures/constants");
+const cleanup_1 = require("./structures/cleanup");
 const class_definition_1 = require("../types/class_definition");
 const interface_definition_1 = require("../types/interface_definition");
 const delete_memory_1 = require("./statements/delete_memory");
@@ -191,6 +192,7 @@ const _syntax_input_1 = require("./_syntax_input");
 const assert_error_1 = require("./assert_error");
 const field_group_1 = require("./statements/field_group");
 const stuff_1 = require("../../stuff");
+const _loop_table_change_1 = require("./_loop_table_change");
 // -----------------------------------
 const map = {};
 function addToMap(handler) {
@@ -352,6 +354,7 @@ class SyntaxLogic {
         };
         this.issues = [];
         this.deferred = [];
+        this.loopTables = new _loop_table_change_1.LoopTableChange();
         this.reg.getDDICReferences().clear(this.object);
         this.reg.getMSAGReferences().clear(this.object);
         if (this.object instanceof objects_1.Program && this.object.isInclude()) {
@@ -417,6 +420,9 @@ class SyntaxLogic {
         this.issues.push(issue);
     }
     traverse(node) {
+        const loop = node instanceof nodes_1.StructureNode
+            && node.get() instanceof Structures.Loop
+            && this.loopTables.push(node, this.scope);
         for (const child of node.getChildren()) {
             const isStructure = child instanceof nodes_1.StructureNode;
             const isStatement = child instanceof nodes_1.StatementNode;
@@ -449,6 +455,9 @@ class SyntaxLogic {
                 this.traverse(child);
             }
         }
+        if (loop === true) {
+            this.loopTables.pop();
+        }
     }
     /**
      * if this returns true, then the traversal should continue with next child
@@ -505,6 +514,9 @@ class SyntaxLogic {
             // todo: skipped for now
             return true;
         }
+        else if (stru instanceof Structures.Cleanup) {
+            cleanup_1.Cleanup.runSyntax(node, input);
+        }
         return false;
     }
     updateScopeStatement(node) {
@@ -534,6 +546,7 @@ class SyntaxLogic {
             this.scope.addIdentifier(new data_2.Data().runSyntax(node, input));
             return;
         }
+        this.loopTables.check(node, input);
         const name = s.constructor.name;
         if (map[name]) {
             map[name].runSyntax(node, input);

package/build/src/ddic.js

@@ -256,7 +256,7 @@ class DDIC {
     lookupDomain(name, dataElement, description) {
         const found = this.reg.getObject("DOMA", name);
         if (found) {
-            return { type: found.parseType(this.reg, dataElement, description), object: found };
+            return { type: found.parseDomainType(this.reg, dataElement, description), object: found };
         }
         else if (this.reg.inErrorNamespace(name)) {
             return { type: new Types.UnknownType(name + ", lookupDomain"), object: undefined };

package/build/src/objects/domain.js

@@ -81,7 +81,10 @@ class Domain extends _abstract_object_1.AbstractObject {
         this.parsedXML = undefined;
         super.setDirty();
     }
-    parseType(reg, dataElement, description) {
+    parseType(reg) {
+        return this.parseDomainType(reg);
+    }
+    parseDomainType(reg, dataElement, description) {
         // dont cache the DOMA parsed type, they are cached on DTEL level
         // also note that the type carries the name of the DTEL
         if (this.parsedXML === undefined) {

package/build/src/registry.js

@@ -75,7 +75,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.74";
+        return "2.120.76";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/abapdoc_html_tag.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbapdocHtmlTag = exports.AbapdocHtmlTagConf = void 0;
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const issue_1 = require("../issue");
+const _abap_rule_1 = require("./_abap_rule");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const _statement_1 = require("../abap/2_statements/statements/_statement");
+const position_1 = require("../position");
+class AbapdocHtmlTagConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.AbapdocHtmlTagConf = AbapdocHtmlTagConf;
+const ALLOWED = new Set(["p", "em", "strong", "ul", "ol", "li", "br", "h1", "h2", "h3"]);
+class AbapdocHtmlTag extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new AbapdocHtmlTagConf();
+    }
+    getMetadata() {
+        return {
+            key: "abapdoc_html_tag",
+            title: "Unsupported HTML tag in ABAP Doc",
+            shortDescription: `Reports tag-like tokens in ABAP Doc which are not ABAP Doc HTML tags.`,
+            extendedInformation: `ABAP Doc is parsed as HTML, a field symbol or a placeholder written as <name> is an
+unsupported and unclosed tag, the system warns and the rendered documentation drops the word.
+
+Supported tags are p, em, strong, ul, ol, li, br, h1, h2 and h3, also as closing tags and with attributes.
+
+Write &lt;name&gt; to show the angle brackets. A "<" which is not followed by a letter, like "a < b", is not reported.
+
+Only checks ABAP Doc inside class definitions and interfaces.`,
+            tags: [_irule_1.RuleTag.SingleFile],
+            badExample: `INTERFACE zif_foo PUBLIC.
+  "! Returns the <name> of the selected row
+  METHODS name RETURNING VALUE(result) TYPE string.
+ENDINTERFACE.`,
+            goodExample: `INTERFACE zif_foo PUBLIC.
+  "! Returns the &lt;name&gt; of the selected row
+  METHODS name RETURNING VALUE(result) TYPE string.
+ENDINTERFACE.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        let definition = false;
+        for (const statement of file.getStatements()) {
+            const type = statement.get();
+            if (type instanceof Statements.ClassDefinition || type instanceof Statements.Interface) {
+                definition = true;
+                continue;
+            }
+            else if (type instanceof Statements.EndClass || type instanceof Statements.EndInterface) {
+                definition = false;
+                continue;
+            }
+            else if (definition === false || !(type instanceof _statement_1.Comment)) {
+                continue;
+            }
+            const token = statement.getFirstToken();
+            const str = token.getStr();
+            if (str.startsWith(`"!`) === false) {
+                continue;
+            }
+            const regex = /<\/?([a-zA-Z][\w-]*)(\s[^<>]*)?\/?>/g;
+            let match;
+            while ((match = regex.exec(str)) !== null) {
+                const name = match[1];
+                if (ALLOWED.has(name.toLowerCase())) {
+                    continue;
+                }
+                const row = token.getStart().getRow();
+                const col = token.getStart().getCol() + match.index;
+                const start = new position_1.Position(row, col);
+                const end = new position_1.Position(row, col + match[0].length);
+                const message = `HTML tag <${name}> is not supported in ABAP Doc, write &lt;${name}&gt;`;
+                issues.push(issue_1.Issue.atRange(file, start, end, message, this.getMetadata().key, this.conf.severity));
+            }
+        }
+        return issues;
+    }
+}
+exports.AbapdocHtmlTag = AbapdocHtmlTag;
+//# sourceMappingURL=abapdoc_html_tag.js.map