@abaplint/core 2.120.24 → 2.120.26

package/build/abaplint.d.ts

@@ -1260,7 +1260,7 @@ declare class ClassDefinition_3 extends Identifier implements IClassDefinition {
     private checkClassNameLength;
     private findSuper;
     private checkMethodNameLength;
-    private checkClassConstructorStatic;
+    private checkClassConstructor;
     private checkInterfaceVisibility;
     private checkMethodsFromSuperClasses;
     private checkMethodNameConflicts;
@@ -4897,6 +4897,7 @@ declare class MethodParameters_2 implements IMethodParameters {
     getParameterDefault(parameter: string): ExpressionNode;
     private parse;
     private checkDuplicateNames;
+    private checkNameLengths;
     private workaroundRAP;
     private add;
     private isPassByValue;

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

@@ -281,6 +281,12 @@ class TypeUtils {
         if (source2 instanceof basic_1.HexType && this.isCalculated(node2) && source1 instanceof basic_1.IntegerType) {
             return false;
         }
+        if (source1 instanceof basic_1.DateType && this.isCalculated(node2) && source2 instanceof basic_1.IntegerType) {
+            return false;
+        }
+        if (source2 instanceof basic_1.DateType && this.isCalculated(node1) && source1 instanceof basic_1.IntegerType) {
+            return false;
+        }
         return true;
     }
     structureContainsString(structure) {

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDatabaseFields = checkDatabaseFields;
+const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
+function checkDatabaseFields(fields, dbSources, input, token) {
+    if (dbSources.length > 1) {
+        return;
+    }
+    const first = dbSources[0];
+    if (first === undefined) {
+        // then its voided
+        return;
+    }
+    const type = first.parseType(input.scope.getRegistry());
+    if (type instanceof basic_1.VoidType || type instanceof basic_1.UnknownType) {
+        return;
+    }
+    if (!(type instanceof basic_1.StructureType)) {
+        const message = "checkFields, expected structure, " + type.constructor.name;
+        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, token, message));
+        return;
+    }
+    for (const field of fields) {
+        if (field === "*") {
+            continue;
+        }
+        if (/^\w+$/.test(field) && type.getComponentByName(field) === undefined) {
+            const message = `checkFields, field ${field} not found`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, token, message));
+            return;
+        }
+    }
+}
+//# sourceMappingURL=_check_database_fields.js.map

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

@@ -39,6 +39,7 @@ const source_1 = require("./source");
 const method_call_chain_1 = require("./method_call_chain");
 const source_field_symbol_1 = require("./source_field_symbol");
 const _syntax_input_1 = require("../_syntax_input");
