Merge pull request #380 from tayloraswift/disambiguate-existentials

Disambiguate existentials, parameter packs, `some` types, variadics, and `~Copyable` types

Author: tayloraswift

Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.Autographer.swift

@@ -20,13 +20,39 @@ extension SignatureSyntax
 }
 extension SignatureSyntax.Autographer
 {
+    mutating
+    func encode(parameter:FunctionParameterSyntax)
+    {
+        self.encode(type: parameter.type)
+
+        if  case _? = parameter.ellipsis
+        {
+            self.autograph.append("...")
+        }
+    }
+
     mutating
     func encode(type:TypeSyntax)
     {
         if  let type:AttributedTypeSyntax = type.as(AttributedTypeSyntax.self)
         {
             self.encode(type: type.baseType)
         }
+        else if
+            let type:SomeOrAnyTypeSyntax = type.as(SomeOrAnyTypeSyntax.self)
+        {
+            self.encode(type: type.constraint)
+        }
+        else if
+            let type:PackElementTypeSyntax = type.as(PackElementTypeSyntax.self)
+        {
+            self.encode(type: type.pack)
+        }
+        else if
+            let type:PackExpansionTypeSyntax = type.as(PackExpansionTypeSyntax.self)
+        {
+            self.encode(type: type.repetitionPattern)
+        }
         else if
             let type:IdentifierTypeSyntax = type.as(IdentifierTypeSyntax.self)
         {
@@ -74,6 +100,12 @@ extension SignatureSyntax.Autographer
             self.encode(type: type.baseType)
             self.autograph.append(".Type")
         }
+        else if
+            let suppressed:SuppressedTypeSyntax = type.as(SuppressedTypeSyntax.self)
+        {
+            self.autograph.append("~")
+            self.encode(type: suppressed.type)
+        }
         else if
             let type:TupleTypeSyntax = type.as(TupleTypeSyntax.self)
         {
@@ -85,6 +117,8 @@ extension SignatureSyntax.Autographer
 
             self.autograph.append("(")
 
+            /// We don’t rely on the existence of the trailing comma in the syntax tree, because
+            /// Swift now allows trailing commas in many places, and we want to normalize them.
             var first:Bool = true
             for element:TupleTypeElementSyntax in type.elements
             {
@@ -124,6 +158,24 @@ extension SignatureSyntax.Autographer
             self.autograph.append(")->")
             self.encode(type: function.returnClause.type)
         }
+        else if
+            let type:CompositionTypeSyntax = type.as(CompositionTypeSyntax.self)
+        {
+            var first:Bool = true
+            for element:CompositionTypeElementSyntax in type.elements
+            {
+                if  first
+                {
+                    first = false
+                }
+                else
+                {
+                    self.autograph.append("&")
+                }
+
+                self.encode(type: element.type)
+            }
+        }
         else
         {
             self.autograph.append("_")

Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.ExpandedVisitor.swift

@@ -29,7 +29,7 @@ extension SignatureSyntax.ExpandedVisitor:SignatureVisitor
         type _:SignatureParameterType) -> SignatureSyntax.ExpandedParameter
     {
         var autographer:SignatureSyntax.Autographer = .init(sugaring: self.sugarMap)
-        autographer.encode(type: parameter.type)
+        autographer.encode(parameter: parameter)
         inputs.append(autographer.autograph)
         return .init(syntax: parameter)
     }

Sources/MarkdownPluginSwiftTests/Autographs.swift

@@ -57,7 +57,7 @@ struct Autographs
         let decl:String = "subscript(a: some Equatable, b: [Float: Bool]!) -> (String)?"
         let _:Signature<Never>.Expanded = .init(decl, landmarks: &self.landmarks)
 
-        #expect(self.landmarks.inputs == ["_", "[Float:Bool]!"])
+        #expect(self.landmarks.inputs == ["Equatable", "[Float:Bool]!"])
         #expect(self.landmarks.output == ["String?"])
     }
 
@@ -85,6 +85,89 @@ struct Autographs
         #expect(self.landmarks.output == ["(Int)->(Int)->Int"])
     }
 
+    @Test mutating
+    func SomeAndAnyTypes()
+    {
+        let decl:String = """
+        func f(
+            a: any Error,
+            b: some Error & CustomStringConvertible,
+            c: [some RandomAccessCollection<UInt8> & MutableCollection<UInt8>].Type)
+        """
+        let _:Signature<Never>.Expanded = .init(decl, landmarks: &self.landmarks)
+
+        #expect(self.landmarks.inputs == [
+                "Error",
+                "Error&CustomStringConvertible",
+                "[RandomAccessCollection<UInt8>&MutableCollection<UInt8>].Type"
+            ])
+        #expect(self.landmarks.output == [])
+    }
+
+    /// Note that as of Swift 6.0, it is currently illegal to include primary associated types
+    /// in an existential protocol composition type, although this is allowed for `some` types.
+    @Test mutating
+    func ProtocolCompositions()
+    {
+        let decl:String = """
+        func f(
+            a: any Error,
+            b: any Error & CustomStringConvertible,
+            c: any RandomAccessCollection & MutableCollection)
+        """
+        let _:Signature<Never>.Expanded = .init(decl, landmarks: &self.landmarks)
+
+        #expect(self.landmarks.inputs == [
+                "Error",
+                "Error&CustomStringConvertible",
+                "RandomAccessCollection&MutableCollection"
+            ])
+        #expect(self.landmarks.output == [])
+    }
+
+    @Test mutating
+    func Variadics()
+    {
+        let decl:String = """
+        func f(
+            a: String...,
+            b: [String]...,
+            c: Set<Int>...)
+        """
+        let _:Signature<Never>.Expanded = .init(decl, landmarks: &self.landmarks)
+
+        #expect(self.landmarks.inputs == [
+                "String...",
+                "[String]...",
+                "Set<Int>..."
+            ])
+        #expect(self.landmarks.output == [])
+    }
+
+    @Test mutating
+    func Packs()
+    {
+        let decl:String = """
+        func f<each T>(x: repeat [each T])
+        """
+        let _:Signature<Never>.Expanded = .init(decl, landmarks: &self.landmarks)
+
+        #expect(self.landmarks.inputs == ["[T]"])
+        #expect(self.landmarks.output == [])
+    }
+
+    @Test mutating
+    func Noncopyable()
+    {
+        let decl:String = """
+        func f(a: borrowing some ~Copyable)
+        """
+        let _:Signature<Never>.Expanded = .init(decl, landmarks: &self.landmarks)
+
+        #expect(self.landmarks.inputs == ["~Copyable"])
+        #expect(self.landmarks.output == [])
+    }
+
     @Test mutating
     func Resugaring()
     {

Sources/UCF/Codelinks/Grammar/UCF.NominalPatternRule.swift

@@ -7,7 +7,6 @@ extension UCF
     {
         typealias Location = String.Index
         typealias Terminal = Unicode.Scalar
-
         typealias Construction = [(Range<Location>, [UCF.TypePattern])]
 
         static func parse<Diagnostics>(

Sources/UCF/Codelinks/Grammar/UCF.TypeElement.swift

@@ -0,0 +1,9 @@
+extension UCF
+{
+    struct TypeElement
+    {
+        let prefix:TypeSigil?
+        let operand:TypeOperand
+        let suffix:[TypeOperator]
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.TypeElementRule.PostfixMetatype.swift

@@ -0,0 +1,10 @@
+import Grammar
+
+extension UCF.TypeElementRule
+{
+    enum PostfixMetatype:LiteralRule
+    {
+        typealias Location = String.Index
+        static var literal:[Unicode.Scalar] { ["T","y","p","e"] }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.TypePatternRule.PostfixOperator.swift renamed to Sources/UCF/Codelinks/Grammar/UCF.TypeElementRule.PostfixOperator.swift

@@ -1,8 +1,8 @@
 import Grammar
 
-extension UCF.TypePatternRule
+extension UCF.TypeElementRule
 {
-    /// PostfixOperator ::= '?' | '!' | '.Type'
+    /// PostfixOperator ::= '?' | '!' | '.Type' | '...'
     enum PostfixOperator:ParsingRule
     {
         typealias Location = String.Index
@@ -18,15 +18,18 @@ extension UCF.TypePatternRule
             {
                 return codepoint
             }
+
+            try input.parse(as: UnicodeEncoding<Location, Terminal>.Period.self)
+
+            if  case ()? = input.parse(as: PostfixMetatype?.self)
+            {
+                return .metatype
+            }
             else
             {
                 try input.parse(as: UnicodeEncoding<Location, Terminal>.Period.self)
-                try input.parse(as: UnicodeEncoding<Location, Terminal>.UppercaseT.self)
-                try input.parse(as: UnicodeEncoding<Location, Terminal>.LowercaseY.self)
-                try input.parse(as: UnicodeEncoding<Location, Terminal>.LowercaseP.self)
-                try input.parse(as: UnicodeEncoding<Location, Terminal>.LowercaseE.self)
-
-                return .metatype
+                try input.parse(as: UnicodeEncoding<Location, Terminal>.Period.self)
+                return .ellipsis
             }
         }
     }

Sources/UCF/Codelinks/Grammar/UCF.TypePatternRule.PostfixOperatorCodepoint.swift renamed to Sources/UCF/Codelinks/Grammar/UCF.TypeElementRule.PostfixOperatorCodepoint.swift

@@ -1,6 +1,6 @@
 import Grammar
 
-extension UCF.TypePatternRule
+extension UCF.TypeElementRule
 {
     enum PostfixOperatorCodepoint:TerminalRule
     {

Sources/UCF/Codelinks/Grammar/UCF.TypeElementRule.swift

@@ -0,0 +1,42 @@
+import Grammar
+
+extension UCF
+{
+    /// TypeElement ::= '~' ? TypeOperand PostfixOperator *
+    enum TypeElementRule:ParsingRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+
+        static func parse<Source>(
+            _ input:inout ParsingInput<some ParsingDiagnostics<Source>>) throws -> TypeElement
+            where Source:Collection<Terminal>, Source.Index == Location
+        {
+            let sigil:TypeSigil?
+            if  case ()? = input.parse(as: UnicodeEncoding<Location, Terminal>.Tilde?.self)
+            {
+                sigil = .tilde
+            }
+            else
+            {
+                sigil = nil
+            }
+
+            let operand:TypeOperand = try input.parse(as: TypeOperandRule.self)
+            let suffix:[TypeOperator] = input.parse(as: PostfixOperator.self, in: [_].self)
+
+            if  suffix.isEmpty,
+                case nil = sigil,
+                case .single(let parenthesized?) = operand,
+                let inhabitant:TypeElement = parenthesized.inhabitant
+            {
+                //  If this is a bare parenthesized operand with no operators, unwrap it.
+                return inhabitant
+            }
+            else
+            {
+                return .init(prefix: sigil, operand: operand, suffix: suffix)
+            }
+        }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.TypePatternRule.PostfixOperand.swift renamed to Sources/UCF/Codelinks/Grammar/UCF.TypeOperandRule.swift

@@ -1,23 +1,23 @@
 import Grammar
 
-extension UCF.TypePatternRule
+extension UCF
 {
-    /// PostfixOperand ::= NominalPattern | BracketPattern | FunctionPattern
-    enum PostfixOperand:ParsingRule
+    /// TypeOperand ::= NominalPattern | BracketPattern | FunctionPattern
+    enum TypeOperandRule:ParsingRule
     {
         typealias Location = String.Index
         typealias Terminal = Unicode.Scalar
 
         static func parse<Diagnostics>(
-            _ input:inout ParsingInput<Diagnostics>) throws -> UCF.TypeOperand where
+            _ input:inout ParsingInput<Diagnostics>) throws -> TypeOperand where
             Diagnostics:ParsingDiagnostics,
             Diagnostics.Source.Element == Terminal,
             Diagnostics.Source.Index == Location
         {
-            if  let path:[(Range<Location>, [UCF.TypePattern])] = input.parse(
-                    as: UCF.NominalPatternRule?.self)
+            if  let path:[(Range<Location>, [TypePattern])] = input.parse(
+                    as: NominalPatternRule?.self)
             {
-                if  let (range, generics):(Range<Location>, [UCF.TypePattern]) = path.first,
+                if  let (range, generics):(Range<Location>, [TypePattern]) = path.first,
                     generics.isEmpty,
                     path.count == 1,
                     input.source.index(after: range.lowerBound) == range.upperBound,
@@ -29,16 +29,16 @@ extension UCF.TypePatternRule
                 return .nominal(path)
             }
             else if
-                let (first, value):(UCF.TypePattern, UCF.TypePattern?) = input.parse(
-                    as: UCF.BracketPatternRule?.self)
+                let (first, value):(TypePattern, TypePattern?) = input.parse(
+                    as: BracketPatternRule?.self)
             {
                 return .bracket(first, value)
             }
 
-            switch try input.parse(as: UCF.FunctionPatternRule.self)
+            switch try input.parse(as: FunctionPatternRule.self)
             {
             case (let tuple, nil):
-                if  let first:UCF.TypePattern = tuple.first, tuple.count == 1
+                if  let first:TypePattern = tuple.first, tuple.count == 1
                 {
                     return .single(first)
                 }