@abaplint/core 2.120.71 → 2.120.73

package/build/abaplint.d.ts

@@ -3681,6 +3681,14 @@ declare interface IMatch {
     errorMatched: number;
 }
 
+/** A match from an index: statements[index] up to statements[next] were matched */
+declare interface IMatchAt {
+    next: number;
+    error: boolean;
+    errorDescription: string;
+    errorMatched: number;
+}
+
 export declare interface IMethodDefinition extends Identifier {
     getVisibility(): Visibility;
     isRedefinition(): boolean;
@@ -4357,6 +4365,7 @@ declare interface IStructureRunnable {
     toRailroad(): string;
     getUsing(): string[];
     run(statements: StatementNode[], parent: INode): IMatch;
+    runAt(statements: StatementNode[], index: number, parent: INode): IMatchAt;
     first(): string[];
 }
 
@@ -7831,6 +7840,7 @@ declare class Table extends AbstractObject {
         PRECFIELD?: string;
         LENG?: string;
         INTLEN?: string;
+        INTTYPE?: string;
         DATATYPE?: string;
         DECIMALS?: string;
         KEYFLAG?: string;

package/build/src/abap/1_lexer/lexer.js

@@ -343,7 +343,7 @@ class Lexer {
             else if (this.m === ModeTemplate
                 && this.buffer.length() > 1
                 && (current === CH_PIPE || current === CH_LBRACE)
-                && (stream.prevChar() !== CH_BACKSLASH || (stream.prevPrevChar() === CH_BACKSLASH && stream.prevChar() === CH_BACKSLASH))) {
+                && stream.countPrevious(CH_BACKSLASH) % 2 === 0) {
                 // end of template
                 if (current === CH_LBRACE || AFTER_LITERAL.has(ahead)) {
                     this.add();

package/build/src/abap/1_lexer/lexer_stream.js

@@ -46,6 +46,14 @@ class LexerStream {
         }
         return this.raw.charCodeAt(o);
     }
+    /** number of consecutive occurrences of the character directly before the current one */
+    countPrevious(code) {
+        let count = 0;
+        for (let o = this.offset - 1; o >= 0 && this.raw.charCodeAt(o) === code; o--) {
+            count++;
+        }
+        return count;
+    }
     currentChar() {
         if (this.offset < 0) {
             return NL; // simulate newline at start of file to handle star(*) comments

package/build/src/abap/3_structures/structures/_combi.js

@@ -9,6 +9,21 @@ exports.sta = sta;
 exports.sub = sub;
 const nodes_1 = require("../../nodes");
 const _statement_1 = require("../../2_statements/statements/_statement");
+function toMatch(statements, m) {
+    return {
+        matched: statements.slice(0, m.next),
+        unmatched: statements.slice(m.next),
+        error: m.error,
+        errorDescription: m.errorDescription,
+        errorMatched: m.errorMatched,
+    };
+}
+function success(next) {
+    return { next, error: false, errorDescription: "", errorMatched: 0 };
+}
+function failure(next, errorDescription, errorMatched) {
+    return { next, error: true, errorDescription, errorMatched };
+}
 class Sequence {
     constructor(list) {
         if (list.length < 2) {
@@ -27,36 +42,18 @@ class Sequence {
         return this.list[0].first();
     }
     run(statements, parent) {
-        let inn = statements;
-        let out = [];
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        let next = index;
         for (const i of this.list) {
-            const match = i.run(inn, parent);
+            const match = i.runAt(statements, next, parent);
             if (match.error) {
-                return {
-                    matched: [],
-                    unmatched: statements,
-                    error: true,
-                    errorDescription: match.errorDescription,
-                    errorMatched: out.length,
-                };
+                return failure(index, match.errorDescription, next - index);
             }
-            if (match.matched.length < 100) {
-                out.push(...match.matched);
-            }
-            else {
-                // avoid using the spread operator, it might trigger "Maximum call stack size exceeded"
-                // when the number of matched elements is very large
-                out = out.concat(match.matched);
-            }
-            inn = match.unmatched;
+            next = match.next;
         }
-        return {
-            matched: out,
-            unmatched: inn,
-            error: false,
-            errorDescription: "",
-            errorMatched: 0,
-        };
+        return success(next);
     }
 }
 // Note that the Alternative does not nessesarily return the first in the alternative
@@ -95,21 +92,18 @@ class Alternative {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(statements, parent) {
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
         this.setupMap();
         let count = 0;
         let countError = "";
-        if (statements.length === 0) {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: countError,
-                errorMatched: count,
-            };
+        if (index >= statements.length) {
+            return failure(index, countError, count);
         }
-        const token = statements[0].getFirstToken().getStr().toUpperCase();
+        const token = statements[index].getFirstToken().getStr().toUpperCase();
         for (const i of this.map[token] || []) {
-            const match = i.run(statements, parent);
+            const match = i.runAt(statements, index, parent);
             if (match.error === false) {
                 return match;
             }
@@ -119,7 +113,7 @@ class Alternative {
             }
         }
         for (const i of this.map[""] || []) {
-            const match = i.run(statements, parent);
+            const match = i.runAt(statements, index, parent);
             if (match.error === false) {
                 return match;
             }
@@ -129,22 +123,10 @@ class Alternative {
             }
         }
         if (count === 0) {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: "Unexpected code structure",
-                errorMatched: count,
-            };
+            return failure(index, "Unexpected code structure", count);
         }
         else {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: countError,
-                errorMatched: count,
-            };
+            return failure(index, countError, count);
         }
     }
 }
@@ -159,7 +141,10 @@ class Optional {
         return this.obj.getUsing();
     }
     run(statements, parent) {
-        const ret = this.obj.run(statements, parent);
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        const ret = this.obj.runAt(statements, index, parent);
         ret.error = false;
         return ret;
     }
@@ -178,48 +163,24 @@ class Star {
         return this.obj.getUsing();
     }
     run(statements, parent) {
-        let inn = statements;
-        let out = [];
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        let next = index;
         while (true) {
-            if (inn.length === 0) {
-                return {
-                    matched: out,
-                    unmatched: inn,
-                    error: false,
-                    errorDescription: "",
-                    errorMatched: 0,
-                };
+            if (next >= statements.length) {
+                return success(next);
             }
-            const match = this.obj.run(inn, parent);
+            const match = this.obj.runAt(statements, next, parent);
             if (match.error === true) {
                 if (match.errorMatched > 0) {
-                    return {
-                        matched: out,
-                        unmatched: inn,
-                        error: true,
-                        errorDescription: match.errorDescription,
-                        errorMatched: match.errorMatched,
-                    };
+                    return failure(next, match.errorDescription, match.errorMatched);
                 }
                 else {
-                    return {
-                        matched: out,
-                        unmatched: inn,
-                        error: false,
-                        errorDescription: "",
-                        errorMatched: 0,
-                    };
+                    return success(next);
                 }
             }
-            if (match.matched.length < 100) {
-                out.push(...match.matched);
-            }
-            else {
-                // avoid using the spread operator, it might trigger "Maximum call stack size exceeded"
-                // when the number of matched elements is very large
-                out = out.concat(match.matched);
-            }
-            inn = match.unmatched;
+            next = match.next;
         }
     }
     first() {
@@ -248,10 +209,13 @@ class SubStructure {
         }
     }
     run(statements, parent) {
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
         const nparent = new nodes_1.StructureNode(this.s);
         this.setupMatcher();
-        const ret = this.matcher.run(statements, nparent);
-        if (ret.matched.length === 0) {
+        const ret = this.matcher.runAt(statements, index, nparent);
+        if (ret.next === index) {
             ret.error = true;
         }
         else {
@@ -281,33 +245,18 @@ class SubStatement {
         return this.obj.name;
     }
     run(statements, parent) {
-        if (statements.length === 0) {
-            return {
-                matched: [],
-                unmatched: [],
-                error: true,
-                errorDescription: "Expected " + this.className().toUpperCase(),
-                errorMatched: 0,
-            };
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        if (index >= statements.length) {
+            return failure(statements.length, "Expected " + this.className().toUpperCase(), 0);
         }
-        else if (statements[0].get() instanceof this.obj) {
-            parent.addChild(statements[0]);
-            return {
-                matched: [statements[0]],
-                unmatched: statements.splice(1),
-                error: false,
-                errorDescription: "",
-                errorMatched: 0,
-            };
+        else if (statements[index].get() instanceof this.obj) {
+            parent.addChild(statements[index]);
+            return success(index + 1);
         }
         else {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: "Expected " + this.className().toUpperCase(),
-                errorMatched: 0,
-            };
+            return failure(index, "Expected " + this.className().toUpperCase(), 0);
         }
     }
 }

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

@@ -153,7 +153,7 @@ class BasicTypes {
         if (children.length === 0) {
             return new Types.UnknownType("Type error, could not resolve \"" + fullName + "\", resolveLikeName1");
         }
-        let type = undefined;
+        let type;
         if (children[1] && (children[1].getFirstToken().getStr() === "=>" || children[1].getFirstToken().getStr() === "->")) {
             type = field_chain_1.FieldChain.runSyntax(chain, this.input, _reference_1.ReferenceType.TypeReference);
         }
@@ -416,7 +416,7 @@ class BasicTypes {
             primaryKey: primaryKey,
             secondary: secondaryKeys,
         };
-        let found = undefined;
+        let found;
         if (text.startsWith("TYPE TABLE OF REF TO ")
             || text.startsWith("TYPE STANDARD TABLE OF REF TO ")
             || text.startsWith("TYPE SORTED TABLE OF REF TO ")
@@ -554,7 +554,7 @@ class BasicTypes {
                 name = typeName === null || typeName === void 0 ? void 0 : typeName.concatTokens();
             }
             const type = this.resolveLikeName(e, false);
-            let row = undefined;
+            let row;
             if (type === undefined) {
                 return new Types.UnknownType("Type error, could not resolve \"" + name + "\", parseType");
             }
@@ -749,7 +749,7 @@ class BasicTypes {
             rest = split[1];
         }
         const subs = rest.split("-");
-        let foundType = undefined;
+        let foundType;
         if (className && chainText.includes("=>")) {
             const split = chainText.split("=>");
             const className = split[0];

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

@@ -0,0 +1,127 @@
+"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.checkDatabaseWorkArea = checkDatabaseWorkArea;
+const nodes_1 = require("../../nodes");
+const Expressions = __importStar(require("../../2_statements/expressions"));
+const Basic = __importStar(require("../../types/basic"));
+const objects_1 = require("../../../objects");
+const _syntax_input_1 = require("../_syntax_input");
+// byte length of a flat type in a unicode system, as a lower and an upper bound:
+// IntegerType also stands for INT1 and INT2, and padding is left out of the lower bound
+function bounds(type) {
+    if (type instanceof Basic.CharacterType || type instanceof Basic.NumericType) {
+        return { min: type.getLength() * 2, max: type.getLength() * 2, align: 2 };
+    }
+    else if (type instanceof Basic.DateType) {
+        return { min: 16, max: 16, align: 2 };
+    }
+    else if (type instanceof Basic.TimeType) {
+        return { min: 12, max: 12, align: 2 };
+    }
+    else if (type instanceof Basic.IntegerType) {
+        return { min: 1, max: 4, align: 4 };
+    }
+    else if (type instanceof Basic.Integer8Type || type instanceof Basic.FloatType
+        || type instanceof Basic.DecFloat16Type || type instanceof Basic.UTCLongType) {
+        return { min: 8, max: 8, align: 8 };
+    }
+    else if (type instanceof Basic.DecFloat34Type) {
+        return { min: 16, max: 16, align: 16 };
+    }
+    else if (type instanceof Basic.PackedType || type instanceof Basic.HexType) {
+        return { min: type.getLength(), max: type.getLength(), align: 1 };
+    }
+    else if (type instanceof Basic.StructureType) {
+        let min = 0;
+        let max = 0;
+        let align = 1;
+        for (const component of type.getComponents()) {
+            const sub = bounds(component.type);
+            if (sub === undefined) {
+                return undefined;
+            }
+            align = Math.max(align, sub.align);
+            max = Math.ceil(max / sub.align) * sub.align + sub.max;
+            min = min + sub.min;
+        }
+        max = Math.ceil(max / align) * align;
+        return { min, max, align };
+    }
+    // deep, generic, void or unknown
+    return undefined;
+}
+// INSERT/MODIFY/UPDATE dbtab FROM wa: the work area must be at least as long as the table line,
+// client field included, else the statement is a syntax error on the system
+function checkDatabaseWorkArea(node, dbSource, sourceTypes, input) {
+    var _a;
+    if (!(dbSource instanceof objects_1.Table)) {
+        return;
+    }
+    const children = node.getChildren();
+    let workArea = undefined;
+    for (let i = 0; i < children.length - 1; i++) {
+        const child = children[i];
+        if (child instanceof nodes_1.TokenNode && child.concatTokens().toUpperCase() === "FROM") {
+            const next = children[i + 1];
+            if (next instanceof nodes_1.ExpressionNode && next.get() instanceof Expressions.SQLSource) {
+                workArea = next;
+            }
+            break;
+        }
+    }
+    if (workArea === undefined) {
+        return;
+    }
+    const source = (_a = workArea.findFirstExpression(Expressions.SimpleSource3)) !== null && _a !== void 0 ? _a : workArea.findFirstExpression(Expressions.Source);
+    if (source === undefined) {
+        return;
+    }
+    const waType = sourceTypes.get(source);
+    if (!(waType instanceof Basic.StructureType)) {
+        return;
+    }
+    const tableType = dbSource.parseType(input.scope.getRegistry());
+    const waBounds = bounds(waType);
+    const tableBounds = bounds(tableType);
+    if (waBounds === undefined || tableBounds === undefined) {
+        return;
+    }
+    if (waBounds.max < tableBounds.min) {
+        const message = "The work area \"" + source.concatTokens() + "\" is not long enough for table " + dbSource.getName();
+        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, source.getFirstToken(), message));
+    }
+}
+//# sourceMappingURL=_check_database_work_area.js.map

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

@@ -17,7 +17,7 @@ class AttributeName {
             return context;
         }
         const helper = new _object_oriented_1.ObjectOriented(input.scope);
-        let ret = undefined;
+        let ret;
         if (context instanceof object_reference_type_1.ObjectReferenceType) {
             const def = input.scope.findObjectDefinition(context.getIdentifierName());
             if (def === undefined) {

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

@@ -40,7 +40,7 @@ const let_1 = require("./let");
 const _syntax_input_1 = require("../_syntax_input");
 const basic_1 = require("../../types/basic");
 class ConvBody {
-    static runSyntax(node, input) {
+    static runSyntax(node, input, targetType) {
         let scoped = false;
         const l = node.findDirectExpression(Expressions.Let);
         if (l) {
@@ -52,7 +52,7 @@ class ConvBody {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
-        const sourceType = source_1.Source.runSyntax(s, input);
+        const sourceType = source_1.Source.runSyntax(s, input, targetType);
         if (scoped === true) {
             input.scope.pop(node.getLastToken().getEnd());
         }

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

@@ -68,7 +68,7 @@ class FieldChain {
                 return found.getType();
             }
         }
-        let context = undefined;
+        let context;
         const children = node.getChildren();
         context = this.findTop(children[0], input, refType);
         let prev = children[0].concatTokens();

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

@@ -21,7 +21,7 @@ class FormParam {
         if (node.findDirectTokenByText("STRUCTURE") && nameToken) {
             // STRUCTURES typing
             const typeName = (_a = node.findDirectExpression(expressions_1.SimpleFieldChain)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr();
-            let type = undefined;
+            let type;
             if (typeName) {
                 type = (_b = input.scope.findType(typeName)) === null || _b === void 0 ? void 0 : _b.getType();
                 if (type === undefined) {

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

@@ -127,7 +127,7 @@ class MethodParameters {
     }
     checkImporting(node, input, method) {
         for (const item of this.parameterListT(node, input)) {
-            let parameterType = undefined;
+            let parameterType;
             if (method instanceof basic_1.VoidType) {
                 parameterType = method;
             }
@@ -164,7 +164,7 @@ class MethodParameters {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return;
             }
-            let parameterType = undefined;
+            let parameterType;
             if (method instanceof basic_1.VoidType) {
                 parameterType = method;
             }

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

@@ -485,9 +485,8 @@ class Select {
     }
     static findFields(node, input) {
         var _a, _b;
-        let expr = undefined;
+        const expr = node.findFirstExpression(Expressions.SQLFieldList);
         const ret = [];
-        expr = node.findFirstExpression(Expressions.SQLFieldList);
         if (((_a = expr === null || expr === void 0 ? void 0 : expr.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
             dynamic_1.Dynamic.runSyntax(expr.getFirstChild(), input);
         }

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

@@ -61,6 +61,7 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const _type_utils_1 = require("../_type_utils");
 const _syntax_input_1 = require("../_syntax_input");
 const assert_error_1 = require("../assert_error");
+const version_1 = require("../../../version");
 /*
 * Type interference, valid scenarios:
 * typed = VALUE #( ... ).         right hand side must follow left hand type
@@ -73,7 +74,7 @@ const assert_error_1 = require("../assert_error");
 // TODO: refactor all these method parameters to objects, this is getting messy
 class Source {
     static runSyntax(node, input, targetType, writeReference = false, allowGenericDeference = false, readReference = true) {
-        var _a;
+        var _a, _b, _c, _d;
         if (node === undefined) {
             return undefined;
         }
@@ -151,7 +152,7 @@ class Source {
                 case "CONV":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = conv_body_1.ConvBody.runSyntax(node.findDirectExpression(Expressions.ConvBody), input);
+                        const bodyType = conv_body_1.ConvBody.runSyntax(node.findDirectExpression(Expressions.ConvBody), input, foundType);
                         const inferred = (_a = node.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _a === void 0 ? void 0 : _a.concatTokens();
                         if (new _type_utils_1.TypeUtils(input.scope).isConvable(foundType, bodyType) === false) {
                             const message = `CONV: Types not compatible, ${foundType === null || foundType === void 0 ? void 0 : foundType.constructor.name}, ${bodyType === null || bodyType === void 0 ? void 0 : bodyType.constructor.name}`;
@@ -168,7 +169,13 @@ class Source {
                             this.traverseRemainingChildren(children, input);
                             return bodyType;
                         }
-                        this.addIfInferred(node, input, foundType);
+                        const bodySource = (_b = node.findDirectExpression(Expressions.ConvBody)) === null || _b === void 0 ? void 0 : _b.findDirectExpression(Expressions.Source);
+                        const nestedType = (_c = bodySource === null || bodySource === void 0 ? void 0 : bodySource.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _c === void 0 ? void 0 : _c.concatTokens();
+                        // CONV # passes its target type into a nested inferred constructor, so
+                        // showing both inferred types would produce duplicate inlay hints.
+                        if (!(inferred === "#" && nestedType === "#")) {
+                            this.addIfInferred(node, input, foundType);
+                        }
                         this.traverseRemainingChildren(children, input);
                         return foundType;
                     }
@@ -225,6 +232,15 @@ class Source {
                 case "CORRESPONDING":
                     {
                         const foundType = this.determineType(node, input, targetType);
+                        if ((foundType === null || foundType === void 0 ? void 0 : foundType.isGeneric()) === true
+                            && ((_d = node.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _d === void 0 ? void 0 : _d.concatTokens()) === "#"
+                            && !(0, version_1.releaseAtLeast)(input.scope.getRelease(), version_1.Release.v756)
+                            && input.scope.getLanguageVersion() !== version_1.LanguageVersion.Cloud
+                            && !input.scope.getOpenABAP()) {
+                            const message = "CORRESPONDING #, the type of the target is generic";
+                            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+                        }
                         corresponding_body_1.CorrespondingBody.runSyntax(node.findDirectExpression(Expressions.CorrespondingBody), input, foundType);
                         this.addIfInferred(node, input, foundType);
                         return foundType;

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

@@ -41,6 +41,7 @@ const basic_1 = require("../../types/basic");
 const dynamic_1 = require("../expressions/dynamic");
 const _type_utils_1 = require("../_type_utils");
 const _syntax_input_1 = require("../_syntax_input");
+const version_1 = require("../../../version");
 class Assign {
     runSyntax(node, input) {
         var _a;
@@ -48,7 +49,7 @@ class Assign {
         const isComponent = ((_a = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getFirstChild()) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase()) === "COMPONENT";
         const sources = (assignSource === null || assignSource === void 0 ? void 0 : assignSource.findDirectExpressionsMulti([Expressions.Source, Expressions.SimpleSource3])) || [];
         const theSource = sources[sources.length - 1];
-        let sourceType = undefined;
+        let sourceType;
         const firstAssign = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren()[0];
         const secondAssign = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren()[1];
         const thirdAssign = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren()[2];
@@ -64,6 +65,19 @@ class Assign {
         }
         else {
             sourceType = source_1.Source.runSyntax(theSource, input, undefined, false, isComponent === false);
+            if ((secondAssign === null || secondAssign === void 0 ? void 0 : secondAssign.concatTokens()) === "->"
+                && (thirdAssign === null || thirdAssign === void 0 ? void 0 : thirdAssign.get()) instanceof Expressions.Dynamic
+                && (sourceType === null || sourceType === void 0 ? void 0 : sourceType.isGeneric()) === true
+                && !(sourceType instanceof basic_1.DataReference)
+                && !(sourceType instanceof basic_1.ObjectReferenceType)
+                && !(sourceType instanceof basic_1.GenericObjectReferenceType)
+                && !(0, version_1.releaseAtLeast)(input.scope.getRelease(), version_1.Release.v756)
+                && input.scope.getLanguageVersion() !== version_1.LanguageVersion.Cloud
+                && !input.scope.getOpenABAP()) {
+                const message = `"${theSource.concatTokens()}" is not a reference variable`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
+            }
         }
         if ((assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren().length) === 5
             && isComponent) {