Add experimental colonColon token

And make sure it doesn’t break Objective-C selector lexing.

Author: beccadax

CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift

@@ -22,6 +22,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case keypathWithMethodMembers
   case oldOwnershipOperatorSpellings
   case inlineArrayTypeSugar
+  case moduleSelector
 
   /// The name of the feature as it is written in the compiler's `Features.def` file.
   public var featureName: String {
@@ -44,6 +45,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "OldOwnershipOperatorSpellings"
     case .inlineArrayTypeSugar:
       return "InlineArrayTypeSugar"
+    case .moduleSelector:
+      return "ModuleSelector"
     }
   }
 
@@ -68,6 +71,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "`_move` and `_borrow` as ownership operators"
     case .inlineArrayTypeSugar:
       return "sugar type for InlineArray"
+    case .moduleSelector:
+      return "Module selector syntax (`ModName::identifier`)"
     }
   }
 

CodeGeneration/Sources/SyntaxSupport/TokenSpec.swift

@@ -126,6 +126,7 @@ public enum Token: CaseIterable {
   case backtick
   case binaryOperator
   case colon
+  case colonColon
   case comma
   case dollarIdentifier
   case ellipsis
@@ -185,6 +186,8 @@ public enum Token: CaseIterable {
       return .other(name: "binaryOperator", nameForDiagnostics: "binary operator")
     case .colon:
       return .punctuator(name: "colon", text: ":")
+    case .colonColon:
+      return .punctuator(name: "colonColon", text: "::")
     case .comma:
       return .punctuator(name: "comma", text: ",")
     case .dollarIdentifier:

Sources/SwiftIDEUtils/SyntaxClassification.swift

@@ -114,6 +114,8 @@ extension RawTokenKind {
       return .operator
     case .colon:
       return .none
+    case .colonColon:
+      return .operator
     case .comma:
       return .none
     case .dollarIdentifier:

Sources/SwiftParser/Attributes.swift

@@ -602,8 +602,8 @@ extension Parser {
     var elements = [RawObjCSelectorPieceSyntax]()
     var loopProgress = LoopProgressCondition()
     while self.hasProgressed(&loopProgress) {
-      // Empty selector piece.
-      if let colon = self.consume(if: .colon) {
+      // Empty selector piece, splitting `::` into two colons.
+      if let colon = self.consume(ifPrefix: ":", as: .colon) {
         elements.append(
           RawObjCSelectorPieceSyntax(
             name: nil,
@@ -627,7 +627,8 @@ extension Parser {
           break
         }
 
-        let (unexpectedBeforeColon, colon) = self.expect(.colon)
+        // Match ending colon, spliting `::` into two colons.
+        let (unexpectedBeforeColon, colon) = self.expect(prefix: ":", as: .colon)
         elements.append(
           RawObjCSelectorPieceSyntax(
             name: name,

Sources/SwiftParser/Lexer/Cursor.swift

@@ -943,9 +943,17 @@ extension Lexer.Cursor {
 
     case ",": _ = self.advance(); return Lexer.Result(.comma)
     case ";": _ = self.advance(); return Lexer.Result(.semicolon)
-    case ":": _ = self.advance(); return Lexer.Result(.colon)
     case "\\": _ = self.advance(); return Lexer.Result(.backslash)
 
+    case ":":
+      _ = self.advance()
+      guard self.experimentalFeatures.contains(.moduleSelector) && self.peek() == ":" else {
+        return Lexer.Result(.colon)
+      }
+
+      _ = self.advance()
+      return Lexer.Result(.colonColon)
+
     case "#":
       // Try lex shebang.
       if self.isAtStartOfFile, self.peek(at: 1) == "!" {

Sources/SwiftParser/Lexer/RegexLiteralLexer.swift

@@ -643,6 +643,10 @@ extension Lexer.Cursor {
     case .identifier, .dollarIdentifier, .wildcard:
       return false
 
+    // Module selectors are allowed before an operator, but not a regex.
+    case .colonColon:
+      return false
+
     // Literals are themselves expressions and therefore don't sequence expressions.
     case .floatLiteral, .integerLiteral:
       return false
@@ -737,7 +741,7 @@ extension Lexer.Cursor {
       // an unapplied operator is legal, and we should prefer to lex as that
       // instead.
       switch previousTokenKind {
-      case .leftParen, .leftSquare, .comma, .colon:
+      case .leftParen, .leftSquare, .comma, .colon, .colonColon:
         break
       default:
         mustBeRegex = true

Sources/SwiftParser/Parser.swift

@@ -645,6 +645,25 @@ extension Parser {
     )
   }
 
+
+  /// Attempts to consume a token starting with the given `prefix` and forming it into `tokenKind`.
+  /// If it cannot be found, the parser tries
+  ///  1. To eat unexpected tokens that have lower ``TokenPrecedence`` than
+  ///     specified by `TokenSpec(tokenKind)` and see if the token occurs after that unexpected.
+  ///  2. If the token couldn't be found after skipping unexpected, it synthesizes
+  ///     a missing token of the requested kind.
+  @inline(__always)
+  mutating func expect(
+    prefix: SyntaxText, as tokenKind: RawTokenKind
+  ) -> (unexpected: RawUnexpectedNodesSyntax?, token: RawTokenSyntax) {
+    let spec = TokenSpec(tokenKind)
+    return expectImpl(
+      consume: { $0.consume(ifPrefix: prefix, as: tokenKind) },
+      canRecoverTo: { $0.canRecoverTo(spec) },
+      makeMissing: { $0.missingToken(spec) }
+    )
+  }
+
   /// If the current token starts with the given prefix, consume the prefis as the given token kind.
   ///
   /// Otherwise, synthesize a missing token of the given kind.

Sources/SwiftParser/Statements.swift

@@ -969,6 +969,9 @@ extension TokenConsumer {
       return false
     case .semicolon, .endOfFile, .poundElse, .poundElseif, .poundEndif:
       return false
+    case .colonColon:
+      // E.g. <word> :: <word>
+      return false
 
     case .leftAngle, .rightAngle:
       // Lexer never produce these token kinds.

Sources/SwiftParser/TokenPrecedence.swift

@@ -128,7 +128,7 @@ enum TokenPrecedence: Comparable {
       // Pound literals
       .poundAvailable, .poundSourceLocation, .poundUnavailable,
       // Identifiers
-      .dollarIdentifier, .identifier,
+      .dollarIdentifier, .identifier, .colonColon,
       // '_' can occur in types to replace a type identifier
       .wildcard,
       // String segment, string interpolation anchor, pound, shebang and regex pattern don't really fit anywhere else

Sources/SwiftParser/generated/ExperimentalFeatures.swift

@@ -158,11 +158,23 @@ final class AttributeTests: ParserTestCase {
       @objc(zeroArg)
       class A { }
 
-      @objc(:::::)
+      @objc(:::x::)
       func f(_: Int, _: Int, _: Int, _: Int, _: Int) { }
       """
     )
 
+    // Same as above, but with module selectors, which introduce a token for adjacent colons.
+    assertParse(
+      """
+      @objc(zeroArg)
+      class A { }
+
+      @objc(:::x::)
+      func f(_: Int, _: Int, _: Int, _: Int, _: Int) { }
+      """,
+      experimentalFeatures: [.moduleSelector]
+    )
+
     assertParse(
       """
       @objc(_:)