@abaplint/core 2.111.1 → 2.112.0

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

@@ -7,26 +7,31 @@ const unknown_type_1 = require("../../types/basic/unknown_type");
 const basic_1 = require("../../types/basic");
 const target_1 = require("../expressions/target");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class Catch {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b;
         const names = new Set();
         for (const c of node.findDirectExpressions(Expressions.ClassName)) {
             const token = c.getFirstToken();
             const className = token.getStr().toUpperCase();
-            const found = scope.existsObject(className);
+            const found = input.scope.existsObject(className);
             if (found === null || found === void 0 ? void 0 : found.id) {
-                scope.addReference(token, found.id, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(token, found.id, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
             }
-            else if (scope.getDDIC().inErrorNamespace(className) === false) {
+            else if (input.scope.getDDIC().inErrorNamespace(className) === false) {
                 const extra = { ooName: className, ooType: "Void" };
-                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, extra);
+                input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, extra);
             }
             else {
-                throw new Error("CATCH, unknown class " + className);
+                const message = "CATCH, unknown class " + className;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, token, message));
+                return;
             }
             if (names.has(className)) {
-                throw new Error("Duplicate class name in CATCH: " + className);
+                const message = "Duplicate class name in CATCH: " + className;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             names.add(className);
         }
@@ -34,26 +39,26 @@ class Catch {
         const firstClassName = (_a = node.findDirectExpression(Expressions.ClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr();
         if (target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData)) {
             const token = (_b = target.findFirstExpression(Expressions.TargetField)) === null || _b === void 0 ? void 0 : _b.getFirstToken();
-            const found = scope.existsObject(firstClassName);
+            const found = input.scope.existsObject(firstClassName);
             if (token && firstClassName && (found === null || found === void 0 ? void 0 : found.id)) {
-                const identifier = new _typed_identifier_1.TypedIdentifier(token, filename, new basic_1.ObjectReferenceType(found.id), ["inline" /* IdentifierMeta.InlineDefinition */]);
-                scope.addIdentifier(identifier);
-                scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+                const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, new basic_1.ObjectReferenceType(found.id), ["inline" /* IdentifierMeta.InlineDefinition */]);
+                input.scope.addIdentifier(identifier);
+                input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
             }
-            else if (token && scope.getDDIC().inErrorNamespace(firstClassName) === false) {
-                const identifier = new _typed_identifier_1.TypedIdentifier(token, filename, new basic_1.VoidType(firstClassName), ["inline" /* IdentifierMeta.InlineDefinition */]);
-                scope.addIdentifier(identifier);
-                scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+            else if (token && input.scope.getDDIC().inErrorNamespace(firstClassName) === false) {
+                const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, new basic_1.VoidType(firstClassName), ["inline" /* IdentifierMeta.InlineDefinition */]);
+                input.scope.addIdentifier(identifier);
+                input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
             }
             else if (token) {
                 const message = "Catch, could not determine type for \"" + token.getStr() + "\"";
-                const identifier = new _typed_identifier_1.TypedIdentifier(token, filename, new unknown_type_1.UnknownType(message), ["inline" /* IdentifierMeta.InlineDefinition */]);
-                scope.addIdentifier(identifier);
-                scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+                const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, new unknown_type_1.UnknownType(message), ["inline" /* IdentifierMeta.InlineDefinition */]);
+                input.scope.addIdentifier(identifier);
+                input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
             }
         }
         else if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
     }
 }

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

@@ -4,9 +4,9 @@ exports.Check = void 0;
 const Expressions = require("../../2_statements/expressions");
 const cond_1 = require("../expressions/cond");
 class Check {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Cond)) {
-            new cond_1.Cond().runSyntax(s, scope, filename);
+            new cond_1.Cond().runSyntax(s, input);
         }
     }
 }

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

@@ -5,24 +5,28 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const data_definition_1 = require("../expressions/data_definition");
 const unknown_type_1 = require("../../types/basic/unknown_type");
