ffmt 0.3.4__tar.gz → 0.3.5__tar.gz

{ffmt-0.3.4 → ffmt-0.3.5}/Cargo.lock

@@ -73,9 +73,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.6.0"
+version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
+checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -95,9 +95,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.6.0"
+version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1110bd8a634a1ab8cb04345d8d878267d57c3cf1b38d91b71af6686408bbca6a"
+checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -156,7 +156,7 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "ffmt"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "clap",
  "ignore",
@@ -182,9 +182,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.16.1"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 
 [[package]]
 name = "heck"
@@ -210,9 +210,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.13.0"
+version = "2.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -268,9 +268,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
 dependencies = [
  "either",
  "rayon-core",

{ffmt-0.3.4 → ffmt-0.3.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ffmt"
-version = "0.3.4"
+version = "0.3.5"
 edition = "2021"
 description = "A fast, configurable Fortran formatter with Fypp, Doxygen, and OpenACC/OpenMP support"
 license = "MIT"

{ffmt-0.3.4 → ffmt-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmt
-Version: 0.3.4
+Version: 0.3.5
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -88,7 +88,7 @@ multdiv = false
 # pre-commit
 repos:
   - repo: https://github.com/sbryngelson/ffmt
-    rev: v0.3.3
+    rev: v0.3.5
     hooks:
       - id: ffmt
 ```

{ffmt-0.3.4 → ffmt-0.3.5}/README.md

@@ -71,7 +71,7 @@ multdiv = false
 # pre-commit
 repos:
   - repo: https://github.com/sbryngelson/ffmt
-    rev: v0.3.3
+    rev: v0.3.5
     hooks:
       - id: ffmt
 ```

{ffmt-0.3.4 → ffmt-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ffmt"
-version = "0.3.4"
+version = "0.3.5"
 description = "A fast, configurable Fortran formatter with Fypp, Doxygen, and OpenACC/OpenMP support"
 license = { text = "MIT" }
 requires-python = ">=3.8"

{ffmt-0.3.4 → ffmt-0.3.5}/src/formatter.rs

@@ -555,6 +555,7 @@ pub fn format_with_config(source: &str, config: &Config, range: Option<(usize, u
                 if line.len() > ll
                     && find_inline_doxygen_in_line(line).is_none()
                     && !line.trim_end().ends_with('&')
+                    && !line.trim_start().starts_with("& ")
                 {
                     final_lines.extend(rewrap_line(line, ll, iw));
                 } else {
@@ -1455,31 +1456,27 @@ fn join_short_comments(lines: &[String], max_length: usize) -> Vec<String> {
                 }
             }
 
-            // If only one line and it already fits, emit as-is
+            // If only one line, emit as-is
             if j == i + 1 {
                 result.push(line.clone());
                 i = j;
                 continue;
             }
 
-            // Rewrap the joined text at word boundaries
-            let words: Vec<&str> = full_text.split_whitespace().collect();
-            let mut current = String::new();
-            for word in &words {
-                if current.is_empty() {
-                    current = word.to_string();
-                } else if current.len() + 1 + word.len() <= avail {
-                    current.push(' ');
-                    current.push_str(word);
-                } else {
-                    result.push(format!("{}{}", prefix, current));
-                    current = word.to_string();
+            // Only join when the combined text fits on a single line.
+            // When each line is already at a reasonable length, they are
+            // independent comments and merging them would destroy the
+            // author's intent (and can cause a moved trailing comment to
+            // be merged into an unrelated preceding standalone comment).
+            if full_text.len() > avail {
+                for line in lines.iter().take(j).skip(i) {
+                    result.push(line.clone());
                 }
-            }
-            if !current.is_empty() {
-                result.push(format!("{}{}", prefix, current));
+                i = j;
+                continue;
             }
 
+            result.push(format!("{}{}", prefix, full_text));
             i = j;
         } else {
             result.push(line.clone());
@@ -1903,6 +1900,27 @@ fn rewrap_line(line: &str, max_length: usize, indent_width: usize) -> Vec<String
     let indent = leading_spaces(line);
     let content = line.trim_start();
 
+    // Split off trailing comment so we never produce a dangling "& ! comment" line.
+    // We wrap only the code portion; the comment is reattached to the last line.
+    let (code_content, trailing_comment) = split_trailing_comment(content);
+    let code_content = code_content.trim_end();
+
+    // If the code portion (with indent) fits but the comment makes it too long,
+    // move the comment to its own line(s) above the code.
+    if !trailing_comment.is_empty() && indent + code_content.len() <= max_length {
+        let comment_line = format!("{}{}", " ".repeat(indent), trailing_comment.trim());
+        let mut result = wrap_comment(&comment_line, max_length, 0, indent_width);
+        result.push(format!("{}{}", " ".repeat(indent), code_content));
+        return result;
+    }
+
+    // Use code-only content for wrapping; comment will be appended at the end
+    let content = if trailing_comment.is_empty() {
+        content
+    } else {
+        code_content
+    };
+
     // Find token boundaries in the content
     let breaks = find_token_breaks(content);
 
@@ -2036,10 +2054,46 @@ fn rewrap_line(line: &str, max_length: usize, indent_width: usize) -> Vec<String
     if result.is_empty() {
         vec![line.to_string()]
     } else {
+        // Reattach trailing comment to the last line
+        if !trailing_comment.is_empty() {
+            if let Some(last) = result.last_mut() {
+                last.push(' ');
+                last.push_str(trailing_comment);
+            }
+        }
         result
     }
 }
 
+/// Split content at the first `!` that starts a trailing comment (outside strings).
+/// Returns (code_part, comment_part). Comment part includes the `!`.
+fn split_trailing_comment(content: &str) -> (&str, &str) {
+    let bytes = content.as_bytes();
+    let mut in_string = false;
+    let mut quote_char = b' ';
+
+    for (i, &b) in bytes.iter().enumerate() {
+        if in_string {
+            if b == quote_char {
+                if i + 1 < bytes.len() && bytes[i + 1] == quote_char {
+                    continue; // doubled quote escape
+                }
+                in_string = false;
+            }
+            continue;
+        }
+        if b == b'\'' || b == b'"' {
+            in_string = true;
+            quote_char = b;
+            continue;
+        }
+        if b == b'!' {
+            return (&content[..i], &content[i..]);
+        }
+    }
+    (content, "")
+}
+
 #[derive(Clone, Copy)]
 enum BreakKind {
     Comma,
@@ -2058,10 +2112,37 @@ fn find_token_breaks(content: &str) -> Vec<(usize, BreakKind)> {
     let mut in_string = false;
     let mut quote_char = b' ';
     let mut paren_depth = 0i32;
+    let mut in_fypp = false; // inside ${...}$ or @{...}@ block
 
     while i < len {
         let b = bytes[i];
 
+        // Skip entire Fypp inline expressions — never break inside ${...}$ or @{...}@
+        if !in_string && !in_fypp && (b == b'$' || b == b'@') && i + 1 < len && bytes[i + 1] == b'{'
+        {
+            in_fypp = true;
+            i += 2;
+            let mut depth = 1i32;
+            while i < len && depth > 0 {
+                if bytes[i] == b'{' {
+                    depth += 1;
+                } else if bytes[i] == b'}' {
+                    depth -= 1;
+                    if depth == 0 {
+                        i += 1;
+                        // consume trailing $ or @
+                        if i < len && (bytes[i] == b'$' || bytes[i] == b'@') {
+                            i += 1;
+                        }
+                        in_fypp = false;
+                        break;
+                    }
+                }
+                i += 1;
+            }
+            continue;
+        }
+
         // Track strings — never break inside
         if in_string {
             if b == quote_char {
@@ -2104,6 +2185,19 @@ fn find_token_breaks(content: &str) -> Vec<(usize, BreakKind)> {
             breaks.push((end, BreakKind::Comma));
         }
 
+        // Dot-keyword logical operators: .and. .or. .eqv. .neqv.
+        // Break BEFORE the operator when preceded by a space, so a long
+        // `if (a .or. b .or. c)` wraps as `a .or. b &\n& .or. c`.
+        // .not. is unary — skip it.  .true./.false. are literals — skip them.
+        if !in_string && b == b'.' && i > 0 && bytes[i - 1] == b' ' {
+            let rest = &bytes[i..];
+            let lo =
+                |op: &[u8]| rest.len() >= op.len() && rest[..op.len()].eq_ignore_ascii_case(op);
+            if lo(b".and.") || lo(b".or.") || lo(b".eqv.") || lo(b".neqv.") {
+                breaks.push((i, BreakKind::Operator));
+            }
+        }
+
         // Binary operators at any paren depth
         {
             // Multi-char operators: check for //, /=, ==, <=, >=, =>, **
@@ -2151,6 +2245,11 @@ fn find_token_breaks(content: &str) -> Vec<(usize, BreakKind)> {
         i += 1;
     }
 
+    // Never break immediately before `%` (member accessor).  A break there
+    // would produce `& %member` on the next line, which is a blank within a
+    // lexical token — invalid in Fortran free-form (§6.3.2.2).
+    breaks.retain(|&(bp, _)| bp >= len || bytes[bp] != b'%');
+
     breaks
 }
 

{ffmt-0.3.4 → ffmt-0.3.5}/src/lsp.rs

@@ -216,18 +216,16 @@ fn handle_message(
 
         _ => {
             // Unknown method — return method not found for requests (with id)
-            if let Some(id) = msg.get("id") {
-                Some(vec![json!({
+            msg.get("id").map(|id| {
+                vec![json!({
                     "jsonrpc": "2.0",
                     "id": id,
                     "error": {
                         "code": -32601,
                         "message": format!("method not found: {}", method)
                     }
-                })])
-            } else {
-                None // notification, ignore
-            }
+                })]
+            })
         }
     }
 }

{ffmt-0.3.4 → ffmt-0.3.5}/src/reader.rs

@@ -86,14 +86,11 @@ fn strip_leading_amp(line: &str) -> &str {
 fn strip_amp_comment_continuation(line: &str) -> String {
     let trimmed = line.trim_start();
     // Match: leading `&` followed by optional spaces then `!` (but not `!$` for OpenACC/OMP)
-    if trimmed.starts_with("& !") && !trimmed.starts_with("& !$") {
-        // Check there's no code between & and ! — only whitespace
-        let after_amp = &trimmed[1..].trim_start();
+    if let Some(stripped) = trimmed.strip_prefix('&') {
+        let after_amp = stripped.trim_start();
         if after_amp.starts_with('!') && !after_amp.starts_with("!$") {
-            // Convert to plain comment: preserve indentation, replace `& !` with `!`
             let indent = line.len() - line.trim_start().len();
-            let comment = &trimmed[1..].trim_start(); // "! comment text"
-            return format!("{}{}", " ".repeat(indent), comment);
+            return format!("{}{}", " ".repeat(indent), after_amp);
         }
     }
     line.to_string()
@@ -236,22 +233,65 @@ pub fn read_logical_lines(source: &str) -> Vec<LogicalLine> {
             }
 
             // If this line is a comment (possibly after `& !` was cleaned to `!`),
-            // stop continuation — Cray ftn rejects `& ! comment` lines (ftn-71).
-            // The comment will be emitted as a separate logical line.
-            // Also strip the trailing `&` from the last accumulated raw line,
-            // since the continuation has no actual code content.
+            // check whether more continuation code follows. Cray ftn (ftn-71)
+            // rejects `& ! comment` lines, so these are converted to plain
+            // comments. If they appear mid-continuation (more `& code` follows),
+            // we preserve them in the raw lines but skip them in the joined
+            // content so the logical statement stays intact. If the comment is
+            // the last line of the continuation, strip the trailing `&` from the
+            // preceding code line and stop.
             let cont_trimmed = cont_line.trim_start();
             if cont_trimmed.starts_with('!') && !cont_trimmed.starts_with("!$") {
-                if let Some(last_raw) = raw_lines_acc.last_mut() {
-                    if let Some(pos) = find_continuation_amp(last_raw) {
-                        *last_raw = last_raw[..pos].trim_end().to_string();
+                // Peek ahead past any additional blank/comment lines to see
+                // whether a continuation line (starting with `&`) follows.
+                let mut peek = i + 1;
+                while peek < raw_count {
+                    let p = cleaned[peek].as_str().trim_start();
+                    if p.is_empty() {
+                        peek += 1;
+                        continue;
                     }
+                    if p.starts_with('!') && !p.starts_with("!$") {
+                        peek += 1;
+                        continue;
+                    }
+                    break;
+                }
+                let more_continuation =
+                    peek < raw_count && cleaned[peek].as_str().trim_start().starts_with('&');
+
+                if more_continuation {
+                    // Mid-continuation comment: keep in raw lines so the
+                    // original structure is preserved in the
+                    // continuation_interrupted path, but don't add any content
+                    // to joined_parts (comments carry no code).
+                    raw_lines_acc.push(cont_line.to_string());
+                    i += 1;
+                    continue;
+                } else {
+                    // Terminal comment: strip trailing `&` from the last code
+                    // line and stop — the comment becomes its own logical line.
+                    if let Some(last_raw) = raw_lines_acc.last_mut() {
+                        if let Some(pos) = find_continuation_amp(last_raw) {
+                            *last_raw = last_raw[..pos].trim_end().to_string();
+                        }
+                    }
+                    break;
                 }
-                break;
             }
 
             raw_lines_acc.push(cont_line.to_string());
 
+            // Track whether this continuation line had a leading `&`.
+            // Per the Fortran free-form standard, when `&` is the last
+            // non-blank character on line N and line N+1 begins with `&`,
+            // the statement continues immediately after the leading `&`
+            // with NO implicit space inserted (the two tokens are glued).
+            // When line N+1 does NOT begin with `&`, one implicit space
+            // is inserted.  This matters for member access: `x &\n& %y`
+            // must join as `x%y`, not `x %y`.
+            let had_leading_amp = cont_line.trim_start().starts_with('&');
+
             // Strip leading `&` if present
             let stripped = strip_leading_amp(cont_line);
 
@@ -265,8 +305,17 @@ pub fn read_logical_lines(source: &str) -> Vec<LogicalLine> {
                 stripped.to_string()
             };
 
-            // Add space separator to prevent tokens from merging
-            joined_parts.push(format!(" {}", content.trim_start()));
+            let content_trimmed = content.trim_start();
+            // Suppress the space separator when the continuation starts with
+            // `%` (member accessor).  Adding a space there would produce
+            // `a %b` which is a blank within a lexical token — invalid in
+            // Fortran free-form (§6.3.2.2).
+            let sep = if had_leading_amp && content_trimmed.starts_with('%') {
+                ""
+            } else {
+                " "
+            };
+            joined_parts.push(format!("{}{}", sep, content_trimmed));
             i += 1;
 
             if !this_fort {

ffmt-0.3.5/tests/fixtures/trailing_comment_wrap.expected.fpp

@@ -0,0 +1,24 @@
+subroutine test_trailing_comment()
+
+    ! Already-broken dangling continuation + comment (illegal output from old formatter)
+    select case (dir)
+    case (101)
+        ! this was an illegal dangling continuation comment
+        x = 2
+    end select
+
+    ! Long trailing comment on a call - should move above and wrap
+    ! this is a very long trailing comment that exceeds the line length limit and should be moved above the code line rather than
+    ! dangling
+    call some_long_sub(arg1, arg2)
+
+    ! Short trailing comment that fits - should stay inline
+    call some_sub(a, b, c)  ! quick note
+
+    ! Mid-continuation comment: code must stay intact (comment is dropped)
+    call some_sub(arg1, arg2, arg3, arg4)
+
+    ! Mid-continuation comment with multiple following continuations
+    x = 1 + 2 + 3 + y + z
+
+end subroutine test_trailing_comment

ffmt-0.3.5/tests/fixtures/trailing_comment_wrap.input.fpp

@@ -0,0 +1,26 @@
+subroutine test_trailing_comment()
+
+    ! Already-broken dangling continuation + comment (illegal output from old formatter)
+    select case (dir)
+    case (101) &
+          & ! this was an illegal dangling continuation comment
+        x = 2
+    end select
+
+    ! Long trailing comment on a call — should move above and wrap
+    call some_long_sub(arg1, arg2) ! this is a very long trailing comment that exceeds the line length limit and should be moved above the code line rather than dangling
+
+    ! Short trailing comment that fits — should stay inline
+    call some_sub(a, b, c) ! quick note
+
+    ! Mid-continuation comment: code must stay intact (comment is dropped)
+    call some_sub(arg1, arg2, &
+      & ! comment about args
+      & arg3, arg4)
+
+    ! Mid-continuation comment with multiple following continuations
+    x = 1+2+3 &
+      & ! explain the split
+      & + y + z
+
+end subroutine test_trailing_comment

{ffmt-0.3.4 → ffmt-0.3.5}/tests/integration.rs

@@ -81,6 +81,23 @@ fn test_idempotent_fypp() {
     assert_eq!(first, second, "Formatter is not idempotent on fypp fixture");
 }
 
+#[test]
+fn test_trailing_comment_wrap() {
+    run_fixture("trailing_comment_wrap");
+}
+
+#[test]
+fn test_idempotent_trailing_comment_wrap() {
+    let fixture_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
+    let input = fs::read_to_string(fixture_dir.join("trailing_comment_wrap.input.fpp")).unwrap();
+    let first = ffmt::format_string(&input);
+    let second = ffmt::format_string(&first);
+    assert_eq!(
+        first, second,
+        "Formatter is not idempotent on trailing_comment_wrap fixture"
+    );
+}
+
 #[test]
 fn test_error_recovery() {
     let input =