Merge pull request #62775 from AnthonyLatsis/sugar-type-members-2

Parser: Support member types with non-identifier qualifiers

Author: AnthonyLatsis

include/swift/AST/CASTBridging.h

@@ -242,7 +242,8 @@ void *ProtocolTypeRepr_create(void *ctx, void *baseType, void *protoLoc);
 void *PackExpansionTypeRepr_create(void *ctx, void *base, void *repeatLoc);
 void *TupleTypeRepr_create(void *ctx, BridgedArrayRef elements, void *lParenLoc,
                            void *rParenLoc);
-void *DeclRefTypeRepr_create(void *ctx, BridgedArrayRef bridgedComponents);
+void *MemberTypeRepr_create(void *ctx, void *baseComponent,
+                            BridgedArrayRef bridgedMemberComponents);
 void *GenericIdentTypeRepr_create(void *ctx, BridgedIdentifier name,
                                   void *nameLoc, BridgedArrayRef genericArgs,
                                   void *lAngle, void *rAngle);

include/swift/AST/TypeRepr.h

@@ -442,11 +442,11 @@ class MemberTypeRepr final : public DeclRefTypeRepr,
   }
 
 public:
-  static MemberTypeRepr *create(const ASTContext &Ctx, TypeRepr *Base,
-                                ArrayRef<IdentTypeRepr *> MemberComponents);
+  static TypeRepr *create(const ASTContext &Ctx, TypeRepr *Base,
+                          ArrayRef<IdentTypeRepr *> MemberComponents);
 
-  static MemberTypeRepr *create(const ASTContext &Ctx,
-                                ArrayRef<IdentTypeRepr *> Components);
+  static DeclRefTypeRepr *create(const ASTContext &Ctx,
+                                 ArrayRef<IdentTypeRepr *> Components);
 
   TypeRepr *getBaseComponent() const { return Base; }
 

include/swift/IDE/CodeCompletionResult.h

