Parse module selectors in permitted locations

Author: beccadax

include/swift/AST/DiagnosticsParse.def

@@ -91,6 +91,11 @@ ERROR(forbidden_interpolated_string,none,
 ERROR(forbidden_extended_escaping_string,none,
       "%0 cannot be an extended escaping string literal", (StringRef))
 
+ERROR(expected_identifier_in_module_selector,none,
+      "expected identifier in module selector", ())
+ERROR(module_selector_not_allowed_here,none,
+      "name cannot be qualified with module selector here", ())
+
 //------------------------------------------------------------------------------
 // MARK: Lexer diagnostics
 //------------------------------------------------------------------------------

include/swift/Parse/Parser.h

@@ -1628,6 +1628,10 @@ class Parser {
     /// not ordinary identifiers.
     AllowKeywordsUsingSpecialNames = AllowKeywords | 1 << 2,
 
+    /// If passed, a module selector (ModuleName::) is permitted before the base
+    /// name.
+    AllowModuleSelector = 1 << 3,
+
     /// If passed, compound names with argument lists are allowed, unless they
     /// have empty argument lists.
     AllowCompoundNames = 1 << 4,

lib/Parse/ParseDecl.cpp

@@ -1189,7 +1189,8 @@ static bool parseQualifiedDeclName(Parser &P, Diag<> nameParseError,
         original.Loc, nameParseError,
         Parser::DeclNameFlag::AllowZeroArgCompoundNames |
             Parser::DeclNameFlag::AllowKeywordsUsingSpecialNames |
-            Parser::DeclNameFlag::AllowOperators);
+            Parser::DeclNameFlag::AllowOperators |
+            Parser::DeclNameFlag::AllowModuleSelector);
     // The base type is optional, but the final unqualified declaration name is
     // not. If name could not be parsed, return true for error.
     if (!original.Name)
@@ -2484,7 +2485,8 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
           diag::attr_dynamic_replacement_expected_function,
           DeclNameFlag::AllowZeroArgCompoundNames |
           DeclNameFlag::AllowKeywordsUsingSpecialNames |
-          DeclNameFlag::AllowOperators);
+          DeclNameFlag::AllowOperators |
+          DeclNameFlag::AllowModuleSelector);
     }
 
     // Parse the matching ')'.
