@abaplint/core 2.120.74 → 2.120.76

package/build/abaplint.d.ts

@@ -624,6 +624,8 @@ export declare class BuiltIn {
     static searchBuiltin(name: string | undefined): IMethodDefinition | undefined;
     private static readonly unnamedArgument;
     static hasUnnamedArgument(name: string | undefined): boolean;
+    private static readonly argumentTypedReturn;
+    static returnsArgumentType(name: string | undefined): boolean;
     static isPredicate(name: string | undefined): boolean | undefined;
     getTypes(): TypedIdentifier[];
     get(extras: string[]): TypedIdentifier[];
@@ -2038,7 +2040,8 @@ declare class Domain extends AbstractObject {
     };
     getIdentifier(): Identifier | undefined;
     setDirty(): void;
-    parseType(reg: IRegistry, dataElement?: string, description?: string): AbstractType;
+    parseType(reg: IRegistry): AbstractType;
+    parseDomainType(reg: IRegistry, dataElement?: string, description?: string): AbstractType;
     parse(): {
         updated: boolean;
         runtime: number;
@@ -7810,6 +7813,7 @@ export declare class SyntaxLogic {
     private readonly object;
     private readonly reg;
     private scope;
+    private loopTables;
     private helpers;
     constructor(reg: IRegistry, object: ABAPObject);
     run(): ISyntaxResult;

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

@@ -58,6 +58,9 @@ const Tokens = __importStar(require("../1_lexer/tokens"));
 const nodes_1 = require("../nodes");
 const version_1 = require("../../version");
 const result_1 = require("./result");
+// shared result for "nothing matched", frozen so accidental mutation throws instead of leaking between calls.
+// Returned arrays are never mutated by callers, which allows returning shared/input arrays as is
+const EMPTY = Object.freeze([]);
 class Regex {
     constructor(r) {
         this.regexp = r;
@@ -69,17 +72,23 @@ class Regex {
         return [];
     }
     run(r) {
-        const result = [];
+        let result = undefined;
         for (const input of r) {
             if (input.remainingLength() === 0) {
                 continue;
             }
             const token = input.peek();
             if (this.regexp.test(token.getStr()) === true) {
-                result.push(input.shift(new nodes_1.TokenNodeRegex(token)));
+                const shifted = input.shift(new nodes_1.TokenNodeRegex(token));
+                if (result === undefined) {
+                    result = [shifted];
+                }
+                else {
+                    result.push(shifted);
+                }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         return "Railroad.Terminal(\"" + this.regexp.source.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\")";
@@ -102,15 +111,20 @@ class Word {
         return [];
     }
     run(r) {
-        const result = [];
+        let result = undefined;
         for (const input of r) {
             if (input.remainingLength() !== 0
                 && input.peek().getUpperStr() === this.s) {
-                //        console.log("match, " + this.s + result.length);
-                result.push(input.shift(new nodes_1.TokenNode(input.peek())));
+                const shifted = input.shift(new nodes_1.TokenNode(input.peek()));
+                if (result === undefined) {
+                    result = [shifted];
+                }
+                else {
+                    result.push(shifted);
+                }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         return "Railroad.Terminal('\"" + this.s + "\"')";
@@ -134,14 +148,20 @@ class Token {
         return [];
     }
     run(r) {
-        const result = [];
+        let result = undefined;
         for (const input of r) {
             if (input.remainingLength() !== 0
                 && input.peek().constructor === this.tokenType) {
-                result.push(input.shift(new nodes_1.TokenNode(input.peek())));
+                const shifted = input.shift(new nodes_1.TokenNode(input.peek()));
+                if (result === undefined) {
+                    result = [shifted];
+                }
+                else {
+                    result.push(shifted);
+                }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         let text = this.name;
@@ -179,9 +199,9 @@ class Vers {
             if (this.also === AlsoIn.OpenABAP) {
                 return this.runnable.run(r);
             }
-            return (0, version_1.releaseAtLeast)(version_1.Release.v702, this.release) ? this.runnable.run(r) : [];
+            return (0, version_1.releaseAtLeast)(version_1.Release.v702, this.release) ? this.runnable.run(r) : EMPTY;
         }
-        return (0, version_1.releaseAtLeast)(Combi.getRelease(), this.release) ? this.runnable.run(r) : [];
+        return (0, version_1.releaseAtLeast)(Combi.getRelease(), this.release) ? this.runnable.run(r) : EMPTY;
     }
     getUsing() {
         return this.runnable.getUsing();
@@ -229,7 +249,7 @@ class LangVers {
             return this.runnable.run(r);
         }
         else {
-            return [];
+            return EMPTY;
         }
     }
     railroad() {
@@ -262,7 +282,7 @@ class LangVersNot {
             return this.runnable.run(r);
         }
         else {
-            return [];
+            return EMPTY;
         }
     }
     railroad() {
@@ -290,6 +310,22 @@ class OptionalPriority {
         return this.optional.getUsing();
     }
     run(r) {
+        if (r.length === 1) {
+            // single input, pass and return the input array without wrapping
+            const res = this.optional.run(r);
+            if (res.length > 1) {
+                return res;
+            }
+            else if (res.length === 0) {
+                return r;
+            }
+            else if (res[0].remainingLength() < r[0].remainingLength()) {
+                return res;
+            }
+            else {
+                return r;
+            }
+        }
         const result = [];
         for (const input of r) {
             const res = this.optional.run([input]);
@@ -329,6 +365,11 @@ class Optional {
         return this.optional.getUsing();
     }
     run(r) {
+        if (r.length === 1) {
+            // single input, pass and return the input array without wrapping
+            const res = this.optional.run(r);
+            return res.length === 0 ? r : r.concat(res);
+        }
         const result = [];
         for (const input of r) {
             result.push(input);
@@ -366,14 +407,16 @@ class Star {
         let result = r;
         try {
             let res = r;
-            let input = [];
             for (;;) {
-                input = res;
-                res = this.sta.run(input);
+                res = this.sta.run(res);
                 if (res.length === 0) {
                     break;
                 }
-                if (res.length > 1000) {
+                if (result === r) {
+                    // copy on first match, the input array must not be mutated
+                    result = r.concat(res);
+                }
+                else if (res.length > 1000) {
                     // avoid stack overflow
                     result = result.concat(res);
                 }
@@ -515,6 +558,17 @@ class Sequence {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
+        if (r.length === 1) {
+            // single input, pass it down without wrapping and return the last result as is
+            let temp = r;
+            for (const sequence of this.list) {
+                temp = sequence.run(temp);
+                if (temp.length === 0) {
+                    return EMPTY;
+                }
+            }
+            return temp;
+        }
         let result = [];
         for (const input of r) {
             let temp = [input];
@@ -592,12 +646,33 @@ class Expression {
         this.runnable = undefined;
     }
     run(r) {
-        const results = [];
         if (this.runnable === undefined) {
             this.runnable = this.getRunnable();
         }
+        if (r.length === 1) {
+            // single input, pass it down without wrapping
+            const input = r[0];
+            const temp = this.runnable.run(r);
+            if (temp.length === 0) {
+                return EMPTY;
+            }
+            const results = new Array(temp.length);
+            for (let i = 0; i < temp.length; i++) {
+                const t = temp[i];
+                const consumed = input.remainingLength() - t.remainingLength();
+                results[i] = consumed > 0 ? t.wrapConsumed(consumed, new nodes_1.ExpressionNode(this)) : t;
+            }
+            return results;
+        }
+        let results = undefined;
         for (const input of r) {
             const temp = this.runnable.run([input]);
+            if (temp.length === 0) {
+                continue;
+            }
+            else if (results === undefined) {
+                results = [];
+            }
             for (const t of temp) {
                 const consumed = input.remainingLength() - t.remainingLength();
                 if (consumed > 0) {
@@ -609,8 +684,7 @@ class Expression {
                 }
             }
         }
-        //    console.dir(results);
-        return results;
+        return results !== null && results !== void 0 ? results : EMPTY;
     }
     listKeywords() {
         // do not recurse, all Expressions are evaluated only on first level
@@ -651,12 +725,16 @@ class Permutation {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
-        const result = [];
-        const copy = this.list.slice();
+        let result = undefined;
+        let copy = undefined;
         for (let index = 0; index < this.list.length; index++) {
             const temp = this.list[index].run(r);
             if (temp.length !== 0) {
                 // match
+                if (result === undefined || copy === undefined) {
+                    result = [];
+                    copy = this.list.slice();
+                }
                 result.push(...temp);
                 const left = copy;
                 left.splice(index, 1);
@@ -668,7 +746,7 @@ class Permutation {
                 }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         const children = this.list.map((e) => { return e.railroad(); });
@@ -745,17 +823,31 @@ class Alternative {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
-        const result = [];
+        var _a;
+        // only allocate a new array when more than one alternative matches
+        let single = undefined;
+        let result = undefined;
         for (const sequ of this.list) {
             const temp = sequ.run(r);
-            if (temp.length === 1) {
-                result.push(temp[0]);
+            if (temp.length === 0) {
+                continue;
+            }
+            else if (result !== undefined) {
+                if (temp.length === 1) {
+                    result.push(temp[0]);
+                }
+                else {
+                    result.push(...temp);
+                }
+            }
+            else if (single !== undefined) {
+                result = single.concat(temp);
             }
             else {
-                result.push(...temp);
+                single = temp;
             }
         }
-        return result;
+        return (_a = result !== null && result !== void 0 ? result : single) !== null && _a !== void 0 ? _a : EMPTY;
     }
     railroad() {
         const children = this.list.map((e) => { return e.railroad(); });
@@ -806,21 +898,13 @@ class AlternativePriority {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
-        const result = [];
         for (const sequ of this.list) {
-            //      console.log(seq.toStr());
             const temp = sequ.run(r);
             if (temp.length > 0) {
-                if (temp.length === 1) {
-                    result.push(temp[0]);
-                }
-                else {
-                    result.push(...temp);
-                }
-                break;
+                return temp;
             }
         }
-        return result;
+        return EMPTY;
     }
     railroad() {
         const children = this.list.map((e) => { return e.railroad(); });
@@ -1026,18 +1110,21 @@ class StopBefore2 {
     getUsing() { return []; }
     run(r) {
         var _a;
-        const result = [];
-        for (const input of r) {
+        // only copy when something is filtered out
+        let result = undefined;
+        for (let i = 0; i < r.length; i++) {
+            const input = r[i];
             const next = input.peek();
-            if (next === undefined) {
-                continue;
-            }
-            if (next.getUpperStr() === this.t1 && ((_a = input.peekAt(1)) === null || _a === void 0 ? void 0 : _a.getUpperStr()) === this.t2) {
+            if (next === undefined
+                || (next.getUpperStr() === this.t1 && ((_a = input.peekAt(1)) === null || _a === void 0 ? void 0 : _a.getUpperStr()) === this.t2)) {
+                if (result === undefined) {
+                    result = r.slice(0, i);
+                }
                 continue;
             }
-            result.push(input);
+            result === null || result === void 0 ? void 0 : result.push(input);
         }
-        return result;
+        return result !== null && result !== void 0 ? result : r;
     }
     railroad() { return "Railroad.Terminal('stopBefore(" + this.t1 + " " + this.t2 + ")')"; }
     toStr() { return "stopBefore(" + this.t1 + "," + this.t2 + ")"; }
@@ -1052,15 +1139,20 @@ class StopBefore1 {
     getUsing() { return []; }
     run(r) {
         var _a;
-        const result = [];
-        for (const input of r) {
+        // only copy when something is filtered out
+        let result = undefined;
+        for (let i = 0; i < r.length; i++) {
+            const input = r[i];
             const next = (_a = input.peek()) === null || _a === void 0 ? void 0 : _a.getUpperStr();
             if (next !== undefined && this.words.includes(next)) {
+                if (result === undefined) {
+                    result = r.slice(0, i);
+                }
                 continue;
             }
-            result.push(input);
+            result === null || result === void 0 ? void 0 : result.push(input);
         }
-        return result;
+        return result !== null && result !== void 0 ? result : r;
     }
     railroad() { return "Railroad.Terminal('stopBefore(" + this.words.join("|") + ")')"; }
     toStr() { return "stopBefore(" + this.words.join(",") + ")"; }

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

@@ -124,6 +124,12 @@ class BuiltIn {
         }
         return BuiltIn.unnamedArgument.has(name.toUpperCase());
     }
+    static returnsArgumentType(name) {
+        if (name === undefined) {
+            return false;
+        }
+        return BuiltIn.argumentTypedReturn.has(name.toUpperCase());
+    }
     static isPredicate(name) {
         if (name === undefined) {
             return undefined;
@@ -1231,4 +1237,6 @@ BuiltIn.unnamedArgument = new Set([
     "FRAC", "LINES", "LOG", "LOG10", "NUMOFCHAR", "SIGN", "SIN", "SINH", "SQRT", "STRLEN", "TAN", "TANH",
     "TRUNC", "XSTRLEN"
 ]);
+// numeric functions returning a value of the type of the argument
+BuiltIn.argumentTypedReturn = new Set(["ABS", "CEIL", "FLOOR", "FRAC", "SIGN", "TRUNC"]);
 //# sourceMappingURL=_builtin.js.map

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

@@ -0,0 +1,126 @@
+"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.LoopTableChange = void 0;
+const Expressions = __importStar(require("../2_statements/expressions"));
+const Statements = __importStar(require("../2_statements/statements"));
+const nodes_1 = require("../nodes");
+const basic_1 = require("../types/basic");
+const _scope_type_1 = require("./_scope_type");
+const _syntax_input_1 = require("./_syntax_input");
+/** In a method, the body of the table an enclosing LOOP AT walks cannot be replaced or freed,
+ *  "you cannot access the entire table body in change mode in a loop. If this is known statically,
+ *  a syntax error occurs in classes", see the ABAP keyword documentation for LOOP AT itab.
+ *  Only tables named directly are handled, a field symbol or a reference is a runtime matter. */
+class LoopTableChange {
+    constructor() {
+        this.tables = [];
+    }
+    /** returns true if the LOOP structure was pushed, then pop() must be called after it */
+    push(node, scope) {
+        var _a, _b;
+        if (scope.getType() !== _scope_type_1.ScopeType.Method) {
+            return false;
+        }
+        const loop = node.findDirectStatement(Statements.Loop);
+        if (loop === undefined || loop.findDirectExpression(Expressions.LoopGroupBy) !== undefined) {
+            return false;
+        }
+        const chain = (_b = (_a = loop.findDirectExpression(Expressions.LoopSource)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(Expressions.SimpleSource2)) === null || _b === void 0 ? void 0 : _b.findDirectExpression(Expressions.FieldChain);
+        const children = (chain === null || chain === void 0 ? void 0 : chain.getChildren()) || [];
+        if (children.length !== 1 && !(children.length === 2 && children[1].get() instanceof Expressions.TableBody)) {
+            return false;
+        }
+        const found = LoopTableChange.findTable(children[0], scope);
+        if (found === undefined) {
+            return false;
+        }
+        this.tables.push(found);
+        return true;
+    }
+    pop() {
+        this.tables.pop();
+    }
+    check(node, input) {
+        if (this.tables.length === 0 || input.scope.getType() !== _scope_type_1.ScopeType.Method) {
+            return;
+        }
+        // DELETE itab WHERE is not refused, abapGit does it in zcl_abapgit_syntax_xml->order_matches,
+        // SORT is left out, it is not certain that it is checked statically
+        const s = node.get();
+        if (!(s instanceof Statements.Clear)
+            && !(s instanceof Statements.Free)
+            && !(s instanceof Statements.Refresh)
+            && !(s instanceof Statements.Move)) {
+            return;
+        }
+        for (const target of node.findDirectExpressions(Expressions.Target)) {
+            const children = target.getChildren();
+            const body = children.length === 2 && children[1].get() instanceof Expressions.TableBody;
+            if (children.length !== 1 && body === false) {
+                continue;
+            }
+            else if (!(children[0].get() instanceof Expressions.TargetField)) {
+                continue;
+            }
+            const found = LoopTableChange.findTable(children[0], input.scope);
+            if (found === undefined || this.tables.includes(found) === false) {
+                continue;
+            }
+            else if (found.getType().isWithHeader() === true && body === false) {
+                // without [] the statement works on the header line
+                continue;
+            }
+            const message = `"${found.getName()}" cannot be changed as a whole inside a LOOP over it`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
+        }
+    }
+    static findTable(node, scope) {
+        var _a;
+        if (!(node instanceof nodes_1.ExpressionNode)
+            || node.getChildren().length !== 1
+            || !(((_a = node.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Field)) {
+            return undefined;
+        }
+        const found = scope.findVariable(node.concatTokens());
+        if (found === undefined || !(found.getType() instanceof basic_1.TableType)) {
+            return undefined;
+        }
+        return found;
+    }
+}
+exports.LoopTableChange = LoopTableChange;
+//# sourceMappingURL=_loop_table_change.js.map

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

@@ -0,0 +1,83 @@
+"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.substringType = substringType;
+exports.isFieldSymbolItself = isFieldSymbolItself;
+const Expressions = __importStar(require("../../2_statements/expressions"));
+const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
+// The type of a substring with a static offset or length, used for reading and writing positions.
+// On a character or byte field of fixed length the substring must lie inside the field, else it is
+// a syntax error. Other types, a dynamic offset or length and "*" (undefined) are left alone, as is
+// length 0. The offset is applied first, so the length is compared to what remains after the offset.
+function substringType(context, offset, length, node, input) {
+    if (!(context instanceof basic_1.CharacterType) && !(context instanceof basic_1.HexType)) {
+        return context;
+    }
+    const fieldLength = context.getLength();
+    if (offset !== undefined && offset > 0) {
+        if (offset >= fieldLength) {
+            const message = `Offset ${offset} is outside the field of length ${fieldLength}`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+        }
+        return context instanceof basic_1.CharacterType ? new basic_1.CharacterType(fieldLength - offset) : new basic_1.HexType(fieldLength - offset);
+    }
+    if (length !== undefined && length > 0) {
+        if (length > fieldLength) {
+            const message = `Length ${length} exceeds the remaining length ${fieldLength} of the field`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+        }
+        return context instanceof basic_1.CharacterType ? new basic_1.CharacterType(length) : new basic_1.HexType(length);
+    }
+    return context;
+}
+// A field symbol typed "c" or "x" is generic, but its type is represented with length 1, so the
+// offset or length at "index" is not checked when it directly follows the field symbol
+function isFieldSymbolItself(children, index) {
+    var _a;
+    const first = (_a = children[0]) === null || _a === void 0 ? void 0 : _a.get();
+    if (!(first instanceof Expressions.SourceFieldSymbol) && !(first instanceof Expressions.TargetFieldSymbol)) {
+        return false;
+    }
+    for (let i = 1; i < index; i++) {
+        if (!(children[i].get() instanceof Expressions.FieldOffset)) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=_substring.js.map

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

@@ -46,6 +46,7 @@ const attribute_name_1 = require("./attribute_name");
 const table_expression_1 = require("./table_expression");
 const field_offset_1 = require("./field_offset");
 const field_length_1 = require("./field_length");
+const _substring_1 = require("./_substring");
 class AttributeChain {
     static runSyntax(inputContext, node, input, type) {
         if (inputContext instanceof void_type_1.VoidType) {
@@ -122,25 +123,11 @@ class AttributeChain {
             }
             else if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.FieldOffset) {
                 const offset = field_offset_1.FieldOffset.runSyntax(child, input);
-                if (offset !== undefined) {
-                    if (contextType instanceof basic_1.CharacterType) {
-                        contextType = new basic_1.CharacterType(contextType.getLength() - offset);
-                    }
-                    else if (contextType instanceof basic_1.HexType) {
-                        contextType = new basic_1.HexType(contextType.getLength() - offset);
-                    }
-                }
+                contextType = (0, _substring_1.substringType)(contextType, offset, undefined, child, input);
             }
             else if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.FieldLength) {
                 const length = field_length_1.FieldLength.runSyntax(child, input);
-                if (length !== undefined) {
-                    if (contextType instanceof basic_1.CharacterType) {
-                        contextType = new basic_1.CharacterType(length);
-                    }
-                    else if (contextType instanceof basic_1.HexType) {
-                        contextType = new basic_1.HexType(length);
-                    }
-                }
+                contextType = (0, _substring_1.substringType)(contextType, undefined, length, child, input);
             }
         }
         return contextType;