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

@@ -429,7 +429,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,
@@ -445,21 +445,66 @@ 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)
-      elements.append(
+
+    // Special case: scoped import with module selector-style syntax. This always has exactly two path components
+    // separated by '::'.
+    if hasImportKind,
+      let (moduleNameOrUnexpected, colonColon, unexpectedAfterColonColon) = self.consumeModuleSelectorTokensIfPresent()
+    {
+      // Is the token in module name position really a module name?
+      let unexpectedBeforeModuleName: RawUnexpectedNodesSyntax?, moduleName: RawTokenSyntax
+      if moduleNameOrUnexpected.tokenKind == .identifier {
+        unexpectedBeforeModuleName = nil
+        moduleName = moduleNameOrUnexpected
+      } else {
+        unexpectedBeforeModuleName = RawUnexpectedNodesSyntax([moduleNameOrUnexpected], arena: self.arena)
+        moduleName = self.missingToken(.identifier)
+      }
+
+      let declName = self.parseAnyIdentifier()
+
+      elements = [
         RawImportPathComponentSyntax(
-          name: name,
-          trailingPeriod: keepGoing,
+          unexpectedBeforeModuleName,
+          name: moduleName,
+          trailingPeriod: colonColon,
+          RawUnexpectedNodesSyntax(unexpectedAfterColonColon, arena: self.arena),
           arena: self.arena
+        ),
+        RawImportPathComponentSyntax(
+          name: declName,
+          trailingPeriod: nil,
+          arena: self.arena
+        ),
+      ]
+    } else {
+      var keepGoing: RawTokenSyntax? = nil
+      var loopProgress = LoopProgressCondition()
+      repeat {
+        let name = self.parseAnyIdentifier()
+        keepGoing = self.consume(if: .period)
+
+        // '::' is not valid if we got here, but someone might try to use it anyway.
+        let unexpectedAfterTrailingPeriod: RawUnexpectedNodesSyntax?
+        if keepGoing == nil, let colonColon = self.consume(if: .colonColon) {
+          unexpectedAfterTrailingPeriod = RawUnexpectedNodesSyntax([colonColon], arena: self.arena)
+          keepGoing = self.missingToken(.period)
+        } else {
+          unexpectedAfterTrailingPeriod = nil
+        }
+
+        elements.append(
+          RawImportPathComponentSyntax(
+            name: name,
+            trailingPeriod: keepGoing,
+            unexpectedAfterTrailingPeriod,
+            arena: self.arena
+          )
         )
-      )
-    } while keepGoing != nil && self.hasProgressed(&loopProgress)
+      } while keepGoing != nil && self.hasProgressed(&loopProgress)
+    }
     return RawImportPathComponentListSyntax(elements: elements, 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.unexpectedAfterTrailingPeriod?.first?.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,70 @@ 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 struct 1️⃣_::A
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "'_' cannot be used as an identifier here")
+      ]
+    )
+
+    assertParse(
+      """
+      import struct ModuleSelectorTestingKit::1️⃣Submodule::A
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "unexpected code 'Submodule::' in import")
+      ]
+    )
+
+    assertParse(
       """
+      import struct ModuleSelectorTestingKit.Submodule1️⃣::A
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          message: "submodule cannot be imported using module selector",
+          fixIts: ["replace '::' with '.'"]
+        )
+      ],
+      fixedSource: """
+        import struct ModuleSelectorTestingKit.Submodule.A
+        """
+    )
+
+    assertParse(
+      """
+      import ctypes1️⃣::bits
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          message: "submodule cannot be imported using module selector",
+          fixIts: ["replace '::' with '.'"]
+        )
+      ],
+      fixedSource: """
+        import ctypes.bits
+        """
     )
   }