[SwiftParser] Avoid consuming invalid dependsOn and nonisolated modifiers while skipping

Otherwise in situations like `nonisolated()` `canParseType` would
return `true` because `()` is valid type.

Author: xedin

Sources/SwiftParser/Types.swift

@@ -687,27 +687,74 @@ extension Parser.Lookahead {
     return true
   }
 
-  mutating func skipTypeAttributeList() {
+  mutating func skipTypeAttributeList() -> Bool {
     var specifierProgress = LoopProgressCondition()
     while canHaveParameterSpecifier,
       self.at(anyIn: SimpleTypeSpecifierSyntax.SpecifierOptions.self) != nil
         || self.at(.keyword(.nonisolated), .keyword(.dependsOn)),
       self.hasProgressed(&specifierProgress)
     {
       switch self.currentToken {
-      case .keyword(.nonisolated), .keyword(.dependsOn):
+      case .keyword(.nonisolated):
+        guard
+          self.withLookahead({
+            // Consume 'nonisolated'
+            $0.consumeAnyToken()
+
+            // The argument is missing but it still could be a valid modifier,
+            // i.e. `nonisolated` in an inheritance clause.
+            guard $0.at(TokenSpec(.leftParen, allowAtStartOfLine: false)) else {
+              return true
+            }
+
+            // Consume '('
+            $0.consumeAnyToken()
+
+            // nonisolated accepts a single modifier at the moment: 'nonsending'
+            // we need to check for that explicitly to avoid misinterpreting this
+            // keyword to be a modifier when it isn't i.e. `[nonisolated(42)]`
+            guard $0.consume(if: TokenSpec(.nonsending, allowAtStartOfLine: false)) != nil else {
+              return false
+            }
+
+            return $0.consume(if: TokenSpec(.rightParen, allowAtStartOfLine: false)) != nil
+          })
+        else {
+          return false
+        }
+
         self.consumeAnyToken()
 
-        // The argument is missing but it still could be a valid modifier,
-        // i.e. `nonisolated` in an inheritance clause.
         guard self.at(TokenSpec(.leftParen, allowAtStartOfLine: false)) else {
           continue
         }
 
-        if self.withLookahead({ $0.atAttributeOrSpecifierArgument() }) {
-          skipSingle()
+        self.skipSingle()
+
+      case .keyword(.dependsOn):
+        guard
+          self.withLookahead({
+            // Consume 'dependsOn'
+            $0.consumeAnyToken()
+
+            if $0.currentToken.isAtStartOfLine {
+              return false
+            }
+
+            // `dependsOn` requires an argument list.
+            guard $0.atAttributeOrSpecifierArgument() else {
+              return false
+            }
+
+            return true
+          })
+        else {
+          return false
         }
 
+        self.consumeAnyToken()
+        self.skipSingle()
+
       default:
         self.consumeAnyToken()
       }
@@ -718,10 +765,14 @@ extension Parser.Lookahead {
       self.consumeAnyToken()
       self.skipTypeAttribute()
     }
+
+    return true
   }
 
   mutating func canParseTypeScalar() -> Bool {
-    self.skipTypeAttributeList()
+    guard self.skipTypeAttributeList() else {
+      return false
+    }
 
     guard self.canParseSimpleOrCompositionType() else {
       return false