@@ -2830,11 +2832,15 @@ ParserStatus Parser::parseDeclAttribute(
   DeclAttributes &Attributes, SourceLoc AtLoc,
   PatternBindingInitializer *&initContext,
   bool isFromClangAttribute) {
+  bool hasModuleSelector = Context.LangOpts.EnableExperimentalModuleSelector &&
+                               peekToken().is(tok::colon_colon);
+
   // If this not an identifier, the attribute is malformed.
   if (Tok.isNot(tok::identifier) &&
       Tok.isNot(tok::kw_in) &&
       Tok.isNot(tok::kw_inout) &&
-      Tok.isNot(tok::kw_rethrows)) {
+      Tok.isNot(tok::kw_rethrows) &&
+      !hasModuleSelector) {
 
     if (Tok.is(tok::code_complete)) {
       if (CodeCompletion) {
@@ -2854,15 +2860,18 @@ ParserStatus Parser::parseDeclAttribute(
 
   // If the attribute follows the new representation, switch
   // over to the alternate parsing path.
-  DeclAttrKind DK = DeclAttribute::getAttrKindFromString(Tok.getText());
+  // All module-selected names are custom attributes, so we always use DAK_Count
+  // if a module selector is present.
+  DeclAttrKind DK = hasModuleSelector ? DAK_Count :
+      DeclAttribute::getAttrKindFromString(Tok.getText());
   if (DK == DAK_Rethrows) { DK = DAK_AtRethrows; }
   if (DK == DAK_Reasync) { DK = DAK_AtReasync; }
 
   auto checkInvalidAttrName = [&](StringRef invalidName,
                                   StringRef correctName,
                                   DeclAttrKind kind,
                                   Optional<Diag<StringRef, StringRef>> diag = None) {
-    if (DK == DAK_Count && Tok.getText() == invalidName) {
+    if (DK == DAK_Count && !hasModuleSelector && Tok.getText() == invalidName) {
       DK = kind;
 
       if (diag) {
@@ -2916,7 +2925,8 @@ ParserStatus Parser::parseDeclAttribute(
     AtLoc = SourceLoc();
   }
 
-  if (DK == DAK_Count && Tok.getText() == "warn_unused_result") {
+  if (DK == DAK_Count && !hasModuleSelector
+      && Tok.getText() == "warn_unused_result") {
     // The behavior created by @warn_unused_result is now the default. Emit a
     // Fix-It to remove.
     SourceLoc attrLoc = consumeToken();
@@ -2957,9 +2967,10 @@ ParserStatus Parser::parseDeclAttribute(
     return makeParserSuccess();
   }
 
-  if (TypeAttributes::getAttrKindFromString(Tok.getText()) != TAK_Count)
+  if (!hasModuleSelector &&
+      TypeAttributes::getAttrKindFromString(Tok.getText()) != TAK_Count)
     diagnose(Tok, diag::type_attribute_applied_to_decl);
-  else if (Tok.isContextualKeyword("unknown")) {
+  else if (!hasModuleSelector && Tok.isContextualKeyword("unknown")) {
     diagnose(Tok, diag::unknown_attribute, "unknown");
   } else {
     // Change the context to create a custom attribute syntax.
@@ -3118,7 +3129,8 @@ bool Parser::parseConventionAttributeInternal(
 
     DeclNameLoc unusedLoc;
     convention.WitnessMethodProtocol = parseDeclNameRef(unusedLoc,
-        diag::convention_attribute_witness_method_expected_protocol, {});
+        diag::convention_attribute_witness_method_expected_protocol,
+        DeclNameFlag::AllowModuleSelector);
   }
 
   // Parse the ')'.  We can't use parseMatchingToken if we're in

lib/Parse/ParseExpr.cpp

@@ -1198,7 +1198,8 @@ Parser::parseExprPostfixSuffix(ParserResult<Expr> Result, bool isExprBasic,
                      ? diag::expected_identifier_after_super_dot_expr
                      : diag::expected_member_name;
       auto Name = parseDeclNameRef(NameLoc, D,
-          DeclNameFlag::AllowKeywords | DeclNameFlag::AllowCompoundNames);
+          DeclNameFlag::AllowKeywords | DeclNameFlag::AllowCompoundNames |
+          DeclNameFlag::AllowModuleSelector);
       if (!Name) {
         SourceRange ErrorRange = Result.get()->getSourceRange();
         ErrorRange.widen(TokLoc);
@@ -1726,7 +1727,8 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
     }
 
     Name = parseDeclNameRef(NameLoc, diag::expected_identifier_after_dot_expr,
-        DeclNameFlag::AllowKeywords | DeclNameFlag::AllowCompoundNames);
+        DeclNameFlag::AllowKeywords | DeclNameFlag::AllowCompoundNames |
+        DeclNameFlag::AllowModuleSelector);
     if (!Name)
       return makeParserErrorResult(new (Context) ErrorExpr(DotLoc));
     SyntaxContext->createNodeInPlace(SyntaxKind::MemberAccessExpr);
@@ -2270,6 +2272,34 @@ DeclNameRef Parser::parseDeclNameRef(DeclNameLoc &loc,
                                      DeclNameOptions flags) {
   SyntaxParsingContext declNameRefCtxt(SyntaxContext, SyntaxKind::DeclNameRef);
 
+  // Consume the module name, if present.
+  SourceLoc moduleSelectorLoc;
+  Identifier moduleSelector;
+  if (Context.LangOpts.EnableExperimentalModuleSelector &&
+      peekToken().is(tok::colon_colon)) {
+    // FIXME: libSyntax
+
+    if (Tok.is(tok::identifier)) { // FIXME: tok::dollarident?
+      moduleSelectorLoc = consumeIdentifier(moduleSelector,
+                                            /*diagnoseDollarPrefix=*/true);
+    }
+    else {
+      diagnose(Tok, diag::expected_identifier_in_module_selector);
+      moduleSelector = Identifier();
+      moduleSelectorLoc = consumeToken();
+    }
+
+    // Diagnose if we don't allow a module selector here.
+    if (!flags.contains(DeclNameFlag::AllowModuleSelector)) {
+      diagnose(Tok, diag::module_selector_not_allowed_here)
+          .fixItRemove({moduleSelectorLoc, Tok.getLoc()});
+      moduleSelector = Identifier();
+      moduleSelectorLoc = SourceLoc();
+    }
+
+    consumeToken(tok::colon_colon);
+  }
+
   // Consume the base name.
   DeclBaseName baseName;
   SourceLoc baseNameLoc;
@@ -2342,7 +2372,8 @@ ParserResult<Expr> Parser::parseExprIdentifier() {
   // Parse the unqualified-decl-name.
   DeclNameLoc loc;
   DeclNameRef name = parseDeclNameRef(loc, diag::expected_expr,
-                                      DeclNameFlag::AllowCompoundNames);
+                                      DeclNameFlag::AllowCompoundNames |
+                                      DeclNameFlag::AllowModuleSelector);
 
   SmallVector<TypeRepr*, 8> args;
   SourceLoc LAngleLoc, RAngleLoc;
@@ -3188,8 +3219,11 @@ ParserStatus Parser::parseExprList(tok leftTok, tok rightTok,
       SyntaxParsingContext operatorContext(SyntaxContext,
                                            SyntaxKind::IdentifierExpr);
       DeclNameLoc Loc;
+      // FIXME: We would like to allow module selectors on binary operators, but
+      // the condition above won't let us reach this code.
       auto OperName = parseDeclNameRef(Loc, diag::expected_operator_ref,
-                                       DeclNameFlag::AllowOperators);
+                                       DeclNameFlag::AllowOperators |
+                                       DeclNameFlag::AllowModuleSelector);
       if (!OperName) {
         return makeParserError();
       }

lib/Parse/ParseType.cpp

@@ -700,7 +700,8 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
   while (true) {
     DeclNameLoc Loc;
     DeclNameRef Name =
-        parseDeclNameRef(Loc, diag::expected_identifier_in_dotted_type, {});
+        parseDeclNameRef(Loc, diag::expected_identifier_in_dotted_type,
+                         DeclNameFlag::AllowModuleSelector);
     if (!Name)
       Status.setIsParseError();
 

test/NameLookup/Inputs/ModuleSelectorTestingKit.swiftinterface

@@ -0,0 +1,42 @@
+// swift-interface-format-version: 1.0
+// swift-module-flags: -module-name ModuleSelectorTestingKit -swift-version 5
+
+import Swift
+
+// These types are identical; we just use them to test with different scope
+// selectors.
+
+public struct A {
+  public init(value: Swift.Int)
+  public dynamic mutating func negate()
+  public var magnitude: Swift.UInt
+}
+
+public struct B {
+  public init(value: Swift.Int)
+  public dynamic mutating func negate()
+  public var magnitude: Swift.UInt
+}
+
+public struct C {
+  public init(value: Int)
+  public dynamic mutating func negate()
+  public var magnitude: Swift.UInt
+}
+
+public struct D {
+  public init(value: Int)
+  public dynamic mutating func negate()
+  public var magnitude: Swift.UInt
+}
+
+@propertyWrapper
+public struct available {
+  public init() {}
+  public var wrappedValue: Int { 0 }
+}
+
+@_functionBuilder
+public struct MyBuilder {
+  public static func buildBlock()
+}

test/NameLookup/module_selector.swift

@@ -1 +1,127 @@
-// RUN: %target-typecheck-verify-swift -enable-experimental-module-selector %s
+// RUN: %target-typecheck-verify-swift -module-name main -I %S/Inputs -enable-experimental-module-selector
+
+// Make sure the lack of the experimental flag disables the feature:
+// RUN: not %target-typecheck-verify-swift -module-name main -I %S/Inputs 2>/dev/null
+
+import ModuleSelectorTestingKit
+
+let magnitude: Never = fatalError()
+
+// Test resolution of main:: using `B`
+
+extension main::B: main::Equatable {
+  @_implements(main::Equatable, main::==(_:_:)) // expected-error {{name cannot be qualified with module selector here}} {{33-39=}}
+  public static func equals(_: main::B, _: main::B) -> main::Bool { main::fatalError() }
+  
+  // FIXME: Add tests with autodiff @_differentiable(jvp:vjp:) and
+  // @_derivative(of:)
+  
+  @_dynamicReplacement(for: main::negate())
+  mutating func myNegate() {
+    let fn: (main::Int, main::Int) -> main::Int =
+    // FIXME:
+      (main::+) // expected-error {{cannot convert value of type '()' to specified type '(Int, Int) -> Int'}} expected-error {{expected expression}} expected-error {{expected expression after operator}}
+    let magnitude: main::Int.main::Magnitude = main::magnitude // expected-EVENTUALLY-error {{a type mismatch with 'Never'}} FIXME: expected-error {{variable used within its own initial value}}
+    if main::Bool.main::random() {
+      main::negate() // expected-EVENTUALLY-error {{something about not finding 'negate' because we didn't look in self}}
+    }
+    else {
+      self = main::B(value: .main::min)
+    }
+    
+    self.main::myNegate()
+  }
+
+  // FIXME: Can we test @convention(witness_method:)?
+}
+
+// Test resolution of ModuleSelectorTestingKit:: using `C`
+
+extension ModuleSelectorTestingKit::C: ModuleSelectorTestingKit::Equatable {
+  @_implements(ModuleSelectorTestingKit::Equatable, ModuleSelectorTestingKit::==(_:_:)) // expected-error {{name cannot be qualified with module selector here}} {{52-77=}}
+  public static func equals(_: ModuleSelectorTestingKit::C, _: ModuleSelectorTestingKit::C) -> ModuleSelectorTestingKit::Bool { ModuleSelectorTestingKit::fatalError() }
+  
+  // FIXME: Add tests with autodiff @_differentiable(jvp:vjp:) and
+  // @_derivative(of:)
+  
+  @_dynamicReplacement(for: ModuleSelectorTestingKit::negate())
+  mutating func myNegate() {
+    let fn: (ModuleSelectorTestingKit::Int, ModuleSelectorTestingKit::Int) -> ModuleSelectorTestingKit::Int =
+    // FIXME:
+      (ModuleSelectorTestingKit::+) // expected-error {{cannot convert value of type '()' to specified type '(Int, Int) -> Int'}} expected-error {{expected expression}} expected-error {{expected expression after operator}}
+    let magnitude: ModuleSelectorTestingKit::Int.ModuleSelectorTestingKit::Magnitude = ModuleSelectorTestingKit::magnitude // expected-EVENTUALLY-error {{something about not finding 'magnitude' because we didn't look in self}} FIXME: expected-error {{variable used within its own initial value}}
+    if ModuleSelectorTestingKit::Bool.ModuleSelectorTestingKit::random() {
+      ModuleSelectorTestingKit::negate() // expected-EVENTUALLY-error {{something about not finding 'negate' because we didn't look in self}}
+    }
+    else {
+      self = ModuleSelectorTestingKit::C(value: .ModuleSelectorTestingKit::min)
+    }
+    
+    self.ModuleSelectorTestingKit::myNegate() // expected-EVENTUALLY-error {{can't find 'myNegate' in ModuleSelectorTestingKit}}
+  }
+
+  // FIXME: Can we test @convention(witness_method:)?
+}
+
+// Test resolution of Swift:: using `D`
+// FIXME: Many more of these should fail once the feature is actually implemented.
+
+extension Swift::D: Swift::Equatable {
+  @_implements(Swift::Equatable, Swift::==(_:_:)) // expected-error {{name cannot be qualified with module selector here}} {{34-41=}}
+  public static func equals(_: Swift::D, _: Swift::D) -> Swift::Bool { Swift::fatalError() }
+  
+  // FIXME: Add tests with autodiff @_differentiable(jvp:vjp:) and
+  // @_derivative(of:)
+  
+  @_dynamicReplacement(for: Swift::negate())
+  mutating func myNegate() {
+    let fn: (Swift::Int, Swift::Int) -> Swift::Int =
+    // FIXME:
+      (Swift::+) // expected-error {{cannot convert value of type '()' to specified type '(Int, Int) -> Int'}} expected-error {{expected expression}} expected-error {{expected expression after operator}}
+    let magnitude: Swift::Int.Swift::Magnitude = Swift::magnitude // expected-EVENTUALLY-error {{something about not finding 'magnitude' because we didn't look in self}} FIXME: expected-error {{variable used within its own initial value}}
+    if Swift::Bool.Swift::random() {
+      Swift::negate() // expected-EVENTUALLY-error {{something about not finding 'negate' because we didn't look in self}}
+    }
+    else {
+      self = Swift::D(value: .ModuleSelectorTestingKit::min)
+    }
+    
+    self.Swift::myNegate() // expected-EVENTUALLY-error {{can't find 'myNegate' in Swift}}
+  }
+
+  // FIXME: Can we test @convention(witness_method:)?
+}
+
+struct AvailableUser {
+  @available(macOS 10.15, *) var use1: String { "foo" }
+
+  @main::available() var use2
+  @ModuleSelectorTestingKit::available() var use4
+  @Swift::available() var use5 // expected-EVENTUALLY-error {{can't find because not in 'Swift'}}
+}
+
+func builderUser2(@main::MyBuilder fn: () -> Void) {}
+func builderUser3(@ModuleSelectorTestingKit::MyBuilder fn: () -> Void) {}
+func builderUser4(@Swift::MyBuilder fn: () -> Void) {} // expected-EVENTUALLY-error {{can't find because not in 'Swift'}}
+
+func whitespace() {
+  Swift::print // expected-error{{expression resolves to an unused function}}
+
+  Swift :: print // expected-error{{expression resolves to an unused function}}
+
+  Swift::
+  print // expected-error{{expression resolves to an unused function}}
+
+  Swift
+  ::print // expected-error{{expression resolves to an unused function}}
+
+  Swift ::
+  print // expected-error{{expression resolves to an unused function}}
+
+  Swift
+  :: print // expected-error{{expression resolves to an unused function}}
+
+  Swift
+  ::
+  print // expected-error{{expression resolves to an unused function}}
+}