@abaplint/core 2.94.23 → 2.94.25

package/build/src/abap/2_statements/expressions/method_source.js

@@ -6,12 +6,17 @@ const tokens_1 = require("../../1_lexer/tokens");
 const _1 = require(".");
 class MethodSource extends combi_1.Expression {
     getRunnable() {
-        const mname = (0, combi_1.alt)(_1.MethodName, _1.Dynamic);
-        const cname = (0, combi_1.alt)(_1.FieldChain, _1.MethodCallChain, _1.Dynamic);
-        // this is a bit tricky, this part is required as FieldChain takes a AttributeName
-        const stati = (0, combi_1.seq)(_1.ClassName, (0, combi_1.tok)(tokens_1.StaticArrow), mname);
-        const part1 = (0, combi_1.seq)(cname, (0, combi_1.alt)((0, combi_1.tok)(tokens_1.InstanceArrow), (0, combi_1.tok)(tokens_1.StaticArrow)));
-        return (0, combi_1.alt)(stati, (0, combi_1.seq)((0, combi_1.starPrio)(part1), mname));
+        // note: AttributeName can be both an attribute and a method name, the syntax check will tell
+        // note: its allowed to end with MethodCall, however if this is done it will give a syntax error via syntax check
+        const afterArrow = (0, combi_1.alt)(_1.AttributeName, _1.MethodCall, _1.Dynamic);
+        const arrow = (0, combi_1.alt)((0, combi_1.tok)(tokens_1.InstanceArrow), (0, combi_1.tok)(tokens_1.StaticArrow));
+        const attr = (0, combi_1.seq)(arrow, afterArrow);
+        const comp = (0, combi_1.seq)((0, combi_1.tok)(tokens_1.Dash), _1.ComponentName);
+        const attrOrComp = (0, combi_1.alt)(attr, comp);
+        const staticClass = (0, combi_1.seq)(_1.ClassName, (0, combi_1.tok)(tokens_1.StaticArrow));
+        const clas = (0, combi_1.seq)(staticClass, afterArrow);
+        const start = (0, combi_1.seq)((0, combi_1.altPrio)(clas, _1.SourceField, _1.SourceFieldSymbol, _1.Dynamic), (0, combi_1.star)(attrOrComp));
+        return start;
     }
 }
 exports.MethodSource = MethodSource;

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