+const _syntax_input_1 = require("../_syntax_input");
+const basic_1 = require("../../types/basic");
 class ClassData {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const dd = node.findFirstExpression(Expressions.DataDefinition);
         if (dd) {
-            const found = new data_definition_1.DataDefinition().runSyntax(dd, scope, filename);
+            const found = new data_definition_1.DataDefinition().runSyntax(dd, input);
             if (found === undefined) {
                 return undefined;
             }
             if ((found === null || found === void 0 ? void 0 : found.getType().isGeneric()) === true
                 && (found === null || found === void 0 ? void 0 : found.getType().containsVoid()) === false) {
-                throw new Error("DATA definition cannot be generic, " + found.getName());
+                const message = "DATA definition cannot be generic, " + found.getName();
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new _typed_identifier_1.TypedIdentifier(found.getToken(), input.filename, new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey));
             }
             const meta = [...found.getMeta(), "static" /* IdentifierMeta.Static */];
-            return new _typed_identifier_1.TypedIdentifier(found.getToken(), filename, found.getType(), meta, found.getValue());
+            return new _typed_identifier_1.TypedIdentifier(found.getToken(), input.filename, found.getType(), meta, found.getValue());
         }
         const fallback = node.findFirstExpression(Expressions.NamespaceSimpleName);
         if (fallback) {
-            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), filename, new unknown_type_1.UnknownType("class data, fallback"));
+            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), input.filename, new unknown_type_1.UnknownType("class data, fallback"));
         }
         return undefined;
     }

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassDeferred = void 0;
 const Expressions = require("../../2_statements/expressions");
 class ClassDeferred {
-    runSyntax(node, scope, _filename) {
+    runSyntax(node, input) {
         var _a;
         const name = (_a = node.findFirstExpression(Expressions.ClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-        scope.addDeferred(name, "CLAS");
+        input.scope.addDeferred(name, "CLAS");
     }
 }
 exports.ClassDeferred = ClassDeferred;

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

@@ -8,33 +8,36 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const position_1 = require("../../../position");
 const _builtin_1 = require("../_builtin");
 const _scope_type_1 = require("../_scope_type");
+const _syntax_input_1 = require("../_syntax_input");
 class ClassImplementation {
-    runSyntax(node, scope, filename) {
-        const helper = new _object_oriented_1.ObjectOriented(scope);
+    runSyntax(node, input) {
+        const helper = new _object_oriented_1.ObjectOriented(input.scope);
         const className = helper.findClassName(node);
-        scope.push(_scope_type_1.ScopeType.ClassImplementation, className, node.getFirstToken().getStart(), filename);
-        const classDefinition = scope.findClassDefinition(className);
+        input.scope.push(_scope_type_1.ScopeType.ClassImplementation, className, node.getFirstToken().getStart(), input.filename);
+        const classDefinition = input.scope.findClassDefinition(className);
         if (classDefinition === undefined) {
-            throw new Error("Class definition for \"" + className + "\" not found");
+            const message = "Class definition for \"" + className + "\" not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         for (const t of classDefinition.getTypeDefinitions().getAll()) {
-            scope.addType(t.type);
+            input.scope.addType(t.type);
         }
-        const sup = scope.findClassDefinition(classDefinition.getSuperClass());
+        const sup = input.scope.findClassDefinition(classDefinition.getSuperClass());
         if (sup) {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(new tokens_1.Identifier(new position_1.Position(1, 1), "super"), _builtin_1.BuiltIn.filename, new basic_1.ObjectReferenceType(sup)));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(new tokens_1.Identifier(new position_1.Position(1, 1), "super"), _builtin_1.BuiltIn.filename, new basic_1.ObjectReferenceType(sup)));
         }
         else {
             // todo: instead of the void type, do proper typing, ie. only empty constructor method
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(new tokens_1.Identifier(new position_1.Position(1, 1), "super"), _builtin_1.BuiltIn.filename, new basic_1.VoidType("noSuper")));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(new tokens_1.Identifier(new position_1.Position(1, 1), "super"), _builtin_1.BuiltIn.filename, new basic_1.VoidType("noSuper")));
         }
-        scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(new tokens_1.Identifier(new position_1.Position(1, 1), "me"), _builtin_1.BuiltIn.filename, new basic_1.ObjectReferenceType(classDefinition)));
+        input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(new tokens_1.Identifier(new position_1.Position(1, 1), "me"), _builtin_1.BuiltIn.filename, new basic_1.ObjectReferenceType(classDefinition)));
         helper.addAliasedAttributes(classDefinition); // todo, this is not correct, take care of instance vs static
         const classAttributes = classDefinition.getAttributes();
