Another Grab Bag of Parser Fixes

Sources/SwiftParser/Attributes.swift

@@ -14,7 +14,7 @@
 
 extension Parser {
   mutating func parseAttributeList() -> RawAttributeListSyntax? {
-    guard self.at(.atSign) else {
+    guard self.at(any: [.atSign, .poundIfKeyword]) else {
       return nil
     }
 
@@ -23,20 +23,30 @@ extension Parser {
     repeat {
       let attribute = self.parseAttribute()
       elements.append(attribute)
-    } while self.at(.atSign) && loopProgress.evaluate(currentToken)
+    } while self.at(any: [.atSign, .poundIfKeyword]) && loopProgress.evaluate(currentToken)
     return RawAttributeListSyntax(elements: elements, arena: self.arena)
   }
 }
 
 extension Parser {
   mutating func parseAttribute() -> RawSyntax {
+    if self.at(.poundIfKeyword) {
+      return RawSyntax(self.parsePoundIfDirective { parser -> RawSyntax in
+        return parser.parseAttribute()
+      } syntax: { parser, attributes in
+        return RawSyntax(RawAttributeListSyntax(elements: attributes, arena: parser.arena))
+      })
+    }
+
     guard let declAttr = DeclarationAttribute(rawValue: self.peek().tokenText) else {
       return RawSyntax(self.parseCustomAttribute())
     }
 
     switch declAttr {
     case .available:
       return RawSyntax(self.parseAvailabilityAttribute())
+    case ._spi_available:
+      return RawSyntax(self.parseSPIAvailableAttribute())
     case .differentiable:
       return RawSyntax(self.parseDifferentiableAttribute())
     case .derivative:
@@ -152,6 +162,37 @@ extension Parser {
       tokenList: nil,
       arena: self.arena)
   }
+
+  mutating func parseSPIAvailableAttribute() -> RawAttributeSyntax {
+    let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
+    let (unexpectedBeforeAvailable, available) = self.expectContextualKeyword("_spi_available")
+    let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
+
+    let argument: RawSyntax
+    do {
+      if self.peek().tokenKind == .integerLiteral {
+        argument = RawSyntax(self.parseAvailabilitySpecList(from: .available))
+      } else if self.peek().tokenKind  == .floatingLiteral {
+        argument = RawSyntax(self.parseAvailabilitySpecList(from: .available))
+      } else {
+        argument = RawSyntax(self.parseExtendedAvailabilitySpecList())
+      }
+    }
+    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
+
+    return RawAttributeSyntax(
+      unexpectedBeforeAtSign,
+      atSignToken: atSign,
+      unexpectedBeforeAvailable,
+      attributeName: available,
+      unexpectedBeforeLeftParen,
+      leftParen: leftParen,
+      argument: argument,
+      unexpectedBeforeRightParen,
+      rightParen: rightParen,
+      tokenList: nil,
+      arena: self.arena)
+  }
 }
 
 extension Parser {
@@ -508,13 +549,13 @@ extension Parser {
         let ident = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let availability = self.parseAvailabilitySpecList(from: .available)
-        // FIXME: This is modeled incorrectly in libSyntax.
-        let semi = RawTokenSyntax(missing: .semicolon, arena: self.arena)
+        let (unexpectedBeforeSemi, semi) = self.expect(.semicolon)
         elements.append(RawSyntax(RawAvailabilityEntrySyntax(
           label: ident,
           unexpectedBeforeColon,
           colon: colon,
           availabilityList: availability,
+          unexpectedBeforeSemi,
           semicolon: semi,
           arena: self.arena
         )))
@@ -761,6 +802,54 @@ extension Parser {
   }
 }
 
+extension Parser {
+  mutating func parseConventionArguments() -> RawSyntax {
+    if let witnessMethod = self.consumeIfContextualKeyword("witness_method") {
+      let (unexpectedBeforeColon, colon) = self.expect(.colon)
+      let name = self.parseAnyIdentifier()
+      return RawSyntax(RawConventionWitnessMethodAttributeArgumentsSyntax(
+        witnessMethodLabel: witnessMethod,
+        unexpectedBeforeColon,
+        colon: colon,
+        protocolName: name,
+        arena: self.arena))
+    } else {
+      let label = self.consumeAnyToken()
+      let unexpectedBeforeComma: RawUnexpectedNodesSyntax?
+      let comma: RawTokenSyntax?
+      let cTypeLabel: RawTokenSyntax?
+      let unexpectedBeforeColon: RawUnexpectedNodesSyntax?
+      let colon: RawTokenSyntax?
+      let unexpectedBeforeCTypeString: RawUnexpectedNodesSyntax?
+      let cTypeString: RawTokenSyntax?
+      if self.at(.comma) {
+        (unexpectedBeforeComma, comma) = self.expect(.comma)
+        cTypeLabel = self.consumeAnyToken()
+        (unexpectedBeforeColon, colon) = self.expect(.colon)
+        (unexpectedBeforeCTypeString, cTypeString) = self.expect(.stringLiteral)
+      } else {
+        unexpectedBeforeComma = nil
+        comma = nil
+        cTypeLabel = nil
+        unexpectedBeforeColon = nil
+        colon = nil
+        unexpectedBeforeCTypeString = nil
+        cTypeString = nil
+      }
+      return RawSyntax(RawConventionAttributeArgumentsSyntax(
+        conventionLabel: label,
+        unexpectedBeforeComma,
+        comma: comma,
+        cTypeLabel: cTypeLabel,
+        unexpectedBeforeColon,
+        colon: colon,
+        unexpectedBeforeCTypeString,
+        cTypeString: cTypeString,
+        arena: self.arena))
+    }
+  }
+}
+
 // MARK: Lookahead
 
 extension Parser.Lookahead {

Sources/SwiftParser/Availability.swift

@@ -139,7 +139,11 @@ extension Parser {
         case nil:
           // Not sure what this label is but, let's just eat it and
           // keep going.
-          entry = RawSyntax(self.consumeAnyToken())
+          var tokens = [RawTokenSyntax]()
+          while !self.at(any: [.eof, .comma, .rightParen]) {
+            tokens.append(self.consumeAnyToken())
+          }
+          entry = RawSyntax(RawNonEmptyTokenListSyntax(elements: tokens, arena: self.arena))
         }
 
         keepGoing = self.consume(if: .comma)

Sources/SwiftParser/DeclarationAttribute.swift.gyb

@@ -25,5 +25,6 @@ extension Parser {
 % for attr in DECL_ATTR_KINDS:
     case ${attr.swift_name} = "${attr.name}"
 % end
+    case _spi_available = "_spi_available"
   }
 }

Sources/SwiftParser/Declarations.swift

@@ -47,6 +47,11 @@ extension TokenConsumer {
       }
     }
 
+    if subparser.at(.poundIfKeyword) {
+      var attrLookahead = subparser.lookahead()
+      return attrLookahead.consumeIfConfigOfAttributes()
+    }
+
     let declStartKeyword: DeclarationStart?
     if allowRecovery {
       declStartKeyword = subparser.canRecoverTo(
@@ -507,7 +512,13 @@ extension Parser {
     do {
       var loopProgress = LoopProgressCondition()
       while !self.at(any: [.eof, .rightBrace]) && loopProgress.evaluate(currentToken) {
-        let decl = self.parseDeclaration()
+        let decl: RawDeclSyntax
+        if self.at(.poundSourceLocationKeyword) {
+          decl = RawDeclSyntax(self.parsePoundSourceLocationDirective())
+        } else {
+          decl = self.parseDeclaration()
+        }
+
         let semi = self.consume(if: .semicolon)
         elements.append(RawMemberDeclListItemSyntax(
           decl: decl, semicolon: semi, arena: self.arena))
@@ -1876,10 +1887,22 @@ extension Parser {
     // checking.
     let precedenceAndTypes: RawOperatorPrecedenceAndTypesSyntax?
     if let colon = self.consume(if: .colon) {
-      let identifier = self.expectIdentifierWithoutRecovery()
+      let (unexpectedBeforeIdentifier, identifier) = self.expectIdentifier()
+      var types = [RawDesignatedTypeElementSyntax]()
+      while let comma = self.consume(if: .comma) {
+        let (unexpectedBeforeDesignatedType, designatedType) = self.expectIdentifier()
+        types.append(RawDesignatedTypeElementSyntax(
+          leadingComma: comma,
+          unexpectedBeforeDesignatedType,
+          name: designatedType,
+          arena: self.arena))
+      }
       precedenceAndTypes = RawOperatorPrecedenceAndTypesSyntax(
         colon: colon,
-        precedenceGroupAndDesignatedTypes: RawIdentifierListSyntax(elements: [ identifier ], arena: self.arena),
+        unexpectedBeforeIdentifier,
+        precedenceGroup: identifier,
+        designatedTypes: RawDesignatedTypeListSyntax(
+          elements: types, arena: self.arena),
         arena: self.arena)
     } else {
       precedenceAndTypes = nil

Sources/SwiftParser/Lookahead.swift

@@ -197,6 +197,44 @@ extension Parser.Lookahead {
     }
     return true
   }
+
+  mutating func consumeIfConfigOfAttributes() -> Bool {
+    while true {
+      // #if / #else / #elseif
+      self.consumeAnyToken()
+
+      // <expression>
+      self.skipUntilEndOfLine()
+
+      while true {
+        if self.at(.atSign) {
+          _ = self.consumeAttributeList()
+          continue
+        }
+
+        if self.at(.poundIfKeyword) {
+          _ = self.consumeIfConfigOfAttributes()
+          continue
+        }
+
+        break
+      }
+
+      guard self.at(any: [ .poundElseifKeyword, .poundElseKeyword ]) else {
+        break
+      }
+    }
+
+    // If we ran out of tokens, say we consumed the rest.
+    if self.at(.eof) {
+      return true
+    }
+
+    guard self.currentToken.isAtStartOfLine else {
+      return false
+    }
+    return self.consume(if: .poundEndifKeyword) != nil
+  }
 }
 
 // MARK: Lookahead

Sources/SwiftParser/Types.swift

@@ -803,7 +803,7 @@ extension Parser {
       let (unexpectedBeforeAt, at) = self.expect(.atSign)
       let (unexpectedBeforeIdent, ident) = self.expectIdentifier()
       let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
-      let (unexpectedBeforeArgument, argument) = self.expectIdentifier()
+      let arguments = self.parseConventionArguments()
       let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
       return RawSyntax(
         RawAttributeSyntax(
@@ -813,8 +813,7 @@ extension Parser {
           attributeName: ident,
           unexpectedBeforeLeftParen,
           leftParen: leftParen,
-          unexpectedBeforeArgument,
-          argument: RawSyntax(argument),
+          argument: arguments,
           unexpectedBeforeRightParen,
           rightParen: rightParen,
           tokenList: nil,

Sources/SwiftParser/gyb_generated/DeclarationAttribute.swift

@@ -119,5 +119,6 @@ extension Parser {
     case _spiOnly = "_spiOnly"
     case _documentation = "_documentation"
     case typeWrapperIgnored = "typeWrapperIgnored"
+    case _spi_available = "_spi_available"
   }
 }

Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md

@@ -234,6 +234,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/PatternBindingSyntax>
 - <doc:SwiftSyntax/EnumCaseElementListSyntax>
 - <doc:SwiftSyntax/EnumCaseElementSyntax>
+- <doc:SwiftSyntax/DesignatedTypeListSyntax>
+- <doc:SwiftSyntax/DesignatedTypeElementSyntax>
 - <doc:SwiftSyntax/PrecedenceGroupNameListSyntax>
 - <doc:SwiftSyntax/PrecedenceGroupNameElementSyntax>
 - <doc:SwiftSyntax/ObjCSelectorSyntax>
@@ -328,7 +330,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/PatternBindingListSyntax>
 - <doc:SwiftSyntax/EnumCaseElementSyntax>
 - <doc:SwiftSyntax/EnumCaseElementListSyntax>
-- <doc:SwiftSyntax/IdentifierListSyntax>
+- <doc:SwiftSyntax/DesignatedTypeListSyntax>
+- <doc:SwiftSyntax/DesignatedTypeElementSyntax>
 - <doc:SwiftSyntax/OperatorPrecedenceAndTypesSyntax>
 - <doc:SwiftSyntax/PrecedenceGroupAttributeListSyntax>
 - <doc:SwiftSyntax/PrecedenceGroupRelationSyntax>
@@ -362,6 +365,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/BackDeployVersionListSyntax>
 - <doc:SwiftSyntax/BackDeployVersionArgumentSyntax>
 - <doc:SwiftSyntax/OpaqueReturnTypeOfAttributeArgumentsSyntax>
+- <doc:SwiftSyntax/ConventionAttributeArgumentsSyntax>
+- <doc:SwiftSyntax/ConventionWitnessMethodAttributeArgumentsSyntax>
 - <doc:SwiftSyntax/SwitchCaseListSyntax>
 - <doc:SwiftSyntax/WhereClauseSyntax>
 - <doc:SwiftSyntax/CatchClauseListSyntax>