abap-parser 0.2.0__tar.gz → 0.3.0__tar.gz

{abap_parser-0.2.0 → abap_parser-0.3.0}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "abap-analysis"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "abap-model",
  "abap-source",
@@ -16,7 +16,7 @@ dependencies = [
 
 [[package]]
 name = "abap-cli"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "abap-analysis",
  "abap-lexer",
@@ -28,14 +28,14 @@ dependencies = [
 
 [[package]]
 name = "abap-lexer"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "abap-model"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "schemars",
  "serde",
@@ -44,7 +44,7 @@ dependencies = [
 
 [[package]]
 name = "abap-node"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "abap-analysis",
  "napi",
@@ -55,7 +55,7 @@ dependencies = [
 
 [[package]]
 name = "abap-python"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "abap-analysis",
  "pyo3",
@@ -63,16 +63,17 @@ dependencies = [
 
 [[package]]
 name = "abap-source"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "base64 0.22.1",
  "serde",
+ "serde_json",
  "ureq",
 ]
 
 [[package]]
 name = "abap-sql"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "abap-model",
  "abap-syntax",
@@ -82,7 +83,7 @@ dependencies = [
 
 [[package]]
 name = "abap-syntax"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "abap-lexer",
  "serde",

{abap_parser-0.2.0 → abap_parser-0.3.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/abap-lexer", "crates/abap-syntax", "crates/abap-model", "crates/abap-sql", "crates/abap-source", "crates/abap-analysis", "bindings/python"]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/albertlast/abapPaser"

{abap_parser-0.2.0 → abap_parser-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abap-parser
-Version: 0.2.0
+Version: 0.3.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3

{abap_parser-0.2.0 → abap_parser-0.3.0}/crates/abap-analysis/src/calls.rs

@@ -402,6 +402,18 @@ pub(crate) struct CallExtractor<'a> {
     pub file: &'a File,
     pub symbols: &'a m::FileSymbols,
     pub resolver: &'a dyn TypeResolver,
+    /// main program, for the names of customer exits
+    pub program: Option<String>,
+}
+
+/// The main program named by `REPORT`, `PROGRAM` or `FUNCTION-POOL`.
+pub(crate) fn main_program(symbols: &m::FileSymbols) -> Option<String> {
+    let p = symbols.program.as_ref()?;
+    match p.kind.as_str() {
+        "report" | "program" => Some(p.name.to_ascii_uppercase()),
+        "function-pool" => Some(format!("SAPL{}", p.name.to_ascii_uppercase())),
+        _ => None,
+    }
 }
 
 impl<'a> CallExtractor<'a> {
@@ -711,6 +723,25 @@ impl<'a> CallExtractor<'a> {
             out.push(new_call(kind, name, dynamic, opts));
         };
         match s.kind {
+            K::CallFunction if word(1) == "CUSTOMER" => {
+                // CALL CUSTOMER-FUNCTION 'nnn': the exit EXIT_<main program>_nnn
+                let Some(k) = (2..t.len()).find(|k| literal(t[*k]).is_some()) else {
+                    return t.len();
+                };
+                let number = literal(t[k]).unwrap_or_default();
+                let opts = vec!["CUSTOMER-FUNCTION".to_string()];
+                match &self.program {
+                    Some(p) => push(
+                        m::CallKind::Function,
+                        format!("EXIT_{}_{number}", p.to_ascii_uppercase()),
+                        false,
+                        opts,
+                    ),
+                    // the program is not known
+                    None => push(m::CallKind::Function, text(k, k + 1), true, opts),
+                }
+                k + 1
+            }
             K::CallFunction => {
                 let (name, dynamic) = target(2);
                 let opts = options(&[
@@ -1178,6 +1209,7 @@ pub(crate) fn new_call(
         from: None,
         name,
         class: None,
+        badi: None,
         program: None,
         receiver: None,
         is_static: false,
@@ -1379,6 +1411,7 @@ pub fn calls(source: &str) -> Vec<m::Call> {
         file: &file,
         symbols: &symbols,
         resolver: &resolver,
+        program: main_program(&symbols),
     }
     .calls()
 }
@@ -1431,6 +1464,29 @@ CLASS lcl_main IMPLEMENTATION.
 ENDCLASS.
 "#;
 
+    #[test]
+    fn customer_exits_are_named_by_the_program() {
+        let names = |src: &str| -> Vec<(String, bool)> {
+            calls(src)
+                .into_iter()
+                .map(|c| (c.name, c.dynamic))
+                .collect()
+        };
+        assert_eq!(
+            names("REPORT sapmv45a.\nCALL CUSTOMER-FUNCTION '001' EXPORTING iv = 1."),
+            [("EXIT_SAPMV45A_001".to_string(), false)]
+        );
+        assert_eq!(
+            names("FUNCTION-POOL v45a.\nCALL CUSTOMER-FUNCTION '010'."),
+            [("EXIT_SAPLV45A_010".to_string(), false)]
+        );
+        // an include alone does not tell its program
+        assert_eq!(
+            names("CALL CUSTOMER-FUNCTION '002'."),
+            [("'002'".to_string(), true)]
+        );
+    }
+
     #[test]
     fn calls_with_types() {
         let c = calls(SRC);

abap_parser-0.3.0/crates/abap-analysis/src/enhance.rs

@@ -0,0 +1,305 @@
+//! Code of enhancement implementations put where it runs: after an
+//! `ENHANCEMENT-POINT`, in place of an `ENHANCEMENT-SECTION`, or at the begin
+//! or end of a form, function module, method or include.
+//!
+//! The code goes into the source on one line, the line of its position, so
+//! the rows of the rest of the source stay as they are.
+
+use abap_source::Hook;
+use abap_syntax::{File, StatementKind as K, Token, TokenKind};
+
+/// Where in a source the code of a hook goes.
+struct Edit {
+    /// byte offset the code is inserted at
+    at: usize,
+    /// bytes from `at` on that the code replaces, for sections
+    replaces: usize,
+    code: String,
+}
+
+/// The sources with the hooks put in, for the units that change, and the
+/// hooks that found their position.
+pub(crate) fn apply<'a>(
+    units: &[(&str, &File)],
+    hooks: &'a [Hook],
+) -> (Vec<(usize, String)>, Vec<&'a Hook>) {
+    let mut edits: Vec<Vec<Edit>> = units.iter().map(|_| Vec::new()).collect();
+    let mut applied = Vec::new();
+    for h in hooks {
+        let Some((u, at, replaces)) = position(units, h) else {
+            continue;
+        };
+        edits[u].push(Edit {
+            at,
+            replaces,
+            code: one_line(&h.code),
+        });
+        applied.push(h);
+    }
+    let mut out = Vec::new();
+    for (u, mut edits) in edits.into_iter().enumerate() {
+        if edits.is_empty() {
+            continue;
+        }
+        let mut text = units[u].1.lexed.source.clone();
+        // from the end, so earlier offsets stay valid
+        edits.sort_by_key(|e| std::cmp::Reverse(e.at));
+        for e in edits {
+            let end = e.at + e.replaces;
+            // replaced code keeps its line breaks, so rows stay
+            let kept: String = text[e.at..end]
+                .chars()
+                .map(|c| if c == '\n' { '\n' } else { ' ' })
+                .collect();
+            text.replace_range(e.at..end, &format!(" {} {kept}", e.code));
+        }
+        out.push((u, text));
+    }
+    (out, applied)
+}
+
+/// The code of a hook on one line, without comments.
+fn one_line(code: &str) -> String {
+    let lexed = abap_syntax::lex(code);
+    let tokens: Vec<&Token> = lexed
+        .tokens
+        .iter()
+        .filter(|t| t.kind != TokenKind::Comment)
+        .collect();
+    abap_syntax::join_tokens(tokens)
+}
+
+/// The unit, byte offset and length of replaced code for a hook.
+fn position(units: &[(&str, &File)], h: &Hook) -> Option<(usize, usize, usize)> {
+    // enhancements of a function module's parameters have two sides
+    if h.position.matches("\\SE:").count() > 1 {
+        return None;
+    }
+    let include = h.part("IC");
+    let in_unit = |u: usize| include.as_deref().is_none_or(|i| units[u].0 == i);
+    if let Some(point) = h.part("EX") {
+        for (u, (_, file)) in units.iter().enumerate().filter(|(u, _)| in_unit(*u)) {
+            for (i, s) in file.statements.iter().enumerate() {
+                // ENHANCEMENT-POINT name SPOTS ...
+                let spots = s.tokens.iter().position(|k| file.tokens()[*k].is("SPOTS"));
+                let named = spots
+                    .and_then(|k| k.checked_sub(1))
+                    .and_then(|k| word(file, s, k))
+                    .is_some_and(|w| w == point);
+                match s.kind {
+                    K::EnhancementPoint if named => return Some((u, end(file, i), 0)),
+                    K::EnhancementSection if named => {
+                        // the implementation replaces the code of the section
+                        let close = (i + 1..file.statements.len())
+                            .find(|k| file.statements[*k].kind == K::EndEnhancementSection)?;
+                        let from = end(file, i);
+                        return Some((u, from, start(file, close) - from));
+                    }
+                    _ => {}
+                }
+            }
+        }
+        return None;
+    }
+    let begin = match h.part("SE")?.as_str() {
+        "BEGIN" => true,
+        "END" => false,
+        _ => return None,
+    };
+    let block = if let Some(form) = h.part("FO") {
+        Some((K::Form, K::EndForm, form, None))
+    } else if let Some(function) = h.part("FU") {
+        Some((K::FunctionModule, K::EndFunction, function, None))
+    } else {
+        h.part("ME")
+            .map(|method| (K::MethodImplementation, K::EndMethod, method, h.part("TY")))
+    };
+    let Some((open, close, name, class)) = block else {
+        // the begin or end of an include
+        let include = include?;
+        let u = units.iter().position(|(n, _)| *n == include)?;
+        let file = units[u].1;
+        return Some(if begin {
+            (u, 0, 0)
+        } else {
+            let last = (0..file.statements.len()).rev().find(|i| end(file, *i) > 0);
+            (u, last.map_or(0, |i| end(file, i)), 0)
+        });
+    };
+    for (u, (_, file)) in units.iter().enumerate().filter(|(u, _)| in_unit(*u)) {
+        let mut in_class: Option<String> = None;
+        for (i, s) in file.statements.iter().enumerate() {
+            if s.kind == K::ClassImplementation {
+                in_class = word(file, s, 1);
+            }
+            let found = s.kind == open
+                && word(file, s, 1).is_some_and(|w| w == name)
+                && class
+                    .as_deref()
+                    .is_none_or(|c| in_class.as_deref() == Some(c));
+            if !found {
+                continue;
+            }
+            if begin {
+                return Some((u, end(file, i), 0));
+            }
+            let k = (i + 1..file.statements.len()).find(|k| file.statements[*k].kind == close)?;
+            return Some((u, start(file, k), 0));
+        }
+    }
+    None
+}
+
+/// The `n`th word of a statement, upper case.
+fn word(file: &File, s: &abap_syntax::Statement, n: usize) -> Option<String> {
+    s.tokens.get(n).map(|k| file.tokens()[*k].upper())
+}
+
+fn start(file: &File, i: usize) -> usize {
+    let s = &file.statements[i];
+    s.tokens.first().map_or(0, |k| file.tokens()[*k].span.start)
+}
+
+/// The end of the statement `i`, without comments; 0 for comments only.
+fn end(file: &File, i: usize) -> usize {
+    let s = &file.statements[i];
+    s.tokens
+        .iter()
+        .map(|k| &file.tokens()[*k])
+        .filter(|t| t.kind != TokenKind::Comment)
+        .map(|t| t.span.end)
+        .max()
+        .unwrap_or(0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn hook(position: &str, code: &str) -> Hook {
+        Hook {
+            enhancement: "ZENH".into(),
+            position: position.into(),
+            code: code.into(),
+            origin: String::new(),
+        }
+    }
+
+    fn applied(source: &str, unit: &str, hooks: &[Hook]) -> String {
+        let file = abap_syntax::parse(source);
+        let (texts, _) = apply(&[(unit, &file)], hooks);
+        texts.into_iter().next().map(|(_, t)| t).unwrap_or_default()
+    }
+
+    #[test]
+    fn hooks_go_where_they_run() {
+        let src = "REPORT zr.
+ENHANCEMENT-POINT ep_top SPOTS zspot STATIC.
+FORM save.
+  gv = 1.
+ENDFORM.
+ENHANCEMENT-SECTION es_calc SPOTS zspot.
+  gv = 2.
+END-ENHANCEMENT-SECTION.";
+        let text = applied(
+            src,
+            "ZR",
+            &[
+                hook(
+                    "\\PR:ZR\\EX:EP_TOP\\EI",
+                    "ENHANCEMENT 1 ZENH.\n  DATA gv_x TYPE i. \" new\nENDENHANCEMENT.",
+                ),
+                hook(
+                    "\\PR:ZR\\FO:SAVE\\SE:END\\EI",
+                    "ENHANCEMENT 2 ZENH.\n  gv = 3.\nENDENHANCEMENT.",
+                ),
+                hook(
+                    "\\PR:ZR\\FO:SAVE\\SE:BEGIN\\EI",
+                    "ENHANCEMENT 3 ZENH.\n  gv = 4.\nENDENHANCEMENT.",
+                ),
+                hook(
+                    "\\PR:ZR\\EX:ES_CALC\\EI",
+                    "ENHANCEMENT 4 ZENH.\n  gv = 5.\nENDENHANCEMENT.",
+                ),
+                hook(
+                    "\\PR:ZR\\FO:NONE\\SE:END\\EI",
+                    "ENHANCEMENT 5 ZENH.\nENDENHANCEMENT.",
+                ),
+            ],
+        );
+        let lines: Vec<&str> = text.lines().map(str::trim_end).collect();
+        assert_eq!(
+            lines,
+            [
+                "REPORT zr.",
+                "ENHANCEMENT-POINT ep_top SPOTS zspot STATIC. ENHANCEMENT 1 ZENH. DATA gv_x TYPE i. ENDENHANCEMENT.",
+                "FORM save. ENHANCEMENT 3 ZENH. gv = 4. ENDENHANCEMENT.",
+                "  gv = 1.",
+                " ENHANCEMENT 2 ZENH. gv = 3. ENDENHANCEMENT. ENDFORM.",
+                "ENHANCEMENT-SECTION es_calc SPOTS zspot. ENHANCEMENT 4 ZENH. gv = 5. ENDENHANCEMENT.",
+                "",
+                "END-ENHANCEMENT-SECTION.",
+            ]
+        );
+    }
+
+    #[test]
+    fn methods_function_modules_and_includes() {
+        let src = "CLASS lcl IMPLEMENTATION.
+  METHOD run.
+  ENDMETHOD.
+ENDCLASS.
+CLASS zcl_x IMPLEMENTATION.
+  METHOD run.
+  ENDMETHOD.
+ENDCLASS.";
+        let text = applied(
+            src,
+            "ZCL_X=========================CP",
+            &[hook(
+                "\\TY:ZCL_X\\ME:RUN\\SE:BEGIN\\EI",
+                "ENHANCEMENT 1 ZENH.\nx = 1.\nENDENHANCEMENT.",
+            )],
+        );
+        assert_eq!(
+            text.lines().nth(5).unwrap(),
+            "  METHOD run. ENHANCEMENT 1 ZENH. x = 1. ENDENHANCEMENT. "
+        );
+
+        let text = applied(
+            "FUNCTION z_fm.\nENDFUNCTION.",
+            "Z_FM",
+            &[hook(
+                "\\FU:Z_FM\\SE:BEGIN\\EI",
+                "ENHANCEMENT 1 ZENH.\nx = 1.\nENDENHANCEMENT.",
+            )],
+        );
+        assert_eq!(
+            text.lines().next().unwrap(),
+            "FUNCTION z_fm. ENHANCEMENT 1 ZENH. x = 1. ENDENHANCEMENT. "
+        );
+        // parameters of function modules are not code
+        let text = applied(
+            "FUNCTION z_fm.\nENDFUNCTION.",
+            "Z_FM",
+            &[hook(
+                "\\FU:Z_FM\\SE:IMPORTING\\SE:END\\EI",
+                "ENHANCEMENT 1 ZENH.\nENDENHANCEMENT.",
+            )],
+        );
+        assert_eq!(text, "");
+
+        let text = applied(
+            "x = 1.\n\" end",
+            "ZINC",
+            &[hook(
+                "\\PR:ZR\\IC:ZINC\\SE:END\\EI",
+                "ENHANCEMENT 1 ZENH.\ny = 2.\nENDENHANCEMENT.",
+            )],
+        );
+        assert_eq!(
+            text,
+            "x = 1. ENHANCEMENT 1 ZENH. y = 2. ENDENHANCEMENT. \n\" end"
+        );
+    }
+}

{abap_parser-0.2.0 → abap_parser-0.3.0}/crates/abap-analysis/src/lib.rs

@@ -5,6 +5,7 @@ mod calls;
 mod context;
 mod db;
 mod ddic;
+mod enhance;
 mod logic;
 mod stores;
 mod symbols;

{abap_parser-0.2.0 → abap_parser-0.3.0}/crates/abap-analysis/src/logic.rs

@@ -40,6 +40,7 @@ pub fn logic_of(file: &File) -> m::FileLogic {
         file,
         symbols: &symbols,
         resolver: &resolver,
+        program: crate::calls::main_program(&symbols),
     }
     .calls();
     let attributes = |class: &str| class_attributes(&symbols, None, class);
@@ -73,6 +74,8 @@ impl Workspace {
     /// in the TOP include, has the scope `global`. Calls into other objects
     /// are followed up to `depth` hops, calls within the object always.
     pub fn logic(&self, root: &SourceRef, depth: u32) -> m::FileLogic {
+        // the engine loads callees one by one: load them before, several at once
+        self.preload(std::slice::from_ref(root), depth);
         let mut engine = Engine::new(Some(self), depth);
         let procedures = match engine.load(root, 0) {
             Some(o) => engine.finish(o),
@@ -92,7 +95,7 @@ impl Workspace {
 
 /// Calls through an interface are followed into at most this many
 /// implementations; with more, which one runs says too little.
-const MAX_IMPLEMENTATIONS: usize = 10;
+pub(crate) const MAX_IMPLEMENTATIONS: usize = 10;
 
 /// Subclasses looked at for redefinitions of a called method; with more,
 /// a class is too general to tell which redefinition runs.
@@ -463,7 +466,14 @@ impl<'w> Engine<'w> {
                 if !interface || name.contains('~') {
                     return Vec::new();
                 }
-                let classes = self.implementations(o, &class);
+                // CALL BADI runs the active implementations of the BAdI
+                let classes = match (&c.badi, self.workspace) {
+                    (Some(badi), Some(ws)) => ws
+                        .badi(badi)
+                        .map(|b| crate::workspace::badi_classes(&b))
+                        .unwrap_or_default(),
+                    _ => self.implementations(o, &class),
+                };
                 if classes.len() > MAX_IMPLEMENTATIONS {
                     return Vec::new();
                 }

{abap_parser-0.2.0 → abap_parser-0.3.0}/crates/abap-analysis/src/text.rs

@@ -523,14 +523,23 @@ fn call(c: &m::Call) -> String {
     if !c.resolved {
         flags.push("unresolved");
     }
+    // CALL BADI with the BAdI, its interface is the class
+    let options: Vec<String> = c
+        .options
+        .iter()
+        .map(|o| match &c.badi {
+            Some(b) if o == "BADI" => format!("BADI {b}"),
+            _ => o.clone(),
+        })
+        .collect();
     format!(
         "  {:>5} {from}: {} {target}{}{}\n",
         c.span.start.row,
         format!("{:?}", c.kind).to_ascii_lowercase(),
-        if c.options.is_empty() {
+        if options.is_empty() {
             String::new()
         } else {
-            format!(" [{}]", c.options.join(", "))
+            format!(" [{}]", options.join(", "))
         },
         if flags.is_empty() {
             String::new()