make the SignatureSyntax code less reliant on Swift operator overloading

tayloraswift · tayloraswift · commit 3c20ec4af1af · 2024-12-25T19:15:39.000Z
diff --git a/Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.Encoder.swift b/Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.Encoder.swift
@@ -125,8 +125,8 @@ extension SignatureSyntax.Encoder
 
 extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>
 {
-    static
-    func += (self:inout Self, decl:DeclSyntax)
+    mutating
+    func encode(decl:DeclSyntax)
     {
         for region:Syntax in decl.children(viewMode: .sourceAccurate)
         {
@@ -150,7 +150,7 @@ extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>
                 let clause:GenericParameterClauseSyntax =
                     region.as(GenericParameterClauseSyntax.self)
             {
-                self += clause
+                self.encode(clause)
             }
             else if
                 let region:FunctionSignatureSyntax = region.as(FunctionSignatureSyntax.self)
@@ -187,8 +187,8 @@ extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>
         }
     }
 
-    static
-    func += (self:inout Self, clause:GenericParameterClauseSyntax)
+    private mutating
+    func encode(_ clause:GenericParameterClauseSyntax)
     {
         for region:Syntax in clause.children(viewMode: .sourceAccurate)
         {
@@ -221,110 +221,110 @@ extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>
 
 extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>
 {
-    static
-    func += (self:inout Self, decl:DeclSyntax)
+    mutating
+    func encode(decl:DeclSyntax)
     {
         if  let decl:ActorDeclSyntax = decl.as(ActorDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.actorKeyword
             self[at: .toplevel] += decl.name.trimmed
-            self ?= decl.genericParameterClause?.trimmed
+            self.encode(decl.genericParameterClause?.trimmed)
         }
         else if
             let decl:AssociatedTypeDeclSyntax = decl.as(AssociatedTypeDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.associatedtypeKeyword
             self[at: .toplevel] += decl.name.trimmed
         }
         else if
             let decl:ClassDeclSyntax = decl.as(ClassDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.classKeyword
             self[at: .toplevel] += decl.name.trimmed
-            self ?= decl.genericParameterClause?.trimmed
+            self.encode(decl.genericParameterClause?.trimmed)
         }
         else if
             let decl:EnumDeclSyntax = decl.as(EnumDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.enumKeyword
             self[at: .toplevel] += decl.name.trimmed
-            self ?= decl.genericParameterClause?.trimmed
+            self.encode(decl.genericParameterClause?.trimmed)
         }
         else if
             let decl:ProtocolDeclSyntax = decl.as(ProtocolDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.protocolKeyword
             self[at: .toplevel] += decl.name.trimmed
             self ?= decl.primaryAssociatedTypeClause?.trimmed
         }
         else if
             let decl:StructDeclSyntax = decl.as(StructDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.structKeyword
             self[at: .toplevel] += decl.name.trimmed
-            self ?= decl.genericParameterClause?.trimmed
+            self.encode(decl.genericParameterClause?.trimmed)
         }
         else if
             let decl:DeinitializerDeclSyntax = decl.as(DeinitializerDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self[at: .toplevel] += decl.deinitKeyword
             self ?= decl.effectSpecifiers?.trimmed
         }
         else if
             let decl:FunctionDeclSyntax = decl.as(FunctionDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.funcKeyword
             self[at: .toplevel] += decl.name
-            self ?= decl.genericParameterClause
-            self += decl.signature
+            self.encode(decl.genericParameterClause?.trimmed)
+            self.encode(decl.signature)
         }
         else if
             let decl:InitializerDeclSyntax = decl.as(InitializerDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self[at: .toplevel] += decl.initKeyword
             self ?= decl.optionalMark
-            self ?= decl.genericParameterClause
-            self += decl.signature
+            self.encode(decl.genericParameterClause?.trimmed)
+            self.encode(decl.signature)
         }
         else if
             let decl:MacroDeclSyntax = decl.as(MacroDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.macroKeyword
             self[at: .toplevel] += decl.name
-            self ?= decl.genericParameterClause
-            self += decl.signature
+            self.encode(decl.genericParameterClause?.trimmed)
+            self.encode(decl.signature)
         }
         else if
             let decl:SubscriptDeclSyntax = decl.as(SubscriptDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self[at: .toplevel] += decl.subscriptKeyword
-            self ?= decl.genericParameterClause
+            self.encode(decl.genericParameterClause?.trimmed)
             self += (decl.parameterClause, func: false)
             self ?= decl.returnClause.trimmed
         }
         else if
             let decl:TypeAliasDeclSyntax = decl.as(TypeAliasDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.typealiasKeyword
             self[at: .toplevel] += decl.name.trimmed
-            self ?= decl.genericParameterClause?.trimmed
+            self.encode(decl.genericParameterClause?.trimmed)
         }
         else if
             let decl:VariableDeclSyntax = decl.as(VariableDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.bindingSpecifier
             for binding:PatternBindingSyntax in decl.bindings
             {
@@ -336,7 +336,7 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>
         else if
             let decl:EnumCaseDeclSyntax = decl.as(EnumCaseDeclSyntax.self)
         {
-            self += decl.modifiers
+            self.encode(decl.modifiers)
             self += decl.caseKeyword
             for element:EnumCaseElementSyntax in decl.elements
             {
@@ -347,7 +347,7 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>
                     self += payload.leftParen
                     for parameter:EnumCaseParameterSyntax in payload.parameters
                     {
-                        self += parameter.modifiers
+                        self.encode(parameter.modifiers)
                         if  let label:TokenSyntax = parameter.firstName,
                                 label.tokenKind != .wildcard
                         {
@@ -368,8 +368,8 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>
         }
     }
 
-    static
-    func += (self:inout Self, function:FunctionSignatureSyntax)
+    private mutating
+    func encode(_ function:FunctionSignatureSyntax)
     {
         if  let returns:ReturnClauseSyntax = function.returnClause
         {
@@ -389,8 +389,8 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>
         }
     }
 
-    static
-    func += (self:inout Self, modifiers:DeclModifierListSyntax)
+    private mutating
+    func encode(_ modifiers:DeclModifierListSyntax)
     {
         for modifier:DeclModifierSyntax in modifiers
         {
@@ -409,14 +409,16 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>
         }
     }
 
-    static
-    func ?= (self:inout Self, clause:GenericParameterClauseSyntax?)
-    {
-        clause.map { self += $0 }
-    }
-    static
-    func += (self:inout Self, clause:GenericParameterClauseSyntax)
+    private mutating
+    func encode(_ clause:GenericParameterClauseSyntax?)
     {
+        guard
+        let clause:GenericParameterClauseSyntax
+        else
+        {
+            return
+        }
+
         self += clause.leftAngle
         for parameter:GenericParameterSyntax in clause.parameters
         {
diff --git a/Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.swift b/Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.swift
@@ -87,7 +87,7 @@ extension SignatureSyntax
         var encoder:Encoder<AbridgedParameter> = .init()
         var parser:Parser = .init(utf8)
 
-        encoder += DeclSyntax.parse(from: &parser)
+        encoder.encode(decl: .parse(from: &parser))
 
         return .init(elements: encoder.move())
     }
@@ -97,7 +97,7 @@ extension SignatureSyntax
         var encoder:Encoder<ExpandedParameter> = .init()
         var parser:Parser = .init(utf8)
 
-        encoder += DeclSyntax.parse(from: &parser)
+        encoder.encode(decl: .parse(from: &parser))
 
         return .init(elements: encoder.move())
     }

Original file line number	Diff line number	Diff line change
`@@ -125,8 +125,8 @@ extension SignatureSyntax.Encoder`
`125`	`125`
`126`	`126`	`extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>`
`127`	`127`	`{`
`128`		`- static`
`129`		`- func += (self:inout Self, decl:DeclSyntax)`
	`128`	`+ mutating`
	`129`	`+ func encode(decl:DeclSyntax)`
`130`	`130`	`{`
`131`	`131`	`for region:Syntax in decl.children(viewMode: .sourceAccurate)`
`132`	`132`	`{`
`@@ -150,7 +150,7 @@ extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>`
`150`	`150`	`let clause:GenericParameterClauseSyntax =`
`151`	`151`	`region.as(GenericParameterClauseSyntax.self)`
`152`	`152`	`{`
`153`		`- self += clause`
	`153`	`+ self.encode(clause)`
`154`	`154`	`}`
`155`	`155`	`else if`
`156`	`156`	`let region:FunctionSignatureSyntax = region.as(FunctionSignatureSyntax.self)`
`@@ -187,8 +187,8 @@ extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>`
`187`	`187`	`}`
`188`	`188`	`}`
`189`	`189`
`190`		`- static`
`191`		`- func += (self:inout Self, clause:GenericParameterClauseSyntax)`
	`190`	`+ private mutating`
	`191`	`+ func encode(_ clause:GenericParameterClauseSyntax)`
`192`	`192`	`{`
`193`	`193`	`for region:Syntax in clause.children(viewMode: .sourceAccurate)`
`194`	`194`	`{`
`@@ -221,110 +221,110 @@ extension SignatureSyntax.Encoder<SignatureSyntax.ExpandedParameter>`
`221`	`221`
`222`	`222`	`extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>`
`223`	`223`	`{`
`224`		`- static`
`225`		`- func += (self:inout Self, decl:DeclSyntax)`
	`224`	`+ mutating`
	`225`	`+ func encode(decl:DeclSyntax)`
`226`	`226`	`{`
`227`	`227`	`if let decl:ActorDeclSyntax = decl.as(ActorDeclSyntax.self)`
`228`	`228`	`{`
`229`		`- self += decl.modifiers`
	`229`	`+ self.encode(decl.modifiers)`
`230`	`230`	`self += decl.actorKeyword`
`231`	`231`	`self[at: .toplevel] += decl.name.trimmed`
`232`		`- self ?= decl.genericParameterClause?.trimmed`
	`232`	`+ self.encode(decl.genericParameterClause?.trimmed)`
`233`	`233`	`}`
`234`	`234`	`else if`
`235`	`235`	`let decl:AssociatedTypeDeclSyntax = decl.as(AssociatedTypeDeclSyntax.self)`
`236`	`236`	`{`
`237`		`- self += decl.modifiers`
	`237`	`+ self.encode(decl.modifiers)`
`238`	`238`	`self += decl.associatedtypeKeyword`
`239`	`239`	`self[at: .toplevel] += decl.name.trimmed`
`240`	`240`	`}`
`241`	`241`	`else if`
`242`	`242`	`let decl:ClassDeclSyntax = decl.as(ClassDeclSyntax.self)`
`243`	`243`	`{`
`244`		`- self += decl.modifiers`
	`244`	`+ self.encode(decl.modifiers)`
`245`	`245`	`self += decl.classKeyword`
`246`	`246`	`self[at: .toplevel] += decl.name.trimmed`
`247`		`- self ?= decl.genericParameterClause?.trimmed`
	`247`	`+ self.encode(decl.genericParameterClause?.trimmed)`
`248`	`248`	`}`
`249`	`249`	`else if`
`250`	`250`	`let decl:EnumDeclSyntax = decl.as(EnumDeclSyntax.self)`
`251`	`251`	`{`
`252`		`- self += decl.modifiers`
	`252`	`+ self.encode(decl.modifiers)`
`253`	`253`	`self += decl.enumKeyword`
`254`	`254`	`self[at: .toplevel] += decl.name.trimmed`
`255`		`- self ?= decl.genericParameterClause?.trimmed`
	`255`	`+ self.encode(decl.genericParameterClause?.trimmed)`
`256`	`256`	`}`
`257`	`257`	`else if`
`258`	`258`	`let decl:ProtocolDeclSyntax = decl.as(ProtocolDeclSyntax.self)`
`259`	`259`	`{`
`260`		`- self += decl.modifiers`
	`260`	`+ self.encode(decl.modifiers)`
`261`	`261`	`self += decl.protocolKeyword`
`262`	`262`	`self[at: .toplevel] += decl.name.trimmed`
`263`	`263`	`self ?= decl.primaryAssociatedTypeClause?.trimmed`
`264`	`264`	`}`
`265`	`265`	`else if`
`266`	`266`	`let decl:StructDeclSyntax = decl.as(StructDeclSyntax.self)`
`267`	`267`	`{`
`268`		`- self += decl.modifiers`
	`268`	`+ self.encode(decl.modifiers)`
`269`	`269`	`self += decl.structKeyword`
`270`	`270`	`self[at: .toplevel] += decl.name.trimmed`
`271`		`- self ?= decl.genericParameterClause?.trimmed`
	`271`	`+ self.encode(decl.genericParameterClause?.trimmed)`
`272`	`272`	`}`
`273`	`273`	`else if`
`274`	`274`	`let decl:DeinitializerDeclSyntax = decl.as(DeinitializerDeclSyntax.self)`
`275`	`275`	`{`
`276`		`- self += decl.modifiers`
	`276`	`+ self.encode(decl.modifiers)`
`277`	`277`	`self[at: .toplevel] += decl.deinitKeyword`
`278`	`278`	`self ?= decl.effectSpecifiers?.trimmed`
`279`	`279`	`}`
`280`	`280`	`else if`
`281`	`281`	`let decl:FunctionDeclSyntax = decl.as(FunctionDeclSyntax.self)`
`282`	`282`	`{`
`283`		`- self += decl.modifiers`
	`283`	`+ self.encode(decl.modifiers)`
`284`	`284`	`self += decl.funcKeyword`
`285`	`285`	`self[at: .toplevel] += decl.name`
`286`		`- self ?= decl.genericParameterClause`
`287`		`- self += decl.signature`
	`286`	`+ self.encode(decl.genericParameterClause?.trimmed)`
	`287`	`+ self.encode(decl.signature)`
`288`	`288`	`}`
`289`	`289`	`else if`
`290`	`290`	`let decl:InitializerDeclSyntax = decl.as(InitializerDeclSyntax.self)`
`291`	`291`	`{`
`292`		`- self += decl.modifiers`
	`292`	`+ self.encode(decl.modifiers)`
`293`	`293`	`self[at: .toplevel] += decl.initKeyword`
`294`	`294`	`self ?= decl.optionalMark`
`295`		`- self ?= decl.genericParameterClause`
`296`		`- self += decl.signature`
	`295`	`+ self.encode(decl.genericParameterClause?.trimmed)`
	`296`	`+ self.encode(decl.signature)`
`297`	`297`	`}`
`298`	`298`	`else if`
`299`	`299`	`let decl:MacroDeclSyntax = decl.as(MacroDeclSyntax.self)`
`300`	`300`	`{`
`301`		`- self += decl.modifiers`
	`301`	`+ self.encode(decl.modifiers)`
`302`	`302`	`self += decl.macroKeyword`
`303`	`303`	`self[at: .toplevel] += decl.name`
`304`		`- self ?= decl.genericParameterClause`
`305`		`- self += decl.signature`
	`304`	`+ self.encode(decl.genericParameterClause?.trimmed)`
	`305`	`+ self.encode(decl.signature)`
`306`	`306`	`}`
`307`	`307`	`else if`
`308`	`308`	`let decl:SubscriptDeclSyntax = decl.as(SubscriptDeclSyntax.self)`
`309`	`309`	`{`
`310`		`- self += decl.modifiers`
	`310`	`+ self.encode(decl.modifiers)`
`311`	`311`	`self[at: .toplevel] += decl.subscriptKeyword`
`312`		`- self ?= decl.genericParameterClause`
	`312`	`+ self.encode(decl.genericParameterClause?.trimmed)`
`313`	`313`	`self += (decl.parameterClause, func: false)`
`314`	`314`	`self ?= decl.returnClause.trimmed`
`315`	`315`	`}`
`316`	`316`	`else if`
`317`	`317`	`let decl:TypeAliasDeclSyntax = decl.as(TypeAliasDeclSyntax.self)`
`318`	`318`	`{`
`319`		`- self += decl.modifiers`
	`319`	`+ self.encode(decl.modifiers)`
`320`	`320`	`self += decl.typealiasKeyword`
`321`	`321`	`self[at: .toplevel] += decl.name.trimmed`
`322`		`- self ?= decl.genericParameterClause?.trimmed`
	`322`	`+ self.encode(decl.genericParameterClause?.trimmed)`
`323`	`323`	`}`
`324`	`324`	`else if`
`325`	`325`	`let decl:VariableDeclSyntax = decl.as(VariableDeclSyntax.self)`
`326`	`326`	`{`
`327`		`- self += decl.modifiers`
	`327`	`+ self.encode(decl.modifiers)`
`328`	`328`	`self += decl.bindingSpecifier`
`329`	`329`	`for binding:PatternBindingSyntax in decl.bindings`
`330`	`330`	`{`
`@@ -336,7 +336,7 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>`
`336`	`336`	`else if`
`337`	`337`	`let decl:EnumCaseDeclSyntax = decl.as(EnumCaseDeclSyntax.self)`
`338`	`338`	`{`
`339`		`- self += decl.modifiers`
	`339`	`+ self.encode(decl.modifiers)`
`340`	`340`	`self += decl.caseKeyword`
`341`	`341`	`for element:EnumCaseElementSyntax in decl.elements`
`342`	`342`	`{`
`@@ -347,7 +347,7 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>`
`347`	`347`	`self += payload.leftParen`
`348`	`348`	`for parameter:EnumCaseParameterSyntax in payload.parameters`
`349`	`349`	`{`
`350`		`- self += parameter.modifiers`
	`350`	`+ self.encode(parameter.modifiers)`
`351`	`351`	`if let label:TokenSyntax = parameter.firstName,`
`352`	`352`	`label.tokenKind != .wildcard`
`353`	`353`	`{`
`@@ -368,8 +368,8 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>`
`368`	`368`	`}`
`369`	`369`	`}`
`370`	`370`
`371`		`- static`
`372`		`- func += (self:inout Self, function:FunctionSignatureSyntax)`
	`371`	`+ private mutating`
	`372`	`+ func encode(_ function:FunctionSignatureSyntax)`
`373`	`373`	`{`
`374`	`374`	`if let returns:ReturnClauseSyntax = function.returnClause`
`375`	`375`	`{`
`@@ -389,8 +389,8 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>`
`389`	`389`	`}`
`390`	`390`	`}`
`391`	`391`
`392`		`- static`
`393`		`- func += (self:inout Self, modifiers:DeclModifierListSyntax)`
	`392`	`+ private mutating`
	`393`	`+ func encode(_ modifiers:DeclModifierListSyntax)`
`394`	`394`	`{`
`395`	`395`	`for modifier:DeclModifierSyntax in modifiers`
`396`	`396`	`{`
`@@ -409,14 +409,16 @@ extension SignatureSyntax.Encoder<SignatureSyntax.AbridgedParameter>`
`409`	`409`	`}`
`410`	`410`	`}`
`411`	`411`
`412`		`- static`
`413`		`- func ?= (self:inout Self, clause:GenericParameterClauseSyntax?)`
`414`		`- {`
`415`		`- clause.map { self += $0 }`
`416`		`- }`
`417`		`- static`
`418`		`- func += (self:inout Self, clause:GenericParameterClauseSyntax)`
	`412`	`+ private mutating`
	`413`	`+ func encode(_ clause:GenericParameterClauseSyntax?)`
`419`	`414`	`{`
	`415`	`+ guard`
	`416`	`+ let clause:GenericParameterClauseSyntax`
	`417`	`+ else`
	`418`	`+ {`
	`419`	`+ return`
	`420`	`+ }`
	`421`	`+`
`420`	`422`	`self += clause.leftAngle`
`421`	`423`	`for parameter:GenericParameterSyntax in clause.parameters`
`422`	`424`	`{`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ extension SignatureSyntax`
`87`	`87`	`var encoder:Encoder<AbridgedParameter> = .init()`
`88`	`88`	`var parser:Parser = .init(utf8)`
`89`	`89`
`90`		`- encoder += DeclSyntax.parse(from: &parser)`
	`90`	`+ encoder.encode(decl: .parse(from: &parser))`
`91`	`91`
`92`	`92`	`return .init(elements: encoder.move())`
`93`	`93`	`}`
`@@ -97,7 +97,7 @@ extension SignatureSyntax`
`97`	`97`	`var encoder:Encoder<ExpandedParameter> = .init()`
`98`	`98`	`var parser:Parser = .init(utf8)`
`99`	`99`
`100`		`- encoder += DeclSyntax.parse(from: &parser)`
	`100`	`+ encoder.encode(decl: .parse(from: &parser))`
`101`	`101`
`102`	`102`	`return .init(elements: encoder.move())`
`103`	`103`	`}`