@abaplint/core 2.120.74 → 2.120.76

package/build/src/rules/local_class_naming.js

@@ -23,6 +23,7 @@ class LocalClassNaming extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new LocalClassNamingConf();
+        this.regex = this.compile();
     }
     getMetadata() {
         return {
@@ -46,6 +47,15 @@ ENDCLASS.`,
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = this.compile();
+    }
+    compile() {
+        return {
+            local: new RegExp(this.conf.local, "i"),
+            exception: new RegExp(this.conf.exception, "i"),
+            test: new RegExp(this.conf.test, "i"),
+            ignorePatterns: name_validator_1.NameValidator.compileIgnorePatterns(this.conf),
+        };
     }
     runParsed(file, obj) {
         const issues = [];
@@ -59,20 +69,23 @@ ENDCLASS.`,
             }
             const className = classDef.name;
             let expected;
+            let regex;
             if (classDef.isForTesting) {
                 expected = this.conf.test;
+                regex = this.regex.test;
             }
             else if (ddic.isException(classDef, obj)) {
                 expected = this.conf.exception;
+                regex = this.regex.exception;
             }
             else {
                 expected = this.conf.local;
+                regex = this.regex.local;
             }
             if (expected === undefined || expected.length === 0) {
                 continue;
             }
-            const regex = new RegExp(expected, "i");
-            if (name_validator_1.NameValidator.violatesRule(className, regex, this.conf)) {
+            if (name_validator_1.NameValidator.violatesRule(className, regex, this.conf, this.regex.ignorePatterns)) {
                 issues.push(issue_1.Issue.atIdentifier(classDef.identifier, this.getDescription(expected, className), this.getMetadata().key, this.conf.severity));
             }
         }

package/build/src/rules/local_variable_names.js

@@ -58,6 +58,7 @@ class LocalVariableNames extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new LocalVariableNamesConf();
+        this.regex = this.compile();
     }
     getMetadata() {
         return {
@@ -85,6 +86,15 @@ ENDFORM.`,
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = this.compile();
+    }
+    compile() {
+        return {
+            expectedData: new RegExp(this.conf.expectedData, "i"),
+            expectedConstant: new RegExp(this.conf.expectedConstant, "i"),
+            expectedFS: new RegExp(this.conf.expectedFS, "i"),
+            ignorePatterns: name_validator_1.NameValidator.compileIgnorePatterns(this.conf),
+        };
     }
     runParsed(file) {
         const ret = [];
@@ -118,7 +128,7 @@ ENDFORM.`,
             const found = dat.findFirstExpression(Expressions.DefinitionName);
             if (found) {
                 const token = found.getFirstToken();
-                ret = ret.concat(this.checkName(token, file, this.conf.expectedData));
+                ret = ret.concat(this.checkName(token, file, this.conf.expectedData, this.regex.expectedData));
             }
         }
         // inline data
@@ -126,7 +136,7 @@ ENDFORM.`,
             const found = dat.findFirstExpression(Expressions.TargetField);
             if (found) {
                 const token = found.getFirstToken();
-                ret = ret.concat(this.checkName(token, file, this.conf.expectedData));
+                ret = ret.concat(this.checkName(token, file, this.conf.expectedData, this.regex.expectedData));
             }
         }
         // data structures, data begin of, first level
@@ -137,14 +147,14 @@ ENDFORM.`,
             const found = stat === null || stat === void 0 ? void 0 : stat.findFirstExpression(Expressions.DefinitionName);
             if (found) {
                 const token = found.getFirstToken();
-                ret = ret.concat(this.checkName(token, file, this.conf.expectedData));
+                ret = ret.concat(this.checkName(token, file, this.conf.expectedData, this.regex.expectedData));
             }
         }
         for (const fieldsymbol of structure.findAllStatements(Statements.FieldSymbol)) {
             const found = fieldsymbol.findFirstExpression(Expressions.FieldSymbol);
             if (found) {
                 const token = found.getFirstToken();
-                ret = ret.concat(this.checkName(token, file, this.conf.expectedFS));
+                ret = ret.concat(this.checkName(token, file, this.conf.expectedFS, this.regex.expectedFS));
             }
         }
         // inline field symbols