-        scope.addList(classAttributes.getConstants());
-        scope.addList(classAttributes.getStatic());
+        input.scope.addList(classAttributes.getConstants());
+        input.scope.addList(classAttributes.getStatic());
         for (const i of classAttributes.getInstance()) {
-            scope.addExtraLikeType(i);
+            input.scope.addExtraLikeType(i);
         }
         helper.fromSuperClassesAndInterfaces(classDefinition);
     }

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

@@ -3,31 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassLocalFriends = void 0;
 const Expressions = require("../../2_statements/expressions");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class ClassLocalFriends {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const classNames = node.findAllExpressions(Expressions.ClassName);
         const found = classNames[0];
         if (found) {
             const token = found.getFirstToken();
             const name = token.getStr();
-            if (scope.getParentObj().getType() === "CLAS"
-                && name.toUpperCase() !== scope.getParentObj().getName().toUpperCase()) {
-                throw new Error(`Befriending must be ` + scope.getParentObj().getName().toUpperCase());
+            if (input.scope.getParentObj().getType() === "CLAS"
+                && name.toUpperCase() !== input.scope.getParentObj().getName().toUpperCase()) {
+                const message = `Befriending must be ` + input.scope.getParentObj().getName().toUpperCase();
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            const def = scope.findClassDefinition(name);
+            const def = input.scope.findClassDefinition(name);
             if (def) {
-                scope.addReference(token, def, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(token, def, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
             }
             else {
-                throw new Error(`Class ${name.toUpperCase()} not found`);
+                const message = `Class ${name.toUpperCase()} not found`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         for (let i = 1; i < classNames.length; i++) {
             const className = classNames[i].concatTokens();
             // make sure to check also DEFINITION DEFERRED
-            const found = scope.existsObject(className);
+            const found = input.scope.existsObject(className);
             if (found === undefined) {
-                throw new Error(`Class ${className.toUpperCase()} not found`);
+                const message = `Class ${className.toUpperCase()} not found`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
     }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class Clear {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const t of node.findDirectExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
     }
 }

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

@@ -4,9 +4,9 @@ exports.CloseDataset = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 class CloseDataset {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
     }
 }

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

@@ -6,18 +6,18 @@ const source_1 = require("../expressions/source");
 const fstarget_1 = require("../expressions/fstarget");
 const target_1 = require("../expressions/target");
 class Collect {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const source = node.findDirectExpression(Expressions.Source);
         if (source) {
-            new source_1.Source().runSyntax(source, scope, filename);
+            new source_1.Source().runSyntax(source, input);
         }
         const target = node.findDirectExpression(Expressions.Target);
         if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
         const fs = node.findDirectExpression(Expressions.FSTarget);
         if (fs) {
-            new fstarget_1.FSTarget().runSyntax(fs, scope, filename, undefined);
+            new fstarget_1.FSTarget().runSyntax(fs, input, undefined);
         }
     }
 }

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

@@ -7,17 +7,17 @@ const target_1 = require("../expressions/target");
 const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
 class CommitEntities {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
             const inline = t === null || t === void 0 ? void 0 : t.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.VoidType("CommitEntities"));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("CommitEntities"));
             }
             else {
-                new target_1.Target().runSyntax(t, scope, filename);
+                new target_1.Target().runSyntax(t, input);
             }
         }
     }

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

@@ -7,40 +7,47 @@ const target_1 = require("../expressions/target");
 const basic_1 = require("../../types/basic");
 const inline_data_1 = require("../expressions/inline_data");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class Concatenate {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const byteMode = node.findDirectTokenByText("BYTE") !== undefined;
         const linesMode = node.findDirectTokenByText("LINES") !== undefined;
         const target = node.findFirstExpression(Expressions.Target);
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
             if (byteMode) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.XStringType());
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.XStringType());
             }
             else {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, basic_1.StringType.get());
