Consider pilfering functionality

[dabrahams]

I was the primary developer of this file when I was on the Swift project, and there are some nice bits in there that might benefit your mode. In particular, the -skip- functions approximately parse swift pretty reliably and efficiently (I see you have your own code for that and I haven't tried to compare it, but the hangs with which-function mode make me suspect you might want to try a different approach), and there are useful functions for folding away the details of files when you want to easily understand an API.

I sucked those into my personal configuration so I could still use that functionality with your mode.

If there's any interest, I'm happy to help. OTOH, if you've already evaluated what's in there and decided none of it is useful, then, sorry for the noise!

[taku0]

Our lexer needs to analyze the type of tokens and required to parse both forward and backward, rather than just skipping forward. It also needs to parse various constructs other than types.

Hiding bodies would be useful, but why not just use hs-hide-all or hs-hide-level? Those functions can handle other types of blocks and parenthesis. For example, swift-hide-bodies doesn't hide let definitions in Parser.swift while hs-hide-level handles parenthesized expressions well.

Besides, swift-hide-bodies needs some improvements:

• swift-skip-type-name doesn't skip those types:

  • Types with attribute: @A B
  • Implicitly unwrapped optional types: Int!
  • Protocol composition types: P & Q
  • Opaque types: some P
  • Explicit existential types: any P
  • Async function types: (Int) async throws -> Int
  • Type names in backticks: `Int`
  • Type names with emoji: 😊

• swift-hide-bodies mishandles:

  • Bare keyword as an identifier:

    class Foo {
      func `deinit`(f: () -> Void) -> Void {
        f()
      }
    }
    
    let foo = Foo()
    // we can use bare keyword as identifier after dot.
    let x = foo.deinit {
      print("aaa")
    }

  • var in case patterns:

    if case var x: Int=1 {
      print("aaa")
    }

    Note that swift-skip-type-name thinks Int=1 is a type name.

swift-hide-doc-comment-detail seems to be nice to incorporate. I'm not sure how to combine codes under Apache License v2.0 and GPLv3, though I know that Apache License v2.0 is compatible with GPLv3.

Other than that, Apple's swift-mode seems to be less accurate while concise and efficient; it doesn't handle those constructs:

• Multiline string literals:

    let x = """
      aaa " aaa
      """
    let y = Foo()

• Extended string literals: #"abc"def"#

• String interpolations: "aaa \(/* " */ 1) bbb"

• Regular expressions.

• Nested multiline comments.

[dabrahams]

On Nov 19, 2022, at 2:31 AM, taku0 ***@***.***> wrote: Hiding bodies would be useful, but why not just use hs-hide-all or hs-hide-level?

hs-hide-all hides too much (the methods and properties of every type); I was unable to make hs-hide-level do anything useful in my Swift file.

Those functions can handle other types of blocks and parenthesis. For example, swift-hide-bodies doesn't hide let definitions in Parser.swift <https://github.com/val-lang/val/blob/a4afd99/Sources/Compiler/Parse/Parser.swift> while hs-hide-level handles parenthesized expressions well.

? let definitions don’t ever have bodies in Swift. A body is a block surrounded by braces at the top level of a declaration. Hiding everything but the summary of doc comments can also be extremely useful. I’m aware code hasn’t been updated in many years as Swift syntax has evolved, and if it or the features it implements are of no use to you, that’s perfectly fine with me. I just thought I’d offer. Cheers, Dave

[taku0]

hs-hide-all hides too much (the methods and properties of every type); I was unable to make hs-hide-level do anything useful in my Swift file.

C-2 M-x hs-hide-level at the beginning of the Parser.swift will show you outline of the file.

? let definitions don’t ever have bodies in Swift. A body is a block surrounded by braces at the top level of a declaration.

Parser.swift has many let bindings with large expression, that is, functionDecl and followings. To grab the outline of the file, it should be hidden.

[dabrahams]

I still miss the folding features I had before I switched to using this otherwise-superior swift-mode package. I want to hide doc-comments except for summary paragraphs, which are, if written well, almost always sufficient. I also want this folding to work on nested types and functions. Please consider this a feature request. Thank you.

[taku0]

Those features should be implemented as a generic command, not as a command of Swift mode. Possible implementation outline:

hs-hide-all-declarations:
  call imenu-create-index-function
  foreach leaf items (i.e. items without children):
    goto the beginning position of the item
    call hs-find-next-block
    call hs-forward-sexp-func
    record the current point as the end position of the item
  sort leaf items by the beginning position
  foreach leaf items:
    if the item doesn't contain other items, in other words, if the end position of the item preceeds the beginning of the next item:
      hide the item

hs-hide-all-comments:
  foreach lines:
    call end-of-line
    call syntax-ppss
    if the point is inside a comment:
      hide the comment

Also add an option to hide a comment except the first sentence, in terms of forward-sentence, when hiding a comment by hs-hide-block.

Please contact to the authors of Hideshow Minor Mode, or implement yourself and contribute it to the Hideshow Minor Mode. If they choose forward-paragraph instead of forward-sentence, I will fix paragraph-start or paragraph-separate of Swift mode to handle comments.