@@ -152,7 +162,7 @@ ENDFORM.`,
             const found = fieldsymbol.findFirstExpression(Expressions.TargetFieldSymbol);
             if (found) {
                 const token = found.getFirstToken();
-                ret = ret.concat(this.checkName(token, file, this.conf.expectedFS));
+                ret = ret.concat(this.checkName(token, file, this.conf.expectedFS, this.regex.expectedFS));
             }
         }
         const constants = structure.findAllStatements(Statements.Constant);
@@ -164,16 +174,15 @@ ENDFORM.`,
             const found = constant.findFirstExpression(Expressions.DefinitionName);
             if (found) {
                 const token = found.getFirstToken();
-                ret = ret.concat(this.checkName(token, file, this.conf.expectedConstant));
+                ret = ret.concat(this.checkName(token, file, this.conf.expectedConstant, this.regex.expectedConstant));
             }
         }
         return ret;
     }
-    checkName(token, file, expected) {
+    checkName(token, file, expected, regex) {
         const ret = [];
-        const regex = new RegExp(expected, "i");
         const name = token.getStr();
-        if (name_validator_1.NameValidator.violatesRule(name, regex, this.conf)) {
+        if (name_validator_1.NameValidator.violatesRule(name, regex, this.conf, this.regex.ignorePatterns)) {
             const message = this.getDescription(expected, name);
             const issue = issue_1.Issue.atToken(file, token, message, this.getMetadata().key, this.conf.severity);
             ret.push(issue);

package/build/src/rules/macro_naming.js

@@ -53,6 +53,7 @@ class MacroNaming extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new MacroNamingConf();
+        this.regex = new RegExp(this.conf.pattern, "i");
     }
     getMetadata() {
         return {
@@ -72,10 +73,10 @@ END-OF-DEFINITION.`,
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = new RegExp(this.conf.pattern, "i");
     }
     runParsed(file, obj) {
         const issues = [];
-        const testRegex = new RegExp(this.conf.pattern, "i");
         if (obj instanceof objects_1.TypePool) {
             return [];
         }
@@ -88,7 +89,7 @@ END-OF-DEFINITION.`,
                 continue;
             }
             const token = expr.getFirstToken();
-            if (testRegex.exec(token.getStr())) {
+            if (this.regex.exec(token.getStr())) {
                 continue;
             }
             else {

package/build/src/rules/method_parameter_names.js

@@ -27,6 +27,7 @@ exports.MethodParameterNamesConf = MethodParameterNamesConf;
 class MethodParameterNames {
     constructor() {
         this.conf = new MethodParameterNamesConf();
+        this.regex = this.compile();
     }
     getMetadata() {
         return {
@@ -52,6 +53,16 @@ class MethodParameterNames {
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = this.compile();
+    }
+    compile() {
+        return {
+            importing: new RegExp(this.conf.importing, "i"),
+            returning: new RegExp(this.conf.returning, "i"),
+            changing: new RegExp(this.conf.changing, "i"),
+            exporting: new RegExp(this.conf.exporting, "i"),
+            ignorePatterns: name_validator_1.NameValidator.compileIgnorePatterns(this.conf),
+        };
     }
     initialize(reg) {
         this.reg = reg;
@@ -91,16 +102,16 @@ class MethodParameterNames {
         for (const p of method.parameters) {
             switch (p.direction) {
                 case _abap_file_information_1.MethodParameterDirection.Importing:
-                    ret = ret.concat(this.checkParameter(p, this.conf.importing));
+                    ret = ret.concat(this.checkParameter(p, this.conf.importing, this.regex.importing));
                     break;
                 case _abap_file_information_1.MethodParameterDirection.Exporting:
-                    ret = ret.concat(this.checkParameter(p, this.conf.exporting));
+                    ret = ret.concat(this.checkParameter(p, this.conf.exporting, this.regex.exporting));
                     break;
                 case _abap_file_information_1.MethodParameterDirection.Changing:
-                    ret = ret.concat(this.checkParameter(p, this.conf.changing));
+                    ret = ret.concat(this.checkParameter(p, this.conf.changing, this.regex.changing));
                     break;
                 case _abap_file_information_1.MethodParameterDirection.Returning:
-                    ret = ret.concat(this.checkParameter(p, this.conf.returning));
+                    ret = ret.concat(this.checkParameter(p, this.conf.returning, this.regex.returning));
                     break;
                 default:
                     break;
@@ -108,11 +119,10 @@ class MethodParameterNames {
         }
         return ret;
     }
-    checkParameter(param, expected) {
+    checkParameter(param, expected, regex) {
         const ret = [];
-        const regex = new RegExp(expected, "i");
         const name = param.name;
-        if (name_validator_1.NameValidator.violatesRule(name, regex, this.conf)) {
+        if (name_validator_1.NameValidator.violatesRule(name, regex, this.conf, this.regex.ignorePatterns)) {
             const message = this.getDescription(expected, name);
             const issue = issue_1.Issue.atIdentifier(param.identifier, message, this.getMetadata().key, this.conf.severity);
             ret.push(issue);

package/build/src/rules/modify_only_own_db_tables.js

@@ -53,6 +53,7 @@ exports.ModifyOnlyOwnDBTablesConf = ModifyOnlyOwnDBTablesConf;
 class ModifyOnlyOwnDBTables {
     constructor() {
         this.conf = new ModifyOnlyOwnDBTablesConf();
+        this.ownTables = new RegExp(this.conf.ownTables, "i");
     }
     getMetadata() {
         return {
@@ -70,6 +71,7 @@ class ModifyOnlyOwnDBTables {
     }
     setConfig(conf) {
         this.conf = conf;
+        this.ownTables = new RegExp(this.conf.ownTables, "i");
     }
     initialize(reg) {
         this.reg = reg;
@@ -87,7 +89,6 @@ class ModifyOnlyOwnDBTables {
             if (struc === undefined) {
                 return [];
             }
-            const regExp = new RegExp(this.getConfig().ownTables, "i");
             for (const s of file.getStatements()) {
                 const g = s.get();
                 if (g instanceof Statements.DeleteDatabase
@@ -105,7 +106,7 @@ class ModifyOnlyOwnDBTables {
                         continue;
                     }
                     const concat = databaseTable.concatTokens().toUpperCase();
-                    if (regExp.test(concat) === false) {
+                    if (this.ownTables.test(concat) === false) {
                         // must contain a ReferenceType.TableVoidReference or a ReferenceType.TableReference if its a dependency
                         if (spaghetti === undefined) {
                             spaghetti = new syntax_1.SyntaxLogic(this.reg, obj).run().spaghetti;

package/build/src/rules/no_prefixes.js

@@ -71,6 +71,7 @@ class NoPrefixes extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new NoPrefixesConf();
+        this.regex = this.compile();
     }
     getMetadata() {
         return {
@@ -94,6 +95,18 @@ https://github.com/SAP/styleguides/blob/main/clean-abap/sub-sections/AvoidEncodi
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = this.compile();
+    }
+    compile() {
+        const compile = (pattern) => pattern !== undefined && pattern !== "" ? new RegExp(pattern, "i") : undefined;
+        return {
+            data: compile(this.conf.data),
+            statics: compile(this.conf.statics),
+            fieldSymbols: compile(this.conf.fieldSymbols),
+            constants: compile(this.conf.constants),
+            types: compile(this.conf.types),
+            methodParameters: compile(this.conf.methodParameters),
+        };
     }
     runParsed(file) {
         const ret = [];
@@ -107,38 +120,38 @@ https://github.com/SAP/styleguides/blob/main/clean-abap/sub-sections/AvoidEncodi
         if (max === undefined || max < 1) {
             max = 10;
         }
-        if (config.data !== undefined && config.data !== "") {
-            ret.push(...this.checkData(structure, new RegExp(config.data, "i"), file));
+        if (this.regex.data !== undefined) {
+            ret.push(...this.checkData(structure, this.regex.data, file));
         }
         if (ret.length >= max) {
             return ret;
         }
-        if (config.statics !== undefined && config.statics !== "") {
-            ret.push(...this.checkStatics(structure, new RegExp(config.statics, "i"), file));
+        if (this.regex.statics !== undefined) {
+            ret.push(...this.checkStatics(structure, this.regex.statics, file));
         }
         if (ret.length >= max) {
             return ret;
         }
-        if (config.fieldSymbols !== undefined && config.fieldSymbols !== "") {
-            ret.push(...this.checkFieldSymbols(structure, new RegExp(config.fieldSymbols, "i"), file));
+        if (this.regex.fieldSymbols !== undefined) {
+            ret.push(...this.checkFieldSymbols(structure, this.regex.fieldSymbols, file));
         }
         if (ret.length >= max) {
             return ret;
         }
-        if (config.constants !== undefined && config.constants !== "") {
-            ret.push(...this.checkConstants(structure, new RegExp(config.constants, "i"), file));
+        if (this.regex.constants !== undefined) {
+            ret.push(...this.checkConstants(structure, this.regex.constants, file));
         }
         if (ret.length >= max) {
             return ret;
         }
-        if (config.types !== undefined && config.types !== "") {
-            ret.push(...this.checkTypes(structure, new RegExp(config.types, "i"), file));
+        if (this.regex.types !== undefined) {
+            ret.push(...this.checkTypes(structure, this.regex.types, file));
         }
         if (ret.length >= max) {
             return ret;
         }
-        if (config.methodParameters !== undefined && config.methodParameters !== "") {
-            ret.push(...this.checkMethodParameters(structure, new RegExp(config.methodParameters, "i"), file));
+        if (this.regex.methodParameters !== undefined) {
+            ret.push(...this.checkMethodParameters(structure, this.regex.methodParameters, file));
         }
         return ret;
     }

package/build/src/rules/object_naming.js

@@ -78,6 +78,7 @@ exports.ObjectNamingConf = ObjectNamingConf;
 class ObjectNaming {
     constructor() {
         this.conf = new ObjectNamingConf();
+        this.regex = this.compile();
     }
     getMetadata() {
         return {
@@ -100,6 +101,20 @@ class ObjectNaming {
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = this.compile();
+    }
+    compile() {
+        const config = this.getConfig();
+        const patterns = new Map();
+        for (const [key, value] of Object.entries(config)) {
+            if (typeof value === "string" && key !== "patternKind" && key !== "severity") {
+                patterns.set(key, new RegExp(value, "i"));
+            }
+        }
+        return {
+            patterns,
+            ignorePatterns: name_validator_1.NameValidator.compileIgnorePatterns(config),
+        };
     }
     initialize(_reg) {
         return this;
@@ -113,11 +128,11 @@ class ObjectNaming {
         const config = this.getConfig();
         // @ts-ignore
         const pattern = config[abapType];
-        if (pattern === undefined) {
+        const regex = this.regex.patterns.get(abapType);
+        if (pattern === undefined || regex === undefined) {
             return [];
         }
-        const regex = new RegExp(pattern, "i");
-        if (name_validator_1.NameValidator.violatesRule(obj.getName(), regex, this.conf)) {
+        if (name_validator_1.NameValidator.violatesRule(obj.getName(), regex, this.conf, this.regex.ignorePatterns)) {
             message = this.getDescription(pattern, obj.getName());
         }
         if (message) {

package/build/src/rules/prefer_inline_cast.js

@@ -0,0 +1,276 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreferInlineCast = exports.PreferInlineCastConf = void 0;
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const _statement_1 = require("../abap/2_statements/statements/_statement");
+const _reference_1 = require("../abap/5_syntax/_reference");
+const syntax_1 = require("../abap/5_syntax/syntax");
+const _identifier_1 = require("../abap/4_file_information/_identifier");
+const _typed_identifier_1 = require("../abap/types/_typed_identifier");
+const basic_1 = require("../abap/types/basic");
+const edit_helper_1 = require("../edit_helper");
+const issue_1 = require("../issue");
+const _abap_object_1 = require("../objects/_abap_object");
+const version_1 = require("../version");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+class PreferInlineCastConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.PreferInlineCastConf = PreferInlineCastConf;
+class PreferInlineCast {
+    constructor() {
+        this.conf = new PreferInlineCastConf();
+    }
+    getMetadata() {
+        return {
+            key: "prefer_inline_cast",
+            title: "Prefer Inline CAST",
+            shortDescription: `Inline a CAST helper read only once in the next statement`,
+            extendedInformation: `Requires 7.40 SP02 or above, or ABAP Cloud, and no syntax errors.
+
+Reports DATA(t) = CAST type( source ) when the helper has exactly one read and no other access,
+except its declaration write, in the entire syntax scope (including earlier reads in loop bodies and exception handlers).
+The immediately following statement must be a plain assignment, an attribute read, a receiver method call,
+or a named IMPORTING argument of a functional method call (caller syntax p = t).
+
+Only class/interface CAST targets, simple assignment targets and static access are supported.
+For argument uses, the CAST operand must be a plain field chain without calls, the receiver and all
+other arguments must be plain variables or literals, and the method signature must be known.
+Explicit EXPORTING, IMPORTING and CHANGING sections are not supported.
+Objects containing macros or dynamic access are skipped. Field symbols, reference-taking,
+pragmas and chained statements are not supported.
+
+Predicates such as IS INITIAL / IS BOUND and removal of statically redundant CASTs are left for a future version.`,
+            tags: [_irule_1.RuleTag.Styleguide, _irule_1.RuleTag.Quickfix, _irule_1.RuleTag.SingleFile],
+            badExample: `DATA(helper) = CAST lcl_node( object ).
+result = helper->get_tokens( ).`,
+            goodExample: `result = CAST lcl_node( object )->get_tokens( ).`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    initialize(reg) {
+        this.reg = reg;
+        return this;
+    }
+    run(obj) {
+        var _a;
+        if (!(obj instanceof _abap_object_1.ABAPObject)
+            || (!(0, version_1.releaseAtLeast)(this.reg.getConfig().getRelease(), version_1.Release.v740sp02)
+                && this.reg.getConfig().getLanguageVersion() !== version_1.LanguageVersion.Cloud)) {
+            return [];
+        }
+        // Neither macro expansion nor a dynamically named variable has reliable references.
+        let hasCast = false;
+        for (const file of obj.getABAPFiles()) {
+            for (const statement of file.getStatements()) {
+                hasCast || (hasCast = statement.findFirstExpression(Expressions.Cast) !== undefined);
+                const type = statement.get();
+                if (type instanceof _statement_1.Unknown || type instanceof Statements.Define
+                    || type instanceof _statement_1.MacroCall || type instanceof _statement_1.MacroContent || type instanceof _statement_1.MacroRecursion
+                    || statement.findFirstExpression(Expressions.Dynamic) !== undefined) {
+                    return [];
+                }
+            }
+        }
+        if (!hasCast) {
+            return [];
+        }
+        const syntax = new syntax_1.SyntaxLogic(this.reg, obj).run();
+        if (syntax.issues.length > 0) {
+            return [];
+        }
+        const references = new Map();
+        const knownMethods = new Set();
+        for (const reference of this.references(syntax.spaghetti.getTop())) {
+            if (reference.resolved === undefined) {
+                continue;
+            }
+            const key = this.identifierKey(reference.resolved);
+            const uses = references.get(key) || [];
+            uses.push(reference);
+            references.set(key, uses);
+            if (reference.referenceType === _reference_1.ReferenceType.MethodReference) {
+                knownMethods.add(this.identifierKey(reference.position));
+            }
+        }
+        const issues = [];
+        for (const file of obj.getABAPFiles()) {
+            const statements = file.getStatements();
+            for (let index = 0; index < statements.length - 1; index++) {
+                const declaration = statements[index];
+                const next = statements[index + 1];
+                const cast = this.castDeclaration(declaration);
+                const inline = declaration.findFirstExpression(Expressions.InlineData);
+                const name = (_a = inline === null || inline === void 0 ? void 0 : inline.findDirectExpression(Expressions.TargetField)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
+                if (cast === undefined || name === undefined) {
+                    continue;
+                }
+                const scope = syntax.spaghetti.lookupPosition(name.getStart(), file.getFilename());
+                const identifier = scope === null || scope === void 0 ? void 0 : scope.findVariable(name.getStr());
+                if (!(identifier instanceof _typed_identifier_1.TypedIdentifier) || !(identifier.getType() instanceof basic_1.ObjectReferenceType)
+                    || identifier.getType().containsVoid()
+                    || identifier.getType().isGeneric()) {
+                    continue;
+                }
+                const uses = references.get(this.identifierKey(identifier)) || [];
+                const reads = uses.filter(r => r.referenceType === _reference_1.ReferenceType.DataReadReference);
+                const writes = uses.filter(r => r.referenceType === _reference_1.ReferenceType.DataWriteReference);
+                if (reads.length !== 1 || writes.length !== 1
+                    || !declaration.includesToken(writes[0].position.getToken())
+                    || uses.length !== 2 || !next.includesToken(reads[0].position.getToken())
+                    || !this.supportedUse(next, reads[0].position, knownMethods, cast)) {
+                    continue;
+                }
+                // Replace the later occurrence first, also when both statements are on the same line.
+                const fix = edit_helper_1.EditHelper.merge(edit_helper_1.EditHelper.replaceToken(file, reads[0].position.getToken(), cast.concatTokensWithLinebreaks()), edit_helper_1.EditHelper.deleteStatement(file, declaration));
+                issues.push(issue_1.Issue.atToken(file, name, "Inline single-use CAST helper", this.getMetadata().key, this.conf.severity, fix));
+            }
+        }
+        return issues;
+    }
+    identifierKey(identifier) {
+        const start = identifier.getStart();
+        return identifier.getFilename() + "," + start.getRow() + "," + start.getCol();
+    }
+    references(node) {
+        return node.getData().references.concat(...node.getChildren().map(child => this.references(child)));
+    }
+    castDeclaration(statement) {
+        var _a;
+        if (!(statement.get() instanceof Statements.Move) || statement.getColon() !== undefined
+            || statement.getPragmas().length > 0) {
+            return undefined;
+        }
+        const target = statement.findDirectExpression(Expressions.Target);
+        const source = statement.findDirectExpression(Expressions.Source);
+        const chain = source === null || source === void 0 ? void 0 : source.findDirectExpression(Expressions.MethodCallChain);
+        const cast = chain === null || chain === void 0 ? void 0 : chain.findDirectExpression(Expressions.Cast);
+        if ((target === null || target === void 0 ? void 0 : target.getChildren().length) !== 1 || target.findDirectExpression(Expressions.InlineData) === undefined
+            || (source === null || source === void 0 ? void 0 : source.getChildren().length) !== 1 || (chain === null || chain === void 0 ? void 0 : chain.getChildren().length) !== 1
+            || cast === undefined || cast.findDirectExpression(Expressions.Let) !== undefined
+            || cast.findDirectExpression(Expressions.Dereference) !== undefined
+            || ((_a = cast.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _a === void 0 ? void 0 : _a.concatTokens()) === "#"
+            || statement.findFirstExpression(Expressions.SourceFieldSymbol) !== undefined
+            || statement.getTokens().length !== target.countTokens() + source.countTokens() + 2
+            || statement.getTokens()[target.countTokens()].getStr() !== "=") {
+            return undefined;
+        }
+        return cast;
+    }
+    supportedUse(statement, read, knownMethods, cast) {
+        var _a, _b, _c;
+        if (statement.getColon() !== undefined || statement.getPragmas().length > 0
+            || statement.findFirstExpression(Expressions.SourceFieldSymbol) !== undefined
+            || statement.findFirstExpression(Expressions.MethodParameters) !== undefined) {
+            return false;
+        }
+        let chain;
+        if (statement.get() instanceof Statements.Move) {
+            const target = statement.findDirectExpression(Expressions.Target);
+            const source = statement.findDirectExpression(Expressions.Source);
+            if (target === undefined || source === undefined || !this.simpleTarget(target)
+                || statement.getTokens().length !== target.countTokens() + source.countTokens() + 2
+                || statement.getTokens()[target.countTokens()].getStr() !== "="
+                || source.getChildren().length !== 1) {
+                return false;
+            }
+            const field = source.findDirectExpression(Expressions.FieldChain);
+            if (field !== undefined) {
+                const tokens = field.getTokens();
+                return field.getFirstToken().getStart().equals(read.getStart())
+                    && (tokens.length === 1 || (tokens.length === 3 && tokens[1].getStr() === "->"
+                        && field.findDirectExpression(Expressions.AttributeName) !== undefined));
+            }
+            chain = source.findDirectExpression(Expressions.MethodCallChain);
+        }
+        else if (statement.get() instanceof Statements.Call) {
+            chain = statement.findDirectExpression(Expressions.MethodCallChain);
+        }
+        if (chain === undefined) {
+            return false;
+        }
+        const calls = chain.findDirectExpressions(Expressions.MethodCall);
+        const receiver = chain.findDirectExpression(Expressions.FieldChain);
+        if (calls.length !== 1 || (chain.getChildren().length !== 1 && chain.getChildren().length !== 3)
+            || (receiver !== undefined && receiver.countTokens() !== 1)) {
+            return false;
+        }
+        if (receiver === null || receiver === void 0 ? void 0 : receiver.getFirstToken().getStart().equals(read.getStart())) {
+            // The receiver is evaluated first; even calls in its arguments stay after the CAST.
+            return true;
+        }
+        // Named argument uses are limited to functional calls with a known signature.
+        const method = (_a = calls[0].findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
+        if (!(statement.get() instanceof Statements.Move) || method === undefined
+            || !this.plainCastOperand(cast)
+            || !knownMethods.has(this.identifierKey(new _identifier_1.Identifier(method, read.getFilename())))) {
+            return false;
+        }
+        const parameters = (_c = (_b = calls[0].findDirectExpression(Expressions.MethodCallParam)) === null || _b === void 0 ? void 0 : _b.findDirectExpression(Expressions.ParameterListS)) === null || _c === void 0 ? void 0 : _c.findDirectExpressions(Expressions.ParameterS);
+        return parameters !== undefined && parameters.some(p => { var _a; return (_a = p.findDirectExpression(Expressions.Source)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStart().equals(read.getStart()); })
+            && parameters.every(p => this.plainSource(p.findDirectExpression(Expressions.Source)));
+    }
+    plainCastOperand(cast) {
+        // Unlike receiver uses, argument uses can evaluate the receiver before the CAST operand.
+        // Exclude calls, table expressions and computed offsets/lengths from the field chain.
+        const source = cast.findDirectExpression(Expressions.Source);
+        const field = source === null || source === void 0 ? void 0 : source.findDirectExpression(Expressions.FieldChain);
+        return (source === null || source === void 0 ? void 0 : source.getChildren().length) === 1 && field !== undefined
+            && field.findFirstExpression(Expressions.MethodCall) === undefined
+            && field.findFirstExpression(Expressions.TableExpression) === undefined
+            && field.findFirstExpression(Expressions.FieldOffset) === undefined
+            && field.findFirstExpression(Expressions.FieldLength) === undefined;
+    }
+    simpleTarget(target) {
+        return target.countTokens() === 1 && target.findDirectExpression(Expressions.TargetField) !== undefined
+            || target.getChildren().length === 1 && target.findDirectExpression(Expressions.InlineData) !== undefined;
+    }
+    plainSource(source) {
+        if ((source === null || source === void 0 ? void 0 : source.getChildren().length) !== 1) {
+            return false;
+        }
+        return source.findDirectExpression(Expressions.Constant) !== undefined
+            || source.countTokens() === 1 && source.findDirectExpression(Expressions.FieldChain) !== undefined;
+    }
+}
+exports.PreferInlineCast = PreferInlineCast;
+//# sourceMappingURL=prefer_inline_cast.js.map