+                new inline_data_1.InlineData().runSyntax(inline, input, basic_1.StringType.get());
             }
         }
         else if (target) {
-            const type = new target_1.Target().runSyntax(target, scope, filename);
-            const compatible = byteMode ? new _type_utils_1.TypeUtils(scope).isHexLike(type) : new _type_utils_1.TypeUtils(scope).isCharLikeStrict(type);
+            const type = new target_1.Target().runSyntax(target, input);
+            const compatible = byteMode ? new _type_utils_1.TypeUtils(input.scope).isHexLike(type) : new _type_utils_1.TypeUtils(input.scope).isCharLikeStrict(type);
             if (compatible === false) {
-                throw new Error("Target type not compatible");
+                const message = "Target type not compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         if (linesMode) {
             for (const s of node.findDirectExpressions(Expressions.Source)) {
-                const type = new source_1.Source().runSyntax(s, scope, filename);
+                const type = new source_1.Source().runSyntax(s, input);
                 if (!(type instanceof basic_1.UnknownType) && !(type instanceof basic_1.VoidType) && !(type instanceof basic_1.TableType)) {
-                    throw new Error("Source must be an internal table");
+                    const message = "Source must be an internal table";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
         }
         for (const s of node.findDirectExpressions(Expressions.SimpleSource3)) {
-            const type = new source_1.Source().runSyntax(s, scope, filename);
-            const compatible = byteMode ? new _type_utils_1.TypeUtils(scope).isHexLike(type) : new _type_utils_1.TypeUtils(scope).isCharLikeStrict(type);
+            const type = new source_1.Source().runSyntax(s, input);
+            const compatible = byteMode ? new _type_utils_1.TypeUtils(input.scope).isHexLike(type) : new _type_utils_1.TypeUtils(input.scope).isCharLikeStrict(type);
             if (compatible === false) {
-                throw new Error("Source type not compatible");
+                const message = "Source type not compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
     }

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

@@ -4,9 +4,9 @@ exports.Condense = void 0;
 const Expressions = require("../../2_statements/expressions");
 const target_1 = require("../expressions/target");
 class Condense {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const t of node.findDirectExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
     }
 }

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

@@ -5,20 +5,21 @@ const Expressions = require("../../2_statements/expressions");
 const basic_types_1 = require("../basic_types");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
+const assert_error_1 = require("../assert_error");
 class Constant {
-    runSyntax(node, scope, filename) {
-        const basic = new basic_types_1.BasicTypes(filename, scope);
+    runSyntax(node, input) {
+        const basic = new basic_types_1.BasicTypes(input);
         const found = basic.simpleType(node);
         if (found) {
             const val = basic.findValue(node);
             const meta = ["read_only" /* IdentifierMeta.ReadOnly */, "static" /* IdentifierMeta.Static */];
-            return new _typed_identifier_1.TypedIdentifier(found.getToken(), filename, found.getType(), meta, val);
+            return new _typed_identifier_1.TypedIdentifier(found.getToken(), input.filename, found.getType(), meta, val);
         }
         const fallback = node.findFirstExpression(Expressions.DefinitionName);
         if (fallback) {
-            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), filename, new basic_1.UnknownType("constant, fallback"));
+            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), input.filename, new basic_1.UnknownType("constant, fallback"));
         }
-        throw new Error("Statement Constant: unexpected structure");
+        throw new assert_error_1.AssertError("Statement Constant: unexpected structure");
     }
 }
 exports.Constant = Constant;

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

@@ -5,13 +5,13 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 class Controls {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const name = node.findDirectExpression(Expressions.NamespaceSimpleName);
         const token = name === null || name === void 0 ? void 0 : name.getFirstToken();
         if (node.findDirectTokenByText("TABSTRIP") && token) {
             const type = new basic_1.StructureType([{ name: "ACTIVETAB", type: new basic_1.CharacterType(132) }]);
-            const id = new _typed_identifier_1.TypedIdentifier(token, filename, type);
-            scope.addIdentifier(id);
+            const id = new _typed_identifier_1.TypedIdentifier(token, input.filename, type);
+            input.scope.addIdentifier(id);
         }
         if (node.findDirectTokenByText("TABLEVIEW") && token) {
             const cols = new basic_1.StructureType([
@@ -35,8 +35,8 @@ class Controls {
                 { name: "COLS", type: new basic_1.TableType(cols, { withHeader: false, keyType: basic_1.TableKeyType.default }) },
                 { name: "INVISIBLE", type: new basic_1.CharacterType(1) },
             ]);
-            const id = new _typed_identifier_1.TypedIdentifier(token, filename, type);
-            scope.addIdentifier(id);
+            const id = new _typed_identifier_1.TypedIdentifier(token, input.filename, type);
+            input.scope.addIdentifier(id);
         }
     }
 }

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