+const basic_1 = require("../../types/basic");
 const _type_utils_1 = require("../_type_utils");
 class Compare {
     static runSyntax(node, input) {
@@ -56,7 +57,15 @@ class Compare {
         if (node.findDirectExpression(Expressions.CompareOperator)
             && new _type_utils_1.TypeUtils(input.scope).isCompareable(sourceTypes[0], sourceTypes[1], sources[0], sources[1]) === false
             && sourceTypes.length === 2) {
-            const message = "Incompatible types for comparison";
+            let message = "Incompatible types for comparison";
+            if ((sourceTypes[0] instanceof basic_1.DateType
+                && sourceTypes[1] instanceof basic_1.IntegerType
+                && sources[1].findFirstExpression(Expressions.ArithOperator))
+                || (sourceTypes[1] instanceof basic_1.DateType
+                    && sourceTypes[0] instanceof basic_1.IntegerType
+                    && sources[0].findFirstExpression(Expressions.ArithOperator))) {
+                message = "Date cannot be compared with arithmetic result of type Integer";
+            }
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
         }
     }

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

@@ -48,6 +48,7 @@ const dynamic_1 = require("./dynamic");
 const _reference_1 = require("../_reference");
 const _syntax_input_1 = require("../_syntax_input");
 const version_1 = require("../../../version");
+const _check_database_fields_1 = require("./_check_database_fields");
 const isSimple = /^\w+$/;
 class Select {
     static runSyntax(node, input, skipImplicitInto = false, selectLoop = false) {
@@ -72,7 +73,7 @@ class Select {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return;
         }
-        this.checkFields(fields, dbSources, input, node);
+        (0, _check_database_fields_1.checkDatabaseFields)(fields.map(field => field.code), dbSources, input, node.getFirstToken());
         const intoExpression = this.handleInto(node, input, fields, dbSources);
         const fae = node.findDirectExpression(Expressions.SQLForAllEntries);
         if (fae) {
@@ -299,35 +300,6 @@ class Select {
         }
         return undefined;
     }
-    static checkFields(fields, dbSources, input, node) {
-        if (dbSources.length > 1) {
-            return;
-        }
-        const first = dbSources[0];
-        if (first === undefined) {
-            // then its voided
-            return;
-        }
-        const type = first.parseType(input.scope.getRegistry());
-        if (type instanceof basic_1.VoidType || type instanceof basic_1.UnknownType) {
-            return;
-        }
-        if (!(type instanceof basic_1.StructureType)) {
-            const message = "checkFields, expected structure, " + type.constructor.name;
-            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-            return;
-        }
-        for (const field of fields) {
-            if (field.code === "*") {
-                continue;
-            }
-            if (isSimple.test(field.code) && type.getComponentByName(field.code) === undefined) {
-                const message = `checkFields, field ${field.code} not found`;
-                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-                return;
-            }
-        }
-    }
     static countResultType(scope) {
         if ((0, version_1.releaseAtLeast)(scope.getRelease(), version_1.Release.v750)
             || scope.getOpenABAP()

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

@@ -43,7 +43,12 @@ const _syntax_input_1 = require("../_syntax_input");
 const _type_utils_1 = require("../_type_utils");
 class Catch {
     runSyntax(node, input) {
-        var _a;
+        var _a, _b, _c;
+        const target = node.findDirectExpression(Expressions.Target);
+        const inlineTarget = (_b = (_a = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData)) === null || _a === void 0 ? void 0 : _a.findFirstExpression(Expressions.TargetField)) === null || _b === void 0 ? void 0 : _b.getFirstToken();
+        if (inlineTarget && inlineTarget.getStr().length > 30) {
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, inlineTarget, "Inline exception name longer than 30 characters"));
+        }
         const names = new Set();
         for (const c of node.findDirectExpressions(Expressions.ClassName)) {
             const token = c.getFirstToken();
@@ -67,9 +72,8 @@ class Catch {
             }
             names.add(className);
         }
-        const target = node.findDirectExpression(Expressions.Target);
         if (target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData)) {
-            const token = (_a = target.findFirstExpression(Expressions.TargetField)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
+            const token = (_c = target.findFirstExpression(Expressions.TargetField)) === null || _c === void 0 ? void 0 : _c.getFirstToken();
             if (token) {
                 const classNames = Array.from(names);
                 const unknownClass = classNames.find(name => input.scope.findClassDefinition(name) === undefined);

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

@@ -38,6 +38,7 @@ const Expressions = __importStar(require("../../2_statements/expressions"));
 const source_1 = require("../expressions/source");
 const dynamic_1 = require("../expressions/dynamic");
 const database_table_1 = require("../expressions/database_table");
+const _check_database_fields_1 = require("../expressions/_check_database_fields");
 class DeleteDatabase {
     runSyntax(node, input) {
         for (const s of node.findAllExpressions(Expressions.Source)) {
@@ -51,7 +52,14 @@ class DeleteDatabase {
         }
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
-            database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const fields = node.findAllExpressions(Expressions.SQLCompare)
+                .map(compare => { var _a; return (_a = compare.findDirectExpression(Expressions.SQLFieldName)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase(); })
+                .filter(field => field !== undefined);
+            for (const orderBy of node.findAllExpressions(Expressions.SQLOrderBy)) {
+                fields.push(...orderBy.findAllExpressions(Expressions.SQLFieldName).map(field => field.concatTokens().toUpperCase()));
+            }
+            (0, _check_database_fields_1.checkDatabaseFields)(fields, [dbSource], input, node.getFirstToken());
         }
     }
 }

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

@@ -42,11 +42,19 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const identifier_1 = require("../../1_lexer/tokens/identifier");
 const database_table_1 = require("../expressions/database_table");
 const dynamic_1 = require("../expressions/dynamic");
+const _check_database_fields_1 = require("../expressions/_check_database_fields");
 class UpdateDatabase {
     runSyntax(node, input) {
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
-            database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const fields = node.findAllExpressions(Expressions.SQLFieldAndValue)
+                .flatMap(fieldAndValue => fieldAndValue.findDirectExpressions(Expressions.SQLFieldName))
+                .map(field => field.concatTokens().toUpperCase());
+            fields.push(...node.findAllExpressions(Expressions.SQLCompare)
+                .map(compare => { var _a; return (_a = compare.findDirectExpression(Expressions.SQLFieldName)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase(); })
+                .filter(field => field !== undefined));
+            (0, _check_database_fields_1.checkDatabaseFields)(fields, [dbSource], input, node.getFirstToken());
         }
         const tableName = node.findDirectExpression(Expressions.DatabaseTable);
         const tokenName = tableName === null || tableName === void 0 ? void 0 : tableName.getFirstToken();

package/build/src/abap/5_syntax/structures/types.js

@@ -44,6 +44,7 @@ const include_type_1 = require("../statements/include_type");
 const type_1 = require("../statements/type");
 const Basic = __importStar(require("../../types/basic"));
 const _scope_type_1 = require("../_scope_type");
+const _syntax_input_1 = require("../_syntax_input");
 class Types {
     runSyntax(node, input, qualifiedNamePrefix) {
         const name = node.findFirstExpression(Expressions.NamespaceSimpleName).getFirstToken();
@@ -58,6 +59,9 @@ class Types {
                 if (ctyp instanceof Statements.Type) {
                     const found = new type_1.Type().runSyntax(c, input, qualifiedNamePrefix + name.getStr() + "-");
                     if (found) {
+                        if (found.getName().length > 30) {
+                            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, found.getToken(), "Structure field name longer than 30 characters"));
+                        }
                         components.push({ name: found.getName(), type: found.getType() });
                     }
                 }
@@ -74,6 +78,9 @@ class Types {
             else if (c instanceof nodes_1.StructureNode && ctyp instanceof Structures.Types) {
                 const found = new Types().runSyntax(c, input, qualifiedNamePrefix + name.getStr() + "-");
                 if (found) {
+                    if (found.getName().length > 30) {
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, found.getToken(), "Structure field name longer than 30 characters"));
+                    }
                     components.push({ name: found.getName(), type: found.getType() });
                 }
             }

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

@@ -101,7 +101,7 @@ class ClassDefinition extends _identifier_1.Identifier {
         this.checkEventNameConflicts(input);
         this.checkClassNameLength(input);
         this.checkMethodNameLength(input);
-        this.checkClassConstructorStatic(input);
+        this.checkClassConstructor(input);
     }
     getFriends() {
         return this.friends;
@@ -171,11 +171,17 @@ class ClassDefinition extends _identifier_1.Identifier {
             }
         }
     }
-    checkClassConstructorStatic(input) {
+    checkClassConstructor(input) {
         for (const m of this.methodDefs.getAll()) {
-            if (m.getName().toUpperCase() === "CLASS_CONSTRUCTOR" && m.isStatic() === false) {
+            if (m.getName().toUpperCase() !== "CLASS_CONSTRUCTOR") {
+                continue;
+            }
+            if (m.isStatic() === false) {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, m.getToken(), "CLASS_CONSTRUCTOR must be static"));
             }
+            else if (m.getVisibility() !== visibility_1.Visibility.Public) {
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, m.getToken(), "CLASS_CONSTRUCTOR must be declared in the public section"));
+            }
         }
     }
     checkInterfaceVisibility(input, node) {

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

@@ -45,6 +45,7 @@ const _object_oriented_1 = require("../5_syntax/_object_oriented");
 const _reference_1 = require("../5_syntax/_reference");
 const identifier_1 = require("../1_lexer/tokens/identifier");
 const _scope_type_1 = require("../5_syntax/_scope_type");
+const _syntax_input_1 = require("../5_syntax/_syntax_input");
 // todo:
 // this.exceptions = [];
 // also consider RAISING vs EXCEPTIONS
@@ -67,6 +68,7 @@ class MethodParameters {
         input.scope.push(_scope_type_1.ScopeType.MethodDefinition, "method definition", node.getStart(), input.filename);
         try {
             this.parse(node, input, parentName, abstractMethod);
+            this.checkNameLengths(input);
             this.checkDuplicateNames();
         }
         finally {
@@ -218,6 +220,13 @@ class MethodParameters {
             names.add(name);
         }
     }
+    checkNameLengths(input) {
+        for (const parameter of this.getAll()) {
+            if (parameter.getName().length > 30) {
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, parameter.getToken(), "Method parameter name longer than 30 characters"));
+            }
+        }
+    }
     workaroundRAP(node, input, parentName) {
         const resultName = node.findExpressionAfterToken("RESULT");
         const concat = node.concatTokens().toUpperCase();

package/build/src/registry.js

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

package/package.json

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