@abaplint/core 2.120.35 → 2.120.37

package/build/abaplint.d.ts

@@ -3559,6 +3559,7 @@ export declare const enum IdentifierMeta {
     FunctionModuleTables = "function_module_tables",
     EventParameter = "event_parameter",
     FormParameter = "form_parameter",
+    FormParameterStructure = "form_parameter_structure",
     ReadOnly = "read_only",
     Tables = "tables",
     Abstract = "abstract",

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

@@ -575,6 +575,29 @@ class TypeUtils {
         }
         return this.isAssignable(source, target);
     }
+    // Typing with the classic STRUCTURE addition, ie. "FORM foo USING bar STRUCTURE zkey",
+    // is not a compatibility check: ABAP only checks the fragment view up to the end of the
+    // formal structure, so the actual parameter is allowed to be longer. For TABLES parameters
+    // the table key is not part of the check at all.
+    isAssignableStructureTyping(source, target, node) {
+        if (source instanceof basic_1.StructureType && target instanceof basic_1.StructureType) {
+            const sourceComponents = source.getComponents();
+            const targetComponents = target.getComponents();
+            if (sourceComponents.length < targetComponents.length) {
+                return false;
+            }
+            for (let i = 0; i < targetComponents.length; i++) {
+                if (this.isAssignableStrict(sourceComponents[i].type, targetComponents[i].type) === false) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        else if (source instanceof basic_1.TableType && target instanceof basic_1.TableType) {
+            return this.isAssignableStructureTyping(source.getRowType(), target.getRowType());
+        }
+        return this.isAssignableStrict(source, target, node);
+    }
     isAssignable(source, target) {
         if (source === undefined || target === undefined) {
             return true;

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

@@ -533,7 +533,7 @@ class BasicTypes {
             return Types.VoidType.get((_f = node.findFirstExpression(Expressions.TypeStructure)) === null || _f === void 0 ? void 0 : _f.concatTokens());
         }
         else if (text.startsWith("LIKE LINE OF ")) {
-            const name = (_g = node.findFirstExpression(Expressions.FieldChain)) === null || _g === void 0 ? void 0 : _g.concatTokens();
+            let name = (_g = node.findFirstExpression(Expressions.FieldChain)) === null || _g === void 0 ? void 0 : _g.concatTokens();
             let e = node.findFirstExpression(Expressions.Type);
             if (e === undefined) {
                 e = node.findFirstExpression(Expressions.FormParamType);
@@ -541,19 +541,32 @@ class BasicTypes {
             if (e === undefined) {
                 e = node.findFirstExpression(Expressions.FieldChain);
             }
+            if (e === undefined) {
+                // old style, eg "LIKE LINE OF tab OCCURS 0 WITH HEADER LINE", it is parsed as TypeName
+                e = typeName;
+                name = typeName === null || typeName === void 0 ? void 0 : typeName.concatTokens();
+            }
             const type = this.resolveLikeName(e, false);
+            let row = undefined;
             if (type === undefined) {
                 return new Types.UnknownType("Type error, could not resolve \"" + name + "\", parseType");
             }
             else if (type instanceof Types.TableType) {
-                return type.getRowType();
+                row = type.getRowType();
             }
             else if (type instanceof Types.VoidType) {
-                return type;
+                row = type;
             }
             else {
                 return new Types.UnknownType("Type error, not a table type " + name);
             }
+            if (this.isOccurs(node)) {
+                return new Types.TableType(row, {
+                    withHeader: text.includes(" WITH HEADER LINE"),
+                    keyType: Types.TableKeyType.default
+                }, qualifiedName);
+            }
+            return row;
         }
         else if (text.startsWith("LIKE REF TO ")) {
             const name = (_h = node.findFirstExpression(Expressions.FieldChain)) === null || _h === void 0 ? void 0 : _h.concatTokens();

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

@@ -31,7 +31,7 @@ class FormParam {
             else {
                 type = new basic_1.UnknownType("todo, FORM STRUCTURES typing");
             }
-            return new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, type, ["form_parameter" /* IdentifierMeta.FormParameter */]);
+            return new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, type, ["form_parameter" /* IdentifierMeta.FormParameter */, "form_parameter_structure" /* IdentifierMeta.FormParameterStructure */]);
         }
         if (node.getChildren().length === 1 && nameToken) {
             // untyped FORM parameter

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

@@ -113,7 +113,11 @@ class Perform {
                 continue;
             }
             const parameter = formal[i];
-            if (typeUtils.isAssignableStrict(type, parameter.getType(), source) === false) {
+            const structureTyping = parameter.getMeta().includes("form_parameter_structure" /* IdentifierMeta.FormParameterStructure */);
+            const assignable = structureTyping
+                ? typeUtils.isAssignableStructureTyping(type, parameter.getType(), source)
+                : typeUtils.isAssignableStrict(type, parameter.getType(), source);
+            if (assignable === false) {
                 const message = `PERFORM parameter type not compatible, ${parameter.getName()}`;
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, source.getFirstToken(), message));
                 return false;

package/build/src/abap/types/form_definition.js

@@ -90,7 +90,8 @@ class FormDefinition extends _identifier_1.Identifier {
                 else if (!(type instanceof basic_1.UnknownType) && !(type instanceof basic_1.VoidType)) {
                     type = new basic_1.UnknownType("FORM TABLES type must be table type");
                 }
-                ret.push(new _typed_identifier_1.TypedIdentifier(p.getToken(), input.filename, type, ["form_parameter" /* IdentifierMeta.FormParameter */]));
+                // keep the meta from FormParam, so STRUCTURE typing can be recognized later
+                ret.push(new _typed_identifier_1.TypedIdentifier(p.getToken(), input.filename, type, p.getMeta()));
             }
         }
         return ret;

package/build/src/registry.js

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

package/package.json

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