Support module selectors in scoped imports

Author: beccadax

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -28,7 +28,7 @@ public let DECL_NODES: [Node] = [
       ),
       Child(
         name: "trailingPeriod",
-        kind: .token(choices: [.token(.period)]),
+        kind: .token(choices: [.token(.period), .token(.colonColon)]),
         isOptional: true
       ),
     ],

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -357,10 +357,6 @@ class ValidateSyntaxNodes: XCTestCase {
             "child 'leadingComma' has a comma keyword as its only token choice and should thus be named 'comma' or 'trailingComma'"
         ),
         // This is similar to `TrailingComma`
-        ValidationFailure(
-          node: .importPathComponent,
-          message: "child 'trailingPeriod' has a token as its only token choice and should thus be named 'period'"
-        ),
         // `~` is the only operator that’s allowed here
         ValidationFailure(
           node: .suppressedType,

Sources/SwiftParser/Declarations.swift

@@ -431,7 +431,7 @@ extension Parser {
   ) -> RawImportDeclSyntax {
     let (unexpectedBeforeImportKeyword, importKeyword) = self.eat(handle)
     let kind = self.parseImportKind()
-    let path = self.parseImportPath()
+    let path = self.parseImportPath(hasImportKind: kind != nil)
     return RawImportDeclSyntax(
       attributes: attrs.attributes,
       modifiers: attrs.modifiers,
@@ -447,16 +447,25 @@ extension Parser {
     return self.consume(ifAnyIn: ImportDeclSyntax.ImportKindSpecifierOptions.self)
   }
 
-  mutating func parseImportPath() -> RawImportPathComponentListSyntax {
+  mutating func parseImportPath(hasImportKind: Bool) -> RawImportPathComponentListSyntax {
     var elements = [RawImportPathComponentSyntax]()
     var keepGoing: RawTokenSyntax? = nil
     var loopProgress = LoopProgressCondition()
     repeat {
       let name = self.parseAnyIdentifier()
-      keepGoing = self.consume(if: .period)
+      keepGoing = self.consume(ifAnyIn: ImportPathComponentSyntax.TrailingPeriodOptions.self)
+
+      // If we got `::` when it's not allowed, reject it
+      var unexpectedBeforeTrailingPeriod: RawUnexpectedNodesSyntax?
+      if keepGoing?.tokenKind == .colonColon && !hasImportKind {
+        unexpectedBeforeTrailingPeriod = RawUnexpectedNodesSyntax([keepGoing], arena: self.arena)
+        keepGoing = missingToken(.period)
+      }
+
       elements.append(
         RawImportPathComponentSyntax(
           name: name,
+          unexpectedBeforeTrailingPeriod,
           trailingPeriod: keepGoing,
           arena: self.arena
         )

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -1249,6 +1249,40 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: ImportPathComponentSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if let colonColon = node.unexpectedBetweenNameAndTrailingPeriod?.last?.as(TokenSyntax.self),
+      colonColon.tokenKind == .colonColon,
+      colonColon.isPresent,
+      let trailingPeriod = node.trailingPeriod,
+      trailingPeriod.tokenKind == .period,
+      trailingPeriod.isMissing
+    {
+      addDiagnostic(
+        colonColon,
+        .submoduleCannotBeImportedUsingModuleSelector,
+        fixIts: [
+          FixIt(
+            message: ReplaceTokensFixIt(replaceTokens: [colonColon], replacements: [trailingPeriod]),
+            changes: [
+              .makeMissing(colonColon),
+              .makePresent(trailingPeriod),
+            ]
+          )
+        ],
+        handledNodes: [
+          colonColon.id,
+          trailingPeriod.id,
+        ]
+      )
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: InitializerClauseSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -233,6 +233,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var subscriptsCannotHaveNames: Self {
     .init("subscripts cannot have a name")
   }
+  public static var submoduleCannotBeImportedUsingModuleSelector: Self {
+    .init("submodule cannot be imported using module selector")
+  }
   public static var tooManyClosingPoundDelimiters: Self {
     .init("too many '#' characters in closing delimiter")
   }

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -22,13 +22,37 @@ final class ModuleSelectorTests: ParserTestCase {
   }
 
   func testModuleSelectorImports() {
-    XCTExpectFailure("imports not yet implemented")
-
     assertParse(
       """
-      import ctypes::bits   // FIXME: ban using :: with submodules?
       import struct ModuleSelectorTestingKit::A
+      """,
+      substructure: ImportDeclSyntax(
+        importKindSpecifier: .keyword(.struct),
+        path: [
+          ImportPathComponentSyntax(
+            name: .identifier("ModuleSelectorTestingKit"),
+            trailingPeriod: .colonColonToken()
+          ),
+          ImportPathComponentSyntax(
+            name: .identifier("A")
+          ),
+        ]
+      )
+    )
+
+    assertParse(
       """
+      import ctypes1️⃣::bits
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          message: "submodule cannot be imported using module selector",
+          fixIts: ["replace '::' with '.'"]
+        )
+      ],
+      fixedSource: """
+        import ctypes.bits
+        """
     )
   }