Merge pull request #13 from tayloraswift/linebreak-long-signatures

linebreak long function signatures

Author: tayloraswift

Assets/css/Main.css

@@ -73,7 +73,7 @@ let package:Package = .init(
         .package(url: "https://github.com/tayloraswift/swift-grammar", .upToNextMinor(
             from: "0.3.2")),
         .package(url: "https://github.com/tayloraswift/swift-mongodb", .upToNextMinor(
-            from: "0.8.1")),
+            from: "0.8.2")),
 
         .package(url: "https://github.com/swift-server/swift-backtrace", .upToNextMinor(
             from: "1.3.4")),
@@ -236,6 +236,9 @@ let package:Package = .init(
         .target(name: "MarkdownPluginSwift", dependencies:
             [
                 .target(name: "MarkdownABI"),
+                .target(name: "Signatures"),
+                .target(name: "Symbols"),
+
                 .product(name: "IDEUtils", package: "swift-syntax"),
                 .product(name: "SwiftParser", package: "swift-syntax"),
             ]),
@@ -330,6 +333,7 @@ let package:Package = .init(
             [
                 .target(name: "JSON"),
                 .target(name: "LexicalPaths"),
+                .target(name: "MarkdownPluginSwift"),
                 .target(name: "ModuleGraphs"),
                 .target(name: "Signatures"),
                 .target(name: "Symbols"),
@@ -481,6 +485,13 @@ let package:Package = .init(
                 .product(name: "Testing", package: "swift-grammar"),
             ]),
 
+        .executableTarget(name: "MarkdownPluginSwiftTests", dependencies:
+            [
+                .target(name: "MarkdownPluginSwift"),
+                .target(name: "MarkdownRendering"),
+                .product(name: "Testing", package: "swift-grammar"),
+            ]),
+
         .executableTarget(name: "MarkdownRenderingTests", dependencies:
             [
                 .target(name: "MarkdownRendering"),

Assets/css/Main.css.map

@@ -55,6 +55,8 @@ extension MarkdownBytecode
         case `class`
         case type
         case `typealias`
+        /// New in 8.0.
+        case indent
 
         //  Section elements.
         case parameters = 0xC0

Package.resolved

@@ -1,5 +1,8 @@
 extension MarkdownBytecode
 {
+    /// Markers inhabit the unassigned codepoints of the UTF-8 encoding.
+    ///
+    /// https://en.wikipedia.org/wiki/UTF-8
     @frozen public
     enum Marker:UInt8, Equatable, Hashable, Sendable
     {

Package.swift

@@ -0,0 +1,37 @@
+import IDEUtils
+import MarkdownABI
+
+extension MarkdownBytecode.Context
+{
+    init?(classification:SyntaxClassification)
+    {
+        switch classification
+        {
+        case    .none,
+                .editorPlaceholder:         return nil
+
+        case    .attribute:                 self = .attribute
+
+        case    .buildConfigId:             self = .directive
+        case    .poundDirectiveKeyword:     self = .magic
+
+        case    .lineComment,
+                .blockComment:              self = .comment
+        case    .docLineComment,
+                .docBlockComment:           self = .doccomment
+
+        case    .dollarIdentifier:          self = .pseudo
+        case    .identifier:                self = .identifier
+        case    .operatorIdentifier:        self = .operator
+
+        case    .integerLiteral,
+                .floatingLiteral:           self = .literalNumber
+        case    .stringLiteral,
+                .objectLiteral:             self = .literalString
+
+        case    .keyword:                   self = .keyword
+        case    .stringInterpolationAnchor: self = .interpolation
+        case    .typeIdentifier:            self = .type
+        }
+    }
+}

Sources/MarkdownABI/Bytecode/MarkdownBytecode.Context.swift

@@ -36,37 +36,14 @@ extension MarkdownCodeLanguage.Swift.Highlighter:MarkdownCodeHighlighter
                     start: base + span.offset,
                     count: span.length)
 
-                let context:MarkdownBytecode.Context
-                switch span.kind
+                if  let context:MarkdownBytecode.Context = .init(classification: span.kind)
                 {
-                case    .none,
-                        .editorPlaceholder:         binary += text ; continue
-
-                case    .attribute:                 context = .attribute
-
-                case    .buildConfigId:             context = .directive
-                case    .poundDirectiveKeyword:     context = .magic
-
-                case    .lineComment,
-                        .blockComment:              context = .comment
-                case    .docLineComment,
-                        .docBlockComment:           context = .doccomment
-
-                case    .dollarIdentifier:          context = .pseudo
-                case    .identifier:                context = .identifier
-                case    .operatorIdentifier:        context = .operator
-
-                case    .integerLiteral,
-                        .floatingLiteral:           context = .literalNumber
-                case    .stringLiteral,
-                        .objectLiteral:             context = .literalString
-
-                case    .keyword:                   context = .keyword
-                case    .stringInterpolationAnchor: context = .interpolation
-                case    .typeIdentifier:            context = .type
+                    binary[context] { $0 += text }
+                }
+                else
+                {
+                    binary += text
                 }
-
-                binary[context] { $0 += text }
             }
         }
     }

Sources/MarkdownABI/Bytecode/MarkdownBytecode.Marker.swift

@@ -0,0 +1,69 @@
+import MarkdownABI
+import Signatures
+
+extension Signature.Abridged
+{
+    @inlinable public
+    init(_ fragments:__shared some Sequence<Signature<Scalar>.Fragment>, actor:Bool = false)
+    {
+        var utf8:[UInt8] = []
+        for fragment:Signature.Fragment in fragments
+        {
+            utf8 += fragment.spelling.utf8
+        }
+        self.init(utf8: utf8, actor: actor)
+    }
+
+    @_spi(testable) public
+    init(_ string:String)
+    {
+        self.init(utf8: [UInt8].init(string.utf8))
+    }
+
+    @usableFromInline internal
+    init(utf8:[UInt8], actor:Bool = false)
+    {
+        let signature:SignatureSyntax = utf8.withUnsafeBufferPointer(SignatureSyntax.init)
+        let bytecode:MarkdownBytecode = .init
+        {
+            for span:SignatureSyntax.Span in signature.elements
+            {
+                switch span
+                {
+                case .wbr(indent: false):
+                    $0[.wbr]
+
+                case .wbr(indent: true):
+                    $0[.indent]
+
+                case .text(let range, nil, _):
+                    $0 += utf8[range]
+
+                case .text(let range, let color?, let depth):
+                    let text:String = .init(decoding: utf8[range], as: Unicode.UTF8.self)
+                    switch  (color, text, depth)
+                    {
+                    case    (.keyword, "subscript", .toplevel?),
+                            (.keyword, "deinit", .toplevel?),
+                            (.keyword, "init", .toplevel?),
+                            (.identifier, _, _):
+                        $0[.identifier] = text
+
+                    case    (.keyword, "class", .toplevel?):
+                        guard actor
+                        else
+                        {
+                            fallthrough
+                        }
+
+                        $0 += "actor"
+
+                    case    (_, _, _):
+                        $0 += text
+                    }
+                }
+            }
+        }
+        self.init(bytecode: bytecode)
+    }
+}

Sources/MarkdownPluginSwift/MarkdownBytecode.Context (ext).swift

@@ -0,0 +1,121 @@
+
+
+import MarkdownABI
+import Signatures
+
+extension Signature.Expanded
+{
+    @inlinable public
+    init(_ fragments:__shared some Collection<Signature<Scalar>.Fragment>,
+        keywords:inout InterestingKeywords)
+    {
+        var utf8:[UInt8] = []
+            utf8.reserveCapacity(fragments.reduce(0) { $0 + $1.spelling.utf8.count })
+
+        var symbols:[Int: Scalar] = [:]
+        for fragment:Signature.Fragment in fragments
+        {
+            let i:Int = utf8.endIndex
+            utf8 += fragment.spelling.utf8
+
+            if  let referent:Scalar = fragment.referent
+            {
+                symbols[i] = referent
+            }
+        }
+
+        self.init(utf8: utf8, keywords: &keywords, symbols: &symbols)
+
+        if !symbols.isEmpty
+        {
+            fatalError("""
+                syntax didn’t round-trip, failed to match symbols: \(symbols), \
+                source: '\(String.init(decoding: utf8, as: Unicode.UTF8.self))'
+                """)
+        }
+    }
+
+    @inlinable @_spi(testable) public
+    init(_ string:String)
+    {
+        var ignored:InterestingKeywords = .init()
+        self.init(string, keywords: &ignored)
+    }
+
+    @inlinable @_spi(testable) public
+    init(_ string:String, keywords:inout InterestingKeywords)
+    {
+        var empty:[Int: Scalar] = [:]
+        self.init(utf8: [UInt8].init(string.utf8), keywords: &keywords, symbols: &empty)
+    }
+
+    @inlinable internal
+    init(utf8:[UInt8], keywords:inout InterestingKeywords, symbols:inout [Int: Scalar])
+    {
+        let signature:SignatureSyntax = utf8.withUnsafeBufferPointer(SignatureSyntax.init)
+        var references:[Scalar: Int] = [:]
+        var referents:[Scalar] = []
+
+        let bytecode:MarkdownBytecode = .init
+        {
+            for span:SignatureSyntax.Span in signature.elements
+            {
+                switch span
+                {
+                case .wbr(indent: false):
+                    $0[.wbr]
+
+                case .wbr(indent: true):
+                    $0[.indent]
+
+                case .text(let range, nil, _):
+                    $0 += utf8[range]
+
+                case .text(let range, let color?, .toplevel?):
+                    if  case .keyword = color
+                    {
+                        //  The `actor` and `async` keywords are contextual; there is no
+                        //  other way to detect them besides inspecting token text!
+                        switch String.init(decoding: utf8[range], as: Unicode.UTF8.self)
+                        {
+                        case "actor":   keywords.actor = true
+                        case "class":   keywords.class = true
+                        default:        break
+                        }
+                    }
+
+                    fallthrough
+
+                case .text(let range, let color?, _):
+
+                    $0[color]
+                    {
+                        if  let referent:Scalar = symbols.removeValue(forKey: range.lowerBound)
+                        {
+                            $0[.href] =
+                            {
+                                if  let reference:Int = $0
+                                {
+                                    return reference
+                                }
+                                else
+                                {
+                                    let next:Int = referents.endIndex
+                                    referents.append(referent)
+                                    $0 = next
+                                    return next
+                                }
+                            } (&references[referent])
+                        }
+                    }
+                    content:
+                    {
+                        $0 += utf8[range]
+                    }
+                }
+            }
+        }
+
+        self.init(bytecode: bytecode, scalars: referents)
+    }
+}