@@ -200,8 +200,8 @@ enum class CompletionKind : uint8_t {
   KeyPathExprSwift,
   TypeDeclResultBeginning,
   TypeSimpleBeginning,
-  TypeIdentifierWithDot,
-  TypeIdentifierWithoutDot,
+  TypeSimpleWithDot,
+  TypeSimpleWithoutDot,
   CaseStmtKeyword,
   CaseStmtBeginning,
   NominalMemberBeginning,

include/swift/Parse/IDEInspectionCallbacks.h

@@ -162,11 +162,11 @@ class IDEInspectionCallbacks {
   /// by user.
   virtual void completeTypeSimpleBeginning() {};
 
-  /// Complete a given type identifier after we have consumed the dot.
-  virtual void completeTypeIdentifierWithDot(DeclRefTypeRepr *TR){};
+  /// Complete a given \c type-simple after we have consumed the dot.
+  virtual void completeTypeSimpleWithDot(TypeRepr *TR){};
 
-  /// Complete a given type identifier when there is no trailing dot.
-  virtual void completeTypeIdentifierWithoutDot(DeclRefTypeRepr *TR){};
+  /// Complete a given \c type-simple when there is no trailing dot.
+  virtual void completeTypeSimpleWithoutDot(TypeRepr *TR){};
 
   /// Complete the beginning of a case statement at the top of switch stmt.
   virtual void completeCaseStmtKeyword() {};

include/swift/Parse/Parser.h

@@ -39,6 +39,7 @@ namespace llvm {
 }
 
 namespace swift {
+  class IdentTypeRepr;
   class IDEInspectionCallbacks;
   class IDEInspectionCallbacksFactory;
   class DefaultArgumentInitializer;
@@ -1327,19 +1328,29 @@ class Parser {
                                      SourceLoc &LAngleLoc,
                                      SourceLoc &RAngleLoc);
 
-  /// Parses a type identifier (e.g. 'Foo' or 'Foo.Bar.Baz').
+  /// Parses and returns the base type for a qualified declaration name,
+  /// positioning the parser at the '.' before the final declaration name. This
+  /// position is important for parsing final declaration names like '.init' via
+  /// `parseUnqualifiedDeclName`. For example, 'Foo.Bar.f' parses as 'Foo.Bar'
+  /// and the parser is positioned at '.f'. If there is no base type qualifier
+  /// (e.g. when parsing just 'f'), returns an empty parser error.
   ///
-  /// When `isParsingQualifiedDeclBaseType` is true:
-  /// - Parses and returns the base type for a qualified declaration name,
-  ///   positioning the parser at the '.' before the final declaration name.
-  //    This position is important for parsing final declaration names like
-  //    '.init' via `parseUnqualifiedDeclName`.
-  /// - For example, 'Foo.Bar.f' parses as 'Foo.Bar' and the parser is
-  ///   positioned at '.f'.
-  /// - If there is no base type qualifier (e.g. when parsing just 'f'), returns
-  ///   an empty parser error.
-  ParserResult<TypeRepr> parseTypeIdentifier(
-      bool isParsingQualifiedDeclBaseType = false);
+  /// \verbatim
+  ///   qualified-decl-name-base-type:
+  ///     identifier generic-args? ('.' identifier generic-args?)*
+  /// \endverbatim
+  ParserResult<TypeRepr> parseQualifiedDeclNameBaseType();
+
+  /// Parse an identifier type, e.g 'Foo' or 'Bar<Int>'.
+  ///
+  /// \verbatim
+  /// type-identifier: identifier generic-args?
+  /// \endverbatim
+  ParserResult<IdentTypeRepr> parseTypeIdentifier();
+
+  /// Parse a dotted type, e.g. 'Foo<X>.Y.Z', 'P.Type', '[X].Y'.
+  ParserResult<TypeRepr> parseTypeDotted(ParserResult<TypeRepr> Base);
+
   ParserResult<TypeRepr> parseOldStyleProtocolComposition();
   ParserResult<TypeRepr> parseAnyType();
   ParserResult<TypeRepr> parseSILBoxType(GenericParamList *generics,
@@ -1587,10 +1598,7 @@ class Parser {
   /// \verbatim
   ///   simple-type-identifier: identifier generic-argument-list?
   /// \endverbatim
-  bool canParseSimpleTypeIdentifier();
-
   bool canParseTypeIdentifier();
-  bool canParseTypeIdentifierOrTypeComposition();
   bool canParseOldStyleProtocolComposition();
   bool canParseTypeTupleBody();
   bool canParseTypeAttribute();
@@ -1599,10 +1607,6 @@ class Parser {
   bool canParseTypedPattern();
 
   /// Returns true if a qualified declaration name base type can be parsed.
-  ///
-  /// \verbatim
-  ///   qualified-decl-name-base-type: simple-type-identifier '.'
-  /// \endverbatim
   bool canParseBaseTypeForQualifiedDeclName();
 
   /// Returns true if the current token is '->' or effects specifiers followed

lib/AST/CASTBridging.cpp

@@ -497,14 +497,13 @@ void *TupleTypeRepr_create(void *ctx, BridgedArrayRef elements, void *lParenLoc,
                                SourceRange{lParen, rParen});
 }
 
-void *DeclRefTypeRepr_create(void *ctx, BridgedArrayRef bridgedComponents) {
+void *MemberTypeRepr_create(void *ctx, void *baseComponent,
+                            BridgedArrayRef bridgedMemberComponents) {
   ASTContext &Context = *static_cast<ASTContext *>(ctx);
-  auto components = getArrayRef<IdentTypeRepr *>(bridgedComponents);
-  if (components.size() == 1) {
-    return components.front();
-  }
+  auto memberComponents = getArrayRef<IdentTypeRepr *>(bridgedMemberComponents);
 
-  return MemberTypeRepr::create(Context, components);
+  return MemberTypeRepr::create(Context, (TypeRepr *)baseComponent,
+                                memberComponents);
 }
 
 void *CompositionTypeRepr_create(void *ctx, BridgedArrayRef types,

lib/AST/TypeRepr.cpp

@@ -384,17 +384,20 @@ GenericIdentTypeRepr *GenericIdentTypeRepr::create(const ASTContext &C,
   return new (mem) GenericIdentTypeRepr(Loc, Id, GenericArgs, AngleBrackets);
 }
 
-MemberTypeRepr *
-MemberTypeRepr::create(const ASTContext &C, TypeRepr *Base,
-                       ArrayRef<IdentTypeRepr *> MemberComponents) {
+TypeRepr *MemberTypeRepr::create(const ASTContext &C, TypeRepr *Base,
+                                 ArrayRef<IdentTypeRepr *> MemberComponents) {
+  if (MemberComponents.empty())
+    return Base;
+
   auto size = totalSizeToAlloc<IdentTypeRepr *>(MemberComponents.size());
   auto mem = C.Allocate(size, alignof(MemberTypeRepr));
   return new (mem) MemberTypeRepr(Base, MemberComponents);
 }
 
-MemberTypeRepr *MemberTypeRepr::create(const ASTContext &Ctx,
-                                       ArrayRef<IdentTypeRepr *> Components) {
-  return create(Ctx, Components.front(), Components.drop_front());
+DeclRefTypeRepr *MemberTypeRepr::create(const ASTContext &Ctx,
+                                        ArrayRef<IdentTypeRepr *> Components) {
+  return cast<DeclRefTypeRepr>(
+      create(Ctx, Components.front(), Components.drop_front()));
 }
 
 PackTypeRepr::PackTypeRepr(SourceLoc keywordLoc, SourceRange braceLocs,

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -28,41 +28,40 @@ extension ASTGenVisitor {
   }
 
   public func visit(_ node: MemberTypeIdentifierSyntax) -> ASTNode {
-    var path = [(TokenSyntax, GenericArgumentClauseSyntax?)]()
-    var memberRef: Syntax? = Syntax(node)
-    while let nestedMember = memberRef?.as(MemberTypeIdentifierSyntax.self) {
-      path.append((nestedMember.name, nestedMember.genericArgumentClause))
-      memberRef = Syntax(nestedMember.baseType)
-    }
+    // Gather the member components, in decreasing depth order.
+    var reverseMemberComponents = [UnsafeMutableRawPointer]()
 
-    if let base = memberRef?.as(SimpleTypeIdentifierSyntax.self) {
-      path.append((base.name, base.genericArgumentClause))
-    }
+    var baseType = Syntax(node)
+    while let memberType = baseType.as(MemberTypeIdentifierSyntax.self) {
+      let nameToken = memberType.name
+      let generics = memberType.genericArgumentClause
 
-    var elements = [UnsafeMutableRawPointer]()
-    for (pathElement, generics) in path.reversed() {
-      var nameText = pathElement.text
+      var nameText = nameToken.text
       let name = nameText.withUTF8 { buf in
         return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
       }
-      let nameLoc = self.base.advanced(by: pathElement.position.utf8Offset).raw
+      let nameLoc = self.base.advanced(by: nameToken.position.utf8Offset).raw
 
       if let generics = generics {
         let lAngle = self.base.advanced(by: generics.leftAngleBracket.position.utf8Offset).raw
         let rAngle = self.base.advanced(by: generics.rightAngleBracket.position.utf8Offset).raw
-        elements.append(
+        reverseMemberComponents.append(
           generics.arguments.map({ self.visit($0.argumentType) }).withBridgedArrayRef {
             genericArgs in
             GenericIdentTypeRepr_create(self.ctx, name, nameLoc, genericArgs, lAngle, rAngle)
           })
       } else {
-        elements.append(SimpleIdentTypeRepr_create(self.ctx, nameLoc, name))
+        reverseMemberComponents.append(SimpleIdentTypeRepr_create(self.ctx, nameLoc, name))
       }
+
+      baseType = Syntax(memberType.baseType)
     }
 
+    let baseComponent = visit(baseType).rawValue
+
     return .type(
-      elements.withBridgedArrayRef { elements in
-        return DeclRefTypeRepr_create(self.ctx, elements)
+      reverseMemberComponents.reversed().withBridgedArrayRef { memberComponents in
+        return MemberTypeRepr_create(self.ctx, baseComponent, memberComponents)
       })
   }
 

lib/IDE/CodeCompletion.cpp

@@ -266,8 +266,8 @@ class CodeCompletionCallbacksImpl : public IDEInspectionCallbacks {
 
   void completeTypeDeclResultBeginning() override;
   void completeTypeSimpleBeginning() override;
-  void completeTypeIdentifierWithDot(DeclRefTypeRepr *TR) override;
-  void completeTypeIdentifierWithoutDot(DeclRefTypeRepr *TR) override;
+  void completeTypeSimpleWithDot(TypeRepr *TR) override;
+  void completeTypeSimpleWithoutDot(TypeRepr *TR) override;
 
   void completeCaseStmtKeyword() override;
   void completeCaseStmtBeginning(CodeCompletionExpr *E) override;
@@ -494,21 +494,16 @@ void CodeCompletionCallbacksImpl::completeInPrecedenceGroup(
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completeTypeIdentifierWithDot(
-    DeclRefTypeRepr *TR) {
-  if (!TR) {
-    completeTypeSimpleBeginning();
-    return;
-  }
-  Kind = CompletionKind::TypeIdentifierWithDot;
+void CodeCompletionCallbacksImpl::completeTypeSimpleWithDot(TypeRepr *TR) {
+  assert(TR);
+  Kind = CompletionKind::TypeSimpleWithDot;
   ParsedTypeLoc = TypeLoc(TR);
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completeTypeIdentifierWithoutDot(
-    DeclRefTypeRepr *TR) {
+void CodeCompletionCallbacksImpl::completeTypeSimpleWithoutDot(TypeRepr *TR) {
   assert(TR);
-  Kind = CompletionKind::TypeIdentifierWithoutDot;
+  Kind = CompletionKind::TypeSimpleWithoutDot;
   ParsedTypeLoc = TypeLoc(TR);
   CurDeclContext = P.CurDeclContext;
 }
@@ -953,6 +948,13 @@ addClosureSignatureKeywordsIfApplicable(CodeCompletionResultSink &Sink,
 
 void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
                                               bool MaybeFuncBody) {
+  auto addEffectsSpecifierKeywords = [&] {
+    if (!llvm::is_contained(ParsedKeywords, "async"))
+      addKeyword(Sink, "async", CodeCompletionKeywordKind::None);
+    if (!llvm::is_contained(ParsedKeywords, "throws"))
+      addKeyword(Sink, "throws", CodeCompletionKeywordKind::kw_throws);
+  };
+
   switch (Kind) {
   case CompletionKind::None:
   case CompletionKind::DotExpr:
@@ -974,13 +976,9 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
   case CompletionKind::OptionalBinding:
     break;
 
-  case CompletionKind::EffectsSpecifier: {
-    if (!llvm::is_contained(ParsedKeywords, "async"))
-      addKeyword(Sink, "async", CodeCompletionKeywordKind::None);
-    if (!llvm::is_contained(ParsedKeywords, "throws"))
-      addKeyword(Sink, "throws", CodeCompletionKeywordKind::kw_throws);
+  case CompletionKind::EffectsSpecifier:
+    addEffectsSpecifierKeywords();
     break;
-  }
 
   case CompletionKind::AccessorBeginning: {
     // TODO: Omit already declared or mutally exclusive accessors.
@@ -1037,8 +1035,15 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
 
     break;
   case CompletionKind::CaseStmtBeginning:
-  case CompletionKind::TypeIdentifierWithDot:
-  case CompletionKind::TypeIdentifierWithoutDot:
+  case CompletionKind::TypeSimpleWithDot:
+    break;
+
+  case CompletionKind::TypeSimpleWithoutDot:
+    // Suggest effects specifiers after a tuple type because it may be
+    // intended as a parameter list.
+    if (isa_and_nonnull<TupleTypeRepr>(ParsedTypeLoc.getTypeRepr())) {
+      addEffectsSpecifierKeywords();
+    }
     break;
 
   case CompletionKind::TypeDeclResultBeginning: {
@@ -1241,8 +1246,8 @@ void swift::ide::postProcessCompletionResults(
     if (result->getKind() == CodeCompletionResultKind::Declaration &&
         result->getAssociatedDeclKind() == CodeCompletionDeclKind::Protocol &&
         Kind != CompletionKind::TypeSimpleBeginning &&
-        Kind != CompletionKind::TypeIdentifierWithoutDot &&
-        Kind != CompletionKind::TypeIdentifierWithDot &&
+        Kind != CompletionKind::TypeSimpleWithoutDot &&
+        Kind != CompletionKind::TypeSimpleWithDot &&
         Kind != CompletionKind::TypeDeclResultBeginning &&
         Kind != CompletionKind::GenericRequirement) {
       flair |= CodeCompletionFlairBit::RareTypeAtCurrentPosition;
@@ -1597,7 +1602,7 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
     return;
 
   undoSingleExpressionReturn(CurDeclContext);
-  if (Kind != CompletionKind::TypeIdentifierWithDot) {
+  if (Kind != CompletionKind::TypeSimpleWithDot) {
     // Type member completion does not need a type-checked AST.
     typeCheckContextAt(
         TypeCheckASTNodeAtLocContext::declContext(CurDeclContext),
@@ -1753,13 +1758,13 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
     break;
   }
 
-  case CompletionKind::TypeIdentifierWithDot: {
+  case CompletionKind::TypeSimpleWithDot: {
     Lookup.setHaveDot(SourceLoc());
     Lookup.getTypeCompletions(ParsedTypeLoc.getType());
     break;
   }
 
-  case CompletionKind::TypeIdentifierWithoutDot: {
+  case CompletionKind::TypeSimpleWithoutDot: {
     Lookup.getTypeCompletions(ParsedTypeLoc.getType());
     break;
   }

lib/Parse/ParseDecl.cpp

@@ -1434,7 +1434,7 @@ static Optional<AccessorKind> isAccessorLabel(const Token &token) {
   return None;
 }
 
-/// Helper function that parses 'type-identifier' for `parseQualifiedDeclName`.
+/// Helper function that parses a base type for `parseQualifiedDeclName`.
 /// Returns true on error. Sets `baseType` to the parsed base type if present,
 /// or to `nullptr` if not. A missing base type is not considered an error.
 static bool parseBaseTypeForQualifiedDeclName(Parser &P, TypeRepr *&baseType) {
@@ -1445,15 +1445,15 @@ static bool parseBaseTypeForQualifiedDeclName(Parser &P, TypeRepr *&baseType) {
   if (!P.canParseBaseTypeForQualifiedDeclName())
     return false;
 
-  auto result = P.parseTypeIdentifier(/*isParsingQualifiedDeclName*/ true);
+  auto result = P.parseQualifiedDeclNameBaseType();
   // If base type should be parseable but the actual base type result is null,
   // return true (error).
   if (result.isNull())
     return true;
 
   // Consume the leading period before the final declaration name component.
-  // `parseTypeIdentifier(/*isParsingQualifiedDeclName*/ true)` leaves the
-  // leading period unparsed to avoid syntax verification errors.
+  // `parseQualifiedDeclNameBaseType` leaves the leading period unparsed to
+  // avoid syntax verification errors.
   assert(P.startsWithSymbol(P.Tok, '.') && "false");
 
   // Check if this is a reference to a property or subscript accessor.
@@ -1489,9 +1489,7 @@ static bool parseBaseTypeForQualifiedDeclName(Parser &P, TypeRepr *&baseType) {
 ///
 /// \verbatim
 ///   qualified-decl-name:
-///     type-identifier? unqualified-decl-name
-///   type-identifier:
-///     identifier generic-args? ('.' identifier generic-args?)*
+///     qualified-decl-name-base-type? unqualified-decl-name
 /// \endverbatim
 ///
 // TODO(TF-1066): Use module qualified name syntax/parsing instead of custom