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

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

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

{abap_parser-0.2.0 → abap_parser-0.4.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.4.0"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/albertlast/abapPaser"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abap-parser
-Version: 0.2.0
+Version: 0.4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
@@ -50,6 +50,9 @@ prompt = abap_parser.text("logic", source)
 outline = await abap_parser.object_text_async("symbols", ["CLAS:ZCL_ORDERS"], options)
 # a CDS view: sources, joins, associations, the fields of each element
 view = abap_parser.cds(open("zi_orders.ddls.asddls", encoding="utf-8").read())
+# sources of the host, e.g. from its own cache: asked after the folders,
+# before the SAP system; returns the source or None
+own = abap_parser.call_graph(["CLAS:ZCL_ORDERS"], {"fetch": lambda ref: cache.get(ref)}, depth=2)
 ```
 
 Every function has an `..._async` variant for asyncio; the native code releases the GIL. The results are dictionaries typed by the TypedDicts in `abap_parser.types`. `text` and `object_text` give a compact form instead: definitions written like ABAP, one line per call or database access, per procedure its effects with statements and conditions. See the [repository](https://github.com/albertlast/abapPaser) for what each result contains.

{abap_parser-0.2.0 → abap_parser-0.4.0}/README.md

@@ -33,6 +33,9 @@ prompt = abap_parser.text("logic", source)
 outline = await abap_parser.object_text_async("symbols", ["CLAS:ZCL_ORDERS"], options)
 # a CDS view: sources, joins, associations, the fields of each element
 view = abap_parser.cds(open("zi_orders.ddls.asddls", encoding="utf-8").read())
+# sources of the host, e.g. from its own cache: asked after the folders,
+# before the SAP system; returns the source or None
+own = abap_parser.call_graph(["CLAS:ZCL_ORDERS"], {"fetch": lambda ref: cache.get(ref)}, depth=2)
 ```
 
 Every function has an `..._async` variant for asyncio; the native code releases the GIL. The results are dictionaries typed by the TypedDicts in `abap_parser.types`. `text` and `object_text` give a compact form instead: definitions written like ABAP, one line per call or database access, per procedure its effects with statements and conditions. See the [repository](https://github.com/albertlast/abapPaser) for what each result contains.

{abap_parser-0.2.0 → abap_parser-0.4.0}/bindings/python/README.md

@@ -33,6 +33,9 @@ prompt = abap_parser.text("logic", source)
 outline = await abap_parser.object_text_async("symbols", ["CLAS:ZCL_ORDERS"], options)
 # a CDS view: sources, joins, associations, the fields of each element
 view = abap_parser.cds(open("zi_orders.ddls.asddls", encoding="utf-8").read())
+# sources of the host, e.g. from its own cache: asked after the folders,
+# before the SAP system; returns the source or None
+own = abap_parser.call_graph(["CLAS:ZCL_ORDERS"], {"fetch": lambda ref: cache.get(ref)}, depth=2)
 ```
 
 Every function has an `..._async` variant for asyncio; the native code releases the GIL. The results are dictionaries typed by the TypedDicts in `abap_parser.types`. `text` and `object_text` give a compact form instead: definitions written like ABAP, one line per call or database access, per procedure its effects with statements and conditions. See the [repository](https://github.com/albertlast/abapPaser) for what each result contains.

{abap_parser-0.2.0 → abap_parser-0.4.0}/bindings/python/src/lib.rs

@@ -1,13 +1,31 @@
 //! Native part of the Python package. Results cross the boundary as JSON
 //! strings, abap_parser/__init__.py parses them, so the shape is exactly the
 //! Rust model.
+//!
+//! Functions loading sources take a `fetch` callable of the host; the
+//! native code runs without the GIL and takes it to call it.
 
 use pyo3::prelude::*;
 
 #[pymodule]
 mod _native {
+    use abap_analysis::abap_source::{FnProvider, SourceError};
+    use abap_analysis::json::Host;
     use pyo3::prelude::*;
 
+    /// `fetch(reference) -> str | None` as a source provider.
+    fn host(fetch: Option<Py<PyAny>>) -> Host {
+        let fetch = fetch?;
+        Some(Box::new(FnProvider::new("fetch", move |r| {
+            Python::attach(|py| {
+                fetch
+                    .call1(py, (r.to_string(),))
+                    .and_then(|v| v.bind(py).extract::<Option<String>>())
+            })
+            .map_err(|e| SourceError::Other(format!("fetch {r}: {e}")))
+        })))
+    }
+
     #[pyfunction]
     fn symbols_json(py: Python<'_>, source: &str) -> String {
         py.detach(|| abap_analysis::json::symbols(source))
@@ -24,19 +42,29 @@ mod _native {
     }
 
     #[pyfunction]
+    #[pyo3(signature = (roots, options, depth, fetch=None))]
     fn call_graph_json(
         py: Python<'_>,
         roots: Vec<String>,
         options: &str,
         depth: u32,
+        fetch: Option<Py<PyAny>>,
     ) -> PyResult<String> {
-        py.detach(|| abap_analysis::json::call_graph(&roots, options, depth))
+        let host = host(fetch);
+        py.detach(|| abap_analysis::json::call_graph(&roots, options, depth, host))
             .map_err(pyo3::exceptions::PyRuntimeError::new_err)
     }
 
     #[pyfunction]
-    fn fetch_source(py: Python<'_>, reference: &str, options: &str) -> PyResult<Option<String>> {
-        py.detach(|| abap_analysis::json::fetch(reference, options))
+    #[pyo3(signature = (reference, options, fetch=None))]
+    fn fetch_source(
+        py: Python<'_>,
+        reference: &str,
+        options: &str,
+        fetch: Option<Py<PyAny>>,
+    ) -> PyResult<Option<String>> {
+        let host = host(fetch);
+        py.detach(|| abap_analysis::json::fetch(reference, options, host))
             .map_err(pyo3::exceptions::PyRuntimeError::new_err)
     }
 
@@ -46,13 +74,16 @@ mod _native {
     }
 
     #[pyfunction]
+    #[pyo3(signature = (reference, options, depth, fetch=None))]
     fn logic_object_json(
         py: Python<'_>,
         reference: &str,
         options: &str,
         depth: u32,
+        fetch: Option<Py<PyAny>>,
     ) -> PyResult<String> {
-        py.detach(|| abap_analysis::json::logic_object(reference, options, depth))
+        let host = host(fetch);
+        py.detach(|| abap_analysis::json::logic_object(reference, options, depth, host))
             .map_err(pyo3::exceptions::PyRuntimeError::new_err)
     }
 
@@ -73,14 +104,17 @@ mod _native {
     }
 
     #[pyfunction]
+    #[pyo3(signature = (analysis, objects, options, depth, fetch=None))]
     fn object_text(
         py: Python<'_>,
         analysis: &str,
         objects: Vec<String>,
         options: &str,
         depth: u32,
+        fetch: Option<Py<PyAny>>,
     ) -> PyResult<String> {
-        py.detach(|| abap_analysis::json::object_text(analysis, &objects, options, depth))
+        let host = host(fetch);
+        py.detach(|| abap_analysis::json::object_text(analysis, &objects, options, depth, host))
             .map_err(pyo3::exceptions::PyRuntimeError::new_err)
     }
 

{abap_parser-0.2.0 → abap_parser-0.4.0}/bindings/python/tests/test_symbols.py

@@ -118,6 +118,34 @@ class SymbolsTest(unittest.TestCase):
         with self.assertRaises(RuntimeError):
             abap_parser.object_text("graph", ["CLAS:X"], {})
 
+    def test_sources_from_a_fetch_function(self):
+        sources = {
+            "PROG:ZMAIN": "REPORT zmain.\nSTART-OF-SELECTION.\n  CALL FUNCTION 'Z_SAVE'.\n  PERFORM run IN PROGRAM zother.",
+            "FUNC:Z_SAVE": "FUNCTION z_save.\n  DELETE FROM zlog WHERE id = 1.\nENDFUNCTION.",
+        }
+        asked = []
+
+        def fetch(reference):
+            asked.append(reference)
+            return sources.get(reference)
+
+        graph = abap_parser.call_graph(["PROG:ZMAIN"], {"fetch": fetch}, 2)
+        self.assertIn(("FUNC:Z_SAVE", "fetch:FUNC:Z_SAVE"), [(u["reference"], u["origin"]) for u in graph["units"]])
+        self.assertIn("PROG:ZOTHER", graph["missing"])
+        self.assertIn("FUNC:Z_SAVE", asked)
+        lg = abap_parser.logic_object("PROG:ZMAIN", {"fetch": fetch})
+        self.assertIn("ZLOG", [e["name"] for e in lg["procedures"][0]["effects"]])
+        self.assertEqual(abap_parser.fetch_source("PROG:ZMAIN", {"fetch": fetch}), sources["PROG:ZMAIN"])
+        self.assertIn("z_save", abap_parser.object_text("symbols", ["FUNC:Z_SAVE"], {"fetch": fetch}).lower())
+
+        def failing(reference):
+            raise ConnectionError("no connection")
+
+        graph = abap_parser.call_graph(["PROG:ZMAIN"], {"fetch": failing})
+        self.assertTrue(any("no connection" in e for e in graph["errors"]), graph["errors"])
+        with self.assertRaises(TypeError):
+            abap_parser.call_graph(["PROG:ZMAIN"], {"fetch": "nope"})
+
     @unittest.skipUnless((CORPUS / "abapgit" / "src").exists(), "corpus submodule missing")
     def test_real_class(self):
         path = CORPUS / "abapgit" / "src" / "apack" / "zcl_abapgit_apack_migration.clas.abap"

{abap_parser-0.2.0 → abap_parser-0.4.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.2.0 → abap_parser-0.4.0}/crates/abap-analysis/src/db.rs

@@ -35,6 +35,11 @@ pub(crate) fn db_access_with(file: &File, symbols: &m::FileSymbols) -> Vec<m::Db
                 resolve_dynamic(&mut a, &constants);
                 out.push(a);
             }
+        } else if let Some(mut a) = abap_sql::parse_cluster(file, s) {
+            a.block = blocks[i].clone();
+            a.text = file.statement_text(s);
+            a.span = span(file, i, i);
+            out.push(a);
         } else if let Some(end) = native_end(file, i) {
             // EXEC SQL ... ENDEXEC, or the body of an AMDP method: HANA SQL
             let (from, to) = native_range(file, i, end);

abap_parser-0.4.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"
+        );
+    }
+}