@@ -7,39 +7,39 @@ const basic_1 = require("../../types/basic");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class Convert {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         // todo, the source must be of a specific type
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         const timeTarget = node.findExpressionAfterToken("TIME");
         if ((timeTarget === null || timeTarget === void 0 ? void 0 : timeTarget.get()) instanceof Expressions.Target) {
             const inline = timeTarget === null || timeTarget === void 0 ? void 0 : timeTarget.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.TimeType());
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.TimeType());
             }
             else {
-                new target_1.Target().runSyntax(timeTarget, scope, filename);
+                new target_1.Target().runSyntax(timeTarget, input);
             }
         }
         const dateTarget = node.findExpressionAfterToken("DATE");
         if ((dateTarget === null || dateTarget === void 0 ? void 0 : dateTarget.get()) instanceof Expressions.Target) {
             const inline = dateTarget === null || dateTarget === void 0 ? void 0 : dateTarget.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.DateType());
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.DateType());
             }
             else {
-                new target_1.Target().runSyntax(dateTarget, scope, filename);
+                new target_1.Target().runSyntax(dateTarget, input);
             }
         }
         const stampTarget = node.findExpressionAfterToken("STAMP");
         if ((stampTarget === null || stampTarget === void 0 ? void 0 : stampTarget.get()) instanceof Expressions.Target) {
             const inline = stampTarget === null || stampTarget === void 0 ? void 0 : stampTarget.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.PackedType(8, 4));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.PackedType(8, 4));
             }
             else {
-                new target_1.Target().runSyntax(stampTarget, scope, filename);
+                new target_1.Target().runSyntax(stampTarget, input);
             }
         }
     }

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

@@ -10,33 +10,33 @@ const basic_1 = require("../../types/basic");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const _reference_1 = require("../_reference");
 class CreateData {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(t, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(t, input);
         }
         const type = node.findDirectExpression(Expressions.TypeName);
         if (type) {
-            const found = new basic_types_1.BasicTypes(filename, scope).resolveTypeName(type);
+            const found = new basic_types_1.BasicTypes(input).resolveTypeName(type);
             if (found instanceof basic_1.UnknownType) {
                 if (node.concatTokens().toUpperCase().includes(" REF TO ")) {
-                    const def = scope.findObjectDefinition(type.concatTokens());
+                    const def = input.scope.findObjectDefinition(type.concatTokens());
                     if (def) {
-                        scope.addReference(type.getFirstToken(), def, _reference_1.ReferenceType.TypeReference, filename);
+                        input.scope.addReference(type.getFirstToken(), def, _reference_1.ReferenceType.TypeReference, input.filename);
                     }
                     else {
-                        const identifier = new _typed_identifier_1.TypedIdentifier(type.getFirstToken(), filename, found);
-                        scope.addReference(type.getFirstToken(), identifier, _reference_1.ReferenceType.TypeReference, filename);
+                        const identifier = new _typed_identifier_1.TypedIdentifier(type.getFirstToken(), input.filename, found);
+                        input.scope.addReference(type.getFirstToken(), identifier, _reference_1.ReferenceType.TypeReference, input.filename);
                     }
                 }
                 else {
-                    const identifier = new _typed_identifier_1.TypedIdentifier(type.getFirstToken(), filename, found);
-                    scope.addReference(type.getFirstToken(), identifier, _reference_1.ReferenceType.TypeReference, filename);
+                    const identifier = new _typed_identifier_1.TypedIdentifier(type.getFirstToken(), input.filename, found);
+                    input.scope.addReference(type.getFirstToken(), identifier, _reference_1.ReferenceType.TypeReference, input.filename);
                 }
             }
         }