Add diagnostic for misplaced specifiers

Author: ahoppen

Sources/SwiftParser/Declarations.swift

@@ -1351,6 +1351,11 @@ extension Parser {
 
         let modifiers = parseParameterModifiers(for: subject)
 
+        var misplacedSpecifiers: [RawTokenSyntax] = []
+        while let specifier = self.consume(ifAnyIn: TypeSpecifier.self) {
+          misplacedSpecifiers.append(specifier)
+        }
+
         let firstName: RawTokenSyntax?
         let secondName: RawTokenSyntax?
         let unexpectedBeforeColon: RawUnexpectedNodesSyntax?
@@ -1387,7 +1392,7 @@ extension Parser {
 
         let type: RawTypeSyntax?
         if shouldParseType {
-          type = self.parseType()
+          type = self.parseType(misplacedSpecifiers: misplacedSpecifiers)
         } else {
           type = nil
         }
@@ -1411,6 +1416,7 @@ extension Parser {
         elements.append(RawFunctionParameterSyntax(
           attributes: attrs,
           modifiers: modifiers,
+          RawUnexpectedNodesSyntax(misplacedSpecifiers, arena: self.arena),
           firstName: firstName,
           secondName: secondName,
           unexpectedBeforeColon,

Sources/SwiftParser/Diagnostics/ParseDiagnosticsGenerator.swift

@@ -179,9 +179,9 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     if node.presence == .missing {
       // If there is an unexpected token in front of the identifier, we assume
       // that this unexpected token was intended to be the identifier we are missing.
-      if case .identifier = node.tokenKind,
-          let invalidIdentifier = node.previousToken(viewMode: .all),
-          let previousParent = invalidIdentifier.parent?.as(UnexpectedNodesSyntax.self) {
+      if node.tokenKind.isIdentifier,
+         let invalidIdentifier = node.previousToken(viewMode: .all),
+         let previousParent = invalidIdentifier.parent?.as(UnexpectedNodesSyntax.self) {
         let fixIts: [FixIt]
         if invalidIdentifier.tokenKind.isKeyword {
           fixIts = [FixIt(message: .wrapKeywordInBackticks, changes: [
@@ -273,9 +273,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
         return
       }
       let message: DiagnosticMessage?
-      if let identifier = unexpected.onlyToken(where: {
-        if case .identifier = $0.tokenKind { return true } else { return false }
-      }) {
+      if let identifier = unexpected.onlyToken(where: { $0.tokenKind.isIdentifier }) {
         message = IdentifierNotAllowedInOperatorName(identifier: identifier)
       } else if let tokens = unexpected.onlyTokens(satisfying: { _ in true }) {
         message = TokensNotAllowedInOperatorName(tokens: tokens)
@@ -459,6 +457,21 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    exchangeTokens(
+      unexpected: node.unexpectedBetweenModifiersAndFirstName,
+      unexpectedTokenCondition: { TypeSpecifier(token: $0) != nil },
+      correctTokens: [node.type?.as(AttributedTypeSyntax.self)?.specifier],
+      message: { SpecifierOnParameterName(misplacedSpecifiers: $0) },
+      moveFixIt: { MoveTokensAfterTypeFixIt(movedTokens: $0) },
+      removeRedundantFixIt: { RemoveRedundantFixIt(removeTokens: $0) }
+    )
+    return .visitChildren
+  }
+
   public override func visit(_ node: PrecedenceGroupAssignmentSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift

@@ -151,6 +151,14 @@ public struct MissingAttributeArgument: ParserError {
   }
 }
 
+public struct SpecifierOnParameterName: ParserError {
+  public let misplacedSpecifiers: [TokenSyntax]
+
+  public var message: String {
+    return "\(nodesDescription(misplacedSpecifiers, format: false)) before a parameter name is not allowed"
+  }
+}
+
 public struct TokensNotAllowedInOperatorName: ParserError {
   public let tokens: [TokenSyntax]
 
@@ -218,6 +226,15 @@ public struct MoveTokensAfterFixIt: ParserFixIt {
   }
 }
 
+public struct MoveTokensAfterTypeFixIt: ParserFixIt {
+  /// The token that should be moved
+  public let movedTokens: [TokenSyntax]
+
+  public var message: String {
+    "move \(nodesDescription(movedTokens, format: false)) after type"
+  }
+}
+
 public struct MoveTokensInFrontOfFixIt: ParserFixIt {
   /// The token that should be moved
   public let movedTokens: [TokenSyntax]

Sources/SwiftParser/Diagnostics/SyntaxExtensions.swift

@@ -102,3 +102,14 @@ extension SyntaxProtocol {
     return nil
   }
 }
+
+extension TokenKind {
+  var isIdentifier: Bool {
+    switch self {
+    case .identifier:
+      return true
+    default:
+      return false
+    }
+  }
+}

Sources/SwiftParser/Names.swift

@@ -237,15 +237,13 @@ extension Parser.Lookahead {
 
 extension Lexer.Lexeme {
   var canBeArgumentLabel: Bool {
-    switch self.tokenKind {
-    case .identifier where self.tokenText == "__shared" || self.tokenText == "__owned":
+    if TypeSpecifier(lexeme: self) != nil {
       return false
+    }
+    switch self.tokenKind {
     case .identifier, .wildcardKeyword:
       // Identifiers, escaped identifiers, and '_' can be argument labels.
       return true
-    case .inoutKeyword:
-      // inout cannot be used as an argument label.
-      return false
     default:
       // All other keywords can be argument labels.
       return self.isKeyword

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -851,6 +851,46 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
   }
 }
 
+enum TypeSpecifier: RawTokenKindSubset {
+  case inoutKeyword
+  case owned
+  case shared
+
+  init?(lexeme: Lexer.Lexeme) {
+    switch (lexeme.tokenKind, lexeme.tokenText) {
+    case (.inoutKeyword, _): self = .inoutKeyword
+    case (.identifier, "__owned"): self = .owned
+    case (.identifier, "__shared"): self = .shared
+    default: return nil
+    }
+  }
+
+  init?(token: TokenSyntax) {
+    switch (token.tokenKind, token.text) {
+    case (.inoutKeyword, _): self = .inoutKeyword
+    case (.contextualKeyword, "__owned"): self = .owned
+    case (.contextualKeyword, "__shared"): self = .shared
+    default: return nil
+    }
+  }
+
+  var rawTokenKind: RawTokenKind {
+    switch self {
+    case .inoutKeyword: return .inoutKeyword
+    case .owned: return .identifier
+    case .shared: return .identifier
+    }
+  }
+
+  var contextualKeyword: SyntaxText? {
+    switch self {
+    case .inoutKeyword: return nil
+    case .owned: return "__owned"
+    case .shared: return "__shared"
+    }
+  }
+}
+
 /// Union of the following token kind subsets:
 ///  - `AwaitTry`
 ///  - `ExpressionPrefixOperator`

Sources/SwiftParser/TokenConsumer.swift

@@ -216,6 +216,14 @@ extension TokenConsumer {
       return nil
     }
   }
+
+  mutating func consume<Subset: RawTokenKindSubset>(ifAnyIn subset: Subset.Type) -> Self.Token? {
+    if let (_, handle) = self.at(anyIn: subset) {
+      return self.eat(handle)
+    } else {
+      return nil
+    }
+  }
 }
 
 // MARK: Expecting Tokens (`expect`)

Sources/SwiftParser/Types.swift

@@ -32,8 +32,8 @@ extension Parser {
   ///     type → self-type
   ///     type → '(' type ')'
   @_spi(RawSyntax)
-  public mutating func parseType() -> RawTypeSyntax {
-    let type = self.parseTypeScalar()
+  public mutating func parseType(misplacedSpecifiers: [RawTokenSyntax] = []) -> RawTypeSyntax {
+    let type = self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)
 
     // Parse pack expansion 'T...'.
     if self.currentToken.isEllipsis {
@@ -47,8 +47,8 @@ extension Parser {
     return type
   }
 
-  mutating func parseTypeScalar() -> RawTypeSyntax {
-    let (specifier, attrList) = self.parseTypeAttributeList()
+  mutating func parseTypeScalar(misplacedSpecifiers: [RawTokenSyntax] = []) -> RawTypeSyntax {
+    let (specifier, attrList) = self.parseTypeAttributeList(misplacedSpecifiers: misplacedSpecifiers)
     var base = RawTypeSyntax(self.parseSimpleOrCompositionType())
     if self.lookahead().isAtFunctionTypeArrow() {
       let firstEffect = self.parseEffectsSpecifier()
@@ -783,8 +783,12 @@ extension Parser.Lookahead {
 
 extension Parser {
   @_spi(RawSyntax)
-  public mutating func parseTypeAttributeList() -> (RawTokenSyntax?, RawAttributeListSyntax?) {
-    let specifier = self.consume(ifAny: [.inoutKeyword], contextualKeywords: ["__shared", "__owned"])
+  public mutating func parseTypeAttributeList(misplacedSpecifiers: [RawTokenSyntax] = []) -> (RawTokenSyntax?, RawAttributeListSyntax?) {
+    var specifier: RawTokenSyntax? = self.consume(ifAnyIn: TypeSpecifier.self)
+    // We can only stick one specifier on this type. Let's pick the first one
+    if specifier == nil, let misplacedSpecifier = misplacedSpecifiers.first {
+      specifier = missingToken(misplacedSpecifier.tokenKind, text: misplacedSpecifier.tokenText)
+    }
 
     if self.at(any: [.atSign, .inoutKeyword]) {
       return (specifier, self.parseTypeAttributeListPresent())