@abaplint/core 2.120.38 → 2.120.40

package/build/abaplint.d.ts

@@ -1612,6 +1612,9 @@ export declare class CurrentScope {
     addExtraLikeTypeNamed(name: string, type: TypedIdentifier | undefined): void;
     addClassDefinition(c: IClassDefinition): void;
     addFormDefinitions(f: readonly IFormDefinition[]): void;
+    /** The FORM definitions are built up front, at that point the program level types are not known.
+     * When the FORM statement is traversed it is replaced with one resolved in the scope of the FORM */
+    updateFormDefinition(f: IFormDefinition): void;
     addInterfaceDefinition(i: IInterfaceDefinition): void;
     addNamedIdentifier(name: string, identifier: TypedIdentifier): void;
     addNamedIdentifierToParent(name: string, identifier: TypedIdentifier): void;
@@ -7872,11 +7875,15 @@ declare type SyntaxInput = {
     scope: CurrentScope;
     filename: string;
     issues: Issue[];
+    /** checks which can only run once the full object has been traversed, eg. PERFORM parameters,
+     * the FORM might be defined after the PERFORM */
+    deferred: (() => void)[];
 };
 
 export declare class SyntaxLogic {
     private currentFile;
     private issues;
+    private deferred;
     private readonly object;
     private readonly reg;
     private scope;

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

@@ -107,6 +107,21 @@ class CurrentScope {
         }
         this.current.getData().forms.push(...f);
     }
+    /** The FORM definitions are built up front, at that point the program level types are not known.
+     * When the FORM statement is traversed it is replaced with one resolved in the scope of the FORM */
+    updateFormDefinition(f) {
+        let search = this.current;
+        while (search !== undefined) {
+            const forms = search.getData().forms;
+            for (let i = 0; i < forms.length; i++) {
+                if (forms[i].equals(f)) {
+                    forms[i] = f;
+                    return;
+                }
+            }
+            search = search.getParent();
+        }
+    }
     addInterfaceDefinition(i) {
         if (this.current === undefined) {
             return;

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

@@ -59,6 +59,7 @@ class Procedural {
                 scope: _current_scope_1.CurrentScope.buildDefault(this.reg, obj),
                 filename: file.getFilename(),
                 issues: [],
+                deferred: [],
             };
             for (const found of structure.findAllStructures(Structures.Form)) {
                 this.scope.addFormDefinitions([new types_1.FormDefinition(found, input)]);

package/build/src/abap/5_syntax/global_definitions/find_global_definitions.js

@@ -151,6 +151,7 @@ class FindGlobalDefinitions {
             filename: file.getFilename(),
             scope: _current_scope_1.CurrentScope.buildDefault(this.reg, obj),
             issues: [],
+            deferred: [],
         };
         if (obj instanceof interface_1.Interface) {
             const found = struc.findFirstStructure(Structures.Interface);

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

@@ -20,6 +20,9 @@ class Form {
         }
         input.scope.push(_scope_type_1.ScopeType.Form, name, node.getFirstToken().getStart(), input.filename);
         const form = new form_definition_1.FormDefinition(node, input);
+        // the definitions are built up front, before the program level types are known, replace it
+        // with this one, which is resolved in the scope of the FORM
+        input.scope.updateFormDefinition(form);
         input.scope.addList(form.getUsingParameters());
         input.scope.addList(form.getChangingParameters());
         input.scope.addList(form.getTablesParameters());

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

@@ -92,12 +92,19 @@ class Perform {
         input.scope.addReference(expr.getFirstToken(), found, _reference_1.ReferenceType.FormReference, input.filename);
         ////////////////////////////
         // check parameters match
-        // USING and CHANGING are interchangeable, the actual parameters form a single positional list
-        if (this.checkParameters(node, tables, found.getTablesParameters(), "TABLES", input) === false) {
-            return;
-        }
-        const formal = found.getUsingParameters().concat(found.getChangingParameters());
-        this.checkParameters(node, using.concat(changing), formal, "USING/CHANGING", input);
+        // deferred, the FORM might be defined after the PERFORM, its parameters are only typed
+        // once the FORM statement itself has been traversed
+        input.deferred.push(() => {
+            var _a;
+            // look up again, the definition is replaced when the FORM statement is traversed
+            const def = (_a = input.scope.findFormDefinition(name)) !== null && _a !== void 0 ? _a : found;
+            if (this.checkParameters(node, tables, def.getTablesParameters(), "TABLES", input) === false) {
+                return;
+            }
+            // USING and CHANGING are interchangeable, the actual parameters form a single positional list
+            const formal = def.getUsingParameters().concat(def.getChangingParameters());
+            this.checkParameters(node, using.concat(changing), formal, "USING/CHANGING", input);
+        });
     }
     // returns false if an issue was reported
     checkParameters(node, actual, formal, kind, input) {

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

@@ -64,22 +64,8 @@ class SelectOption {
             return;
         }
         const nameChain = node.findFirstExpression(Expressions.FieldChain);
-        let found = new basic_types_1.BasicTypes(input).resolveLikeName(nameChain);
+        const found = new basic_types_1.BasicTypes(input).resolveLikeName(nameChain);
         if (found) {
-            if (found instanceof basic_1.StructureType) {
-                let length = 0;
-                for (const c of found.getComponents()) {
-                    if (c.type instanceof basic_1.CharacterType) {
-                        length += c.type.getLength();
-                    }
-                }
-                if (length === 0) {
-                    found = basic_1.VoidType.get("Selectoption, fallback");
-                }
-                else {
-                    found = new basic_1.CharacterType(length);
-                }
-            }
             const stru = new basic_1.StructureType([
                 { name: "SIGN", type: new basic_1.CharacterType(1) },
                 { name: "OPTION", type: new basic_1.CharacterType(2) },

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

@@ -337,6 +337,7 @@ class SyntaxLogic {
     constructor(reg, object) {
         this.reg = reg;
         this.issues = [];
+        this.deferred = [];
         this.object = object;
     }
     run() {
@@ -350,6 +351,7 @@ class SyntaxLogic {
             proc: new _procedural_1.Procedural(this.reg, this.scope),
         };
         this.issues = [];
+        this.deferred = [];
         this.reg.getDDICReferences().clear(this.object);
         this.reg.getMSAGReferences().clear(this.object);
         if (this.object instanceof objects_1.Program && this.object.isInclude()) {
@@ -357,6 +359,11 @@ class SyntaxLogic {
             return { issues: [], spaghetti: this.scope.pop(new position_1.Position(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER)) };
         }
         this.traverseObject();
+        // the FORM definitions are now all traversed, ie. their parameters are typed
+        for (const d of this.deferred) {
+            d();
+        }
+        this.deferred = [];
         for (;;) {
             const spaghetti = this.scope.pop(new position_1.Position(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER)); // pop built-in scopes
             if (spaghetti.getTop().getIdentifier().stype === _scope_type_1.ScopeType.BuiltIn) {
@@ -456,6 +463,7 @@ class SyntaxLogic {
             scope: this.scope,
             filename,
             issues: this.issues,
+            deferred: this.deferred,
         };
         if (stru instanceof Structures.ClassDefinition) {
             new class_definition_1.ClassDefinition(node, input);
@@ -507,6 +515,7 @@ class SyntaxLogic {
             scope: this.scope,
             filename,
             issues: this.issues,
+            deferred: this.deferred,
         };
         // todo, refactor
         if (s instanceof Statements.Type) {

package/build/src/registry.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.120.38",
+    "version": "2.120.40",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",