@@ -408,6 +408,11 @@ class BasicTypes {
         if (text === undefined) {
             text = (_d = node.findFirstExpression(Expressions.FormParamType)) === null || _d === void 0 ? void 0 : _d.concatTokens().toUpperCase();
         }
+        if (text === undefined
+            && node.get() instanceof Statements.Parameter
+            && node.findDirectTokenByText("LIKE")) {
+            text = "LIKE " + (typeName === null || typeName === void 0 ? void 0 : typeName.concatTokens());
+        }
         if (text === undefined) {
             text = "TYPE";
         }
@@ -461,6 +466,9 @@ class BasicTypes {
             if (sub === undefined) {
                 sub = node.findFirstExpression(Expressions.FieldChain);
             }
+            if (sub === undefined) {
+                sub = node.findFirstExpression(Expressions.TypeName);
+            }
             found = this.resolveLikeName(sub);
             if (found && this.isOccurs(node)) {
                 found = new Types.TableType(found, { withHeader: text.includes("WITH HEADER LINE") }, qualifiedName);

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

@@ -14,6 +14,7 @@ const table_expression_1 = require("./table_expression");
 const expressions_1 = require("../../2_statements/expressions");
 const dereference_1 = require("./dereference");
 const source_field_symbol_1 = require("./source_field_symbol");
+const source_field_1 = require("./source_field");
 class FieldChain {
     runSyntax(node, scope, filename, refType) {
         const concat = node.concatTokens();
@@ -110,23 +111,9 @@ class FieldChain {
             && node.get() instanceof Expressions.SourceFieldSymbol) {
             return new source_field_symbol_1.SourceFieldSymbol().runSyntax(node, scope, filename);
         }
-        else if (node.get() instanceof Expressions.SourceField) {
-            const token = node.getFirstToken();
-            const name = token.getStr();
-            const found = scope.findVariable(name);
-            if (found === undefined) {
-                throw new Error("\"" + name + "\" not found, findTop");
-            }
-            if (type) {
-                scope.addReference(token, found, type, filename);
-            }
-            if (name.includes("~")) {
-                const idef = scope.findInterfaceDefinition(name.split("~")[0]);
-                if (idef) {
-                    scope.addReference(token, idef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
-                }
-            }
-            return found.getType();
+        else if (node instanceof nodes_1.ExpressionNode
+            && node.get() instanceof Expressions.SourceField) {
+            return new source_field_1.SourceField().runSyntax(node, scope, filename, type);
         }
         else if (node.get() instanceof Expressions.ClassName) {
             const classTok = node.getFirstToken();

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

@@ -4,68 +4,137 @@ exports.MethodSource = void 0;
 const Expressions = require("../../2_statements/expressions");
 const nodes_1 = require("../../nodes");
 const dynamic_1 = require("./dynamic");
-const method_call_chain_1 = require("./method_call_chain");
 const basic_1 = require("../../types/basic");
-const types_1 = require("../../types");
 const _reference_1 = require("../_reference");
 const _object_oriented_1 = require("../_object_oriented");
+const _abstract_type_1 = require("../../types/basic/_abstract_type");
+const source_field_symbol_1 = require("./source_field_symbol");
+const source_field_1 = require("./source_field");
+const tokens_1 = require("../../1_lexer/tokens");
+const attribute_name_1 = require("./attribute_name");
+const component_name_1 = require("./component_name");
+const types_1 = require("../../types");
 class MethodSource {
     runSyntax(node, scope, filename) {
-        // todo, rewrite the context finding, and/or restructure the expression?
-        const context = new method_call_chain_1.MethodCallChain().runSyntax(node, scope, filename);
-        const last = node.getLastChild();
-        const first = node.getFirstChild();
-        if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Dynamic) {
-            new dynamic_1.Dynamic().runSyntax(first, scope, filename);
+        var _a;
+        const helper = new _object_oriented_1.ObjectOriented(scope);
+        const children = node.getChildren().slice();
+        const first = children.shift();
+        if (first === undefined) {
+            throw new Error("MethodSource, first child expected");
         }
-        else if (last instanceof nodes_1.ExpressionNode && last.get() instanceof Expressions.MethodName) {
-            if (context instanceof basic_1.ObjectReferenceType) {
-                let id = context.getIdentifier();
-                if (!(id instanceof types_1.ClassDefinition)) {
-                    id = scope.findObjectDefinition(id.getName());
+        let context = this.findTop(first, scope, filename);
+        if (context === undefined) {
+            context = (_a = scope.findVariable("me")) === null || _a === void 0 ? void 0 : _a.getType();
+            children.unshift(first);
+        }
+        if (context instanceof basic_1.VoidType) {
+            // todo, if there are more dynamic with variables, the references for the variables are not added?
+            return context;
+        }
+        while (children.length > 0) {
+            const current = children.shift();
+            if (current === undefined) {
+                break;
+            }
+            if (current.get() instanceof tokens_1.Dash) {
+                if (context instanceof basic_1.UnknownType) {
+                    throw new Error("Not a structure, type unknown, MethodSource");
                 }
-                if (id instanceof types_1.ClassDefinition || id instanceof types_1.InterfaceDefinition) {
-                    const methodName = last.concatTokens().toUpperCase();
-                    const helper = new _object_oriented_1.ObjectOriented(scope);
-                    const { method: foundMethod, def: foundDef } = helper.searchMethodName(id, methodName);
-                    if (foundMethod === undefined && methodName !== "CONSTRUCTOR") {
-                        if (node.getChildren().length !== 3) {
-                            // todo
-                            return undefined;
-                        }
-                        throw new Error(`MethodSource, method not found \"${methodName}\"`);
+                else if (!(context instanceof basic_1.StructureType)) {
+                    throw new Error("Not a structure, MethodSource");
+                }
+            }
+            else if (current.get() instanceof tokens_1.InstanceArrow
+                || current.get() instanceof tokens_1.StaticArrow) {
+                // todo, handling static vs instance
+            }
+            else if (current.get() instanceof Expressions.AttributeName
+                || current.get() instanceof Expressions.SourceField) {
+                try {
+                    if (context instanceof _abstract_type_1.AbstractType) {
+                        const attr = new attribute_name_1.AttributeName().runSyntax(context, current, scope, filename, _reference_1.ReferenceType.DataReadReference);
+                        context = attr;
+                        continue;
                     }
+                }
+                catch (_b) {
+                    // ignore
+                }
+                // try looking for method name
+                const className = context instanceof basic_1.ObjectReferenceType ? context.getIdentifierName() : undefined;
+                const methodToken = current.getFirstToken();
+                const methodName = methodToken === null || methodToken === void 0 ? void 0 : methodToken.getStr();
+                const def = scope.findObjectDefinition(className);
+                // eslint-disable-next-line prefer-const
+                let { method, def: foundDef } = helper.searchMethodName(def, methodName);
+                if (method === undefined && (methodName === null || methodName === void 0 ? void 0 : methodName.toUpperCase()) === "CONSTRUCTOR") {
+                    context = new basic_1.VoidType("CONSTRUCTOR"); // todo, this is a workaround, constructors always exists
+                }
+                else if (method === undefined && !(context instanceof basic_1.VoidType)) {
+                    throw new Error("Method or attribute \"" + methodName + "\" not found, MethodSource");
+                }
+                else if (method) {
                     const extra = {
                         ooName: foundDef === null || foundDef === void 0 ? void 0 : foundDef.getName(),
                         ooType: foundDef instanceof types_1.ClassDefinition ? "CLAS" : "INTF"
                     };
-                    scope.addReference(last.getFirstToken(), foundMethod, _reference_1.ReferenceType.MethodReference, filename, extra);
-                    return foundMethod;
+                    scope.addReference(methodToken, method, _reference_1.ReferenceType.MethodReference, filename, extra);
+                    context = method;
                 }
             }
-            else if (context instanceof basic_1.VoidType) {
-                return context;
+            else if (current.get() instanceof Expressions.ComponentName && context instanceof _abstract_type_1.AbstractType) {
+                if (context instanceof basic_1.TableType && context.isWithHeader()) {
+                    context = context.getRowType();
+                }
+                context = new component_name_1.ComponentName().runSyntax(context, current);
             }
-            else {
-                throw new Error("MethodSource, not an object reference, " + node.concatTokens());
+            else if (current instanceof nodes_1.ExpressionNode && current.get() instanceof Expressions.Dynamic) {
+                new dynamic_1.Dynamic().runSyntax(current, scope, filename);
+                context = new basic_1.VoidType("Dynamic");
             }
         }
-        else if (last instanceof nodes_1.ExpressionNode && last.get() instanceof Expressions.Dynamic) {
-            new dynamic_1.Dynamic().runSyntax(last, scope, filename);
+        if (context instanceof _abstract_type_1.AbstractType && !(context instanceof basic_1.VoidType)) {
+            throw new Error("Not a method, MethodSource");
         }
-        else {
-            throw new Error("MethodSource, unexpected node");
+        else if (context === undefined) {
+            throw new Error("Not found, MethodSource");
         }
-        /*
-        const chain = node.findDirectExpression(Expressions.FieldChain);
-        if (chain) {
-          new FieldChain().runSyntax(chain, scope, filename, ReferenceType.DataReadReference);
+        return context;
+    }
+    //////////////////////////////////////
+    findTop(first, scope, filename) {
+        if (first.get() instanceof Expressions.ClassName) {
+            // todo, refactor this part to new expression handler,
+            const token = first.getFirstToken();
+            const className = token.getStr();
+            const classDefinition = scope.findObjectDefinition(className);
+            if (classDefinition === undefined && scope.getDDIC().inErrorNamespace(className) === false) {
+                const extra = { ooName: className, ooType: "Void" };
+                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, extra);
+                return new basic_1.VoidType(className);
+            }
+            else if (classDefinition === undefined) {
+                throw new Error("Class " + className + " not found");
+            }
+            scope.addReference(first.getFirstToken(), classDefinition, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+            return new basic_1.ObjectReferenceType(classDefinition);
         }
-    
-        for (const d of node.findAllExpressions(Expressions.Dynamic)) {
-          new Dynamic().runSyntax(d, scope, filename);
+        else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.SourceField) {
+            try {
+                return new source_field_1.SourceField().runSyntax(first, scope, filename, _reference_1.ReferenceType.DataReadReference);
+            }
+            catch (_a) {
+                return undefined;
+            }
+        }
+        else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.SourceFieldSymbol) {
+            return new source_field_symbol_1.SourceFieldSymbol().runSyntax(first, scope, filename);
+        }
+        else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Dynamic) {
+            new dynamic_1.Dynamic().runSyntax(first, scope, filename);
+            return new basic_1.VoidType("Dynamic");
         }
-        */
         return undefined;
     }
 }

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceField = void 0;
+const _reference_1 = require("../_reference");
+class SourceField {
+    runSyntax(node, scope, filename, type) {
+        const token = node.getFirstToken();
+        const name = token.getStr();
+        const found = scope.findVariable(name);
+        if (found === undefined) {
+            throw new Error("\"" + name + "\" not found, findTop");
+        }
+        if (type) {
+            scope.addReference(token, found, type, filename);
+        }
+        if (name.includes("~")) {
+            const idef = scope.findInterfaceDefinition(name.split("~")[0]);
+            if (idef) {
+                scope.addReference(token, idef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+            }
+        }
+        return found.getType();
+    }
+}
+exports.SourceField = SourceField;
+//# sourceMappingURL=source_field.js.map

package/build/src/lsp/_lookup.js

@@ -10,6 +10,7 @@ const _typed_identifier_1 = require("../abap/types/_typed_identifier");
 const _reference_1 = require("../abap/5_syntax/_reference");
 const _builtin_1 = require("../abap/5_syntax/_builtin");
 const _scope_type_1 = require("../abap/5_syntax/_scope_type");
+const types_1 = require("../abap/types");
 class LSPLookup {
     static lookup(cursor, reg, obj) {
         const inc = this.findInclude(cursor, reg);
@@ -84,13 +85,23 @@ class LSPLookup {
                 hoverValue += this.referenceHover(ref, bottomScope, reg);
             }
             let definition = undefined;
+            let implementation = undefined;
             if (refs[0].resolved) {
                 definition = _lsp_utils_1.LSPUtils.identiferToLocation(refs[0].resolved);
                 if (definition.uri === _builtin_1.BuiltIn.filename) {
                     definition = undefined;
                 }
+                if (refs[0].resolved instanceof types_1.FormDefinition) {
+                    implementation = definition;
+                }
             }
-            return { hover: hoverValue, definition, definitionId: refs[0].resolved, scope: bottomScope };
+            return {
+                hover: hoverValue,
+                definition: definition,
+                implementation: implementation,
+                definitionId: refs[0].resolved,
+                scope: bottomScope,
+            };
         }
         if (hoverValue !== "") {
             return { hover: hoverValue, scope: bottomScope };

package/build/src/registry.js

@@ -63,7 +63,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.94.23";
+        return "2.94.25";
     }
     getDDICReferences() {
         return this.references;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.94.23",
+    "version": "2.94.25",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -52,7 +52,7 @@
         "@types/mocha": "^10.0.1",
         "@types/node": "^18.11.18",
         "chai": "^4.3.7",
-        "eslint": "^8.31.0",
+        "eslint": "^8.32.0",
         "mocha": "^10.2.0",
         "c8": "^7.12.0",
         "source-map-support": "^0.5.21",