[NFC] Parse: Refactor for recursive MemberTypeRepr representation

Author: AnthonyLatsis

include/swift/AST/TypeRepr.h

@@ -336,6 +336,14 @@ class DeclRefTypeRepr : public TypeRepr {
   explicit DeclRefTypeRepr(TypeReprKind K) : TypeRepr(K) {}
 
 public:
+  static DeclRefTypeRepr *create(const ASTContext &C, TypeRepr *Base,
+                                 DeclNameLoc NameLoc, DeclNameRef Name);
+
+  static DeclRefTypeRepr *create(const ASTContext &C, TypeRepr *Base,
+                                 DeclNameLoc NameLoc, DeclNameRef Name,
+                                 ArrayRef<TypeRepr *> GenericArgs,
+                                 SourceRange AngleBrackets);
+
   /// Returns the root qualifier. For example, `A` for `A.B.C`. The root
   /// qualifier of a `IdentTypeRepr` is itself.
   TypeRepr *getRoot();

include/swift/Parse/Parser.h

@@ -1463,12 +1463,13 @@ class Parser {
   /// \endverbatim
   ParserResult<TypeRepr> parseQualifiedDeclNameBaseType();
 
-  /// Parse an identifier type, e.g 'Foo' or 'Bar<Int>'.
+  /// Parse a single type identifier, possibly followed by a generic argument
+  /// list, e.g `Foo` or `Bar<Int>`.
   ///
   /// \verbatim
   /// type-identifier: identifier generic-args?
   /// \endverbatim
-  ParserResult<IdentTypeRepr> parseTypeIdentifier();
+  ParserResult<DeclRefTypeRepr> parseTypeIdentifier(TypeRepr *Base);
 
   /// Parse a dotted type, e.g. 'Foo<X>.Y.Z', 'P.Type', '[X].Y'.
   ParserResult<TypeRepr> parseTypeDotted(ParserResult<TypeRepr> Base);

lib/AST/TypeRepr.cpp

@@ -154,6 +154,43 @@ SourceLoc TypeRepr::findAttrLoc(TypeAttrKind kind) const {
   return SourceLoc();
 }
 
+DeclRefTypeRepr *DeclRefTypeRepr::create(const ASTContext &C, TypeRepr *Base,
+                                         DeclNameLoc NameLoc,
+                                         DeclNameRef Name) {
+  return create(C, Base, NameLoc, Name, {}, SourceRange());
+}
+
+DeclRefTypeRepr *DeclRefTypeRepr::create(const ASTContext &C, TypeRepr *Base,
+                                         DeclNameLoc NameLoc, DeclNameRef Name,
+                                         ArrayRef<TypeRepr *> GenericArgs,
+                                         SourceRange AngleBrackets) {
+  IdentTypeRepr *identTR = nullptr;
+  if (AngleBrackets.isInvalid() && GenericArgs.empty()) {
+    identTR = new (C) SimpleIdentTypeRepr(NameLoc, Name);
+  } else {
+    identTR = GenericIdentTypeRepr::create(C, NameLoc, Name, GenericArgs,
+                                           AngleBrackets);
+  }
+
+  if (Base) {
+    if (auto *memberTR = dyn_cast<MemberTypeRepr>(Base)) {
+      llvm::SmallVector<IdentTypeRepr *> newComponents;
+      {
+        auto components = memberTR->getMemberComponents();
+        newComponents.append(components.begin(), components.end());
+      }
+      newComponents.push_back(identTR);
+
+      return cast<DeclRefTypeRepr>(
+          MemberTypeRepr::create(C, memberTR->getRoot(), newComponents));
+    } else {
+      return cast<DeclRefTypeRepr>(MemberTypeRepr::create(C, Base, {identTR}));
+    }
+  } else {
+    return identTR;
+  }
+}
+
 TypeRepr *DeclRefTypeRepr::getRoot() {
   return const_cast<TypeRepr *>(
       const_cast<const DeclRefTypeRepr *>(this)->getRoot());

lib/Parse/ParseType.cpp

@@ -203,11 +203,11 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
           status, PackTypeRepr::create(Context, keywordLoc,
                                        SourceRange(lbLoc, rbLoc), elements));
     } else {
-      ty = parseTypeIdentifier();
-      if (auto *ITR = cast_or_null<IdentTypeRepr>(ty.getPtrOrNull())) {
+      ty = parseTypeIdentifier(/*Base=*/nullptr);
+      if (auto *repr = ty.getPtrOrNull()) {
         if (Tok.is(tok::code_complete) && !Tok.isAtStartOfLine()) {
           if (CodeCompletionCallbacks) {
-            CodeCompletionCallbacks->completeTypeSimpleWithoutDot(ITR);
+            CodeCompletionCallbacks->completeTypeSimpleWithoutDot(repr);
           }
 
           ty.setHasCodeCompletionAndIsError();
@@ -771,14 +771,14 @@ ParserResult<TypeRepr> Parser::parseQualifiedDeclNameBaseType() {
   }
 
   ParserStatus Status;
-  SmallVector<IdentTypeRepr *, 4> ComponentsR;
+  DeclRefTypeRepr *Result = nullptr;
   SourceLoc EndLoc;
   while (true) {
-    auto IdentResult = parseTypeIdentifier();
-    if (IdentResult.isParseErrorOrHasCompletion())
-      return IdentResult;
+    auto PartialResult = parseTypeIdentifier(/*Base=*/Result);
+    if (PartialResult.isParseErrorOrHasCompletion())
+      return PartialResult;
 
-    ComponentsR.push_back(cast<IdentTypeRepr>(IdentResult.get()));
+    Result = PartialResult.get();
 
     // Treat 'Foo.<anything>' as an attempt to write a dotted type
     // unless <anything> is 'Type'.
@@ -811,31 +811,26 @@ ParserResult<TypeRepr> Parser::parseQualifiedDeclNameBaseType() {
     break;
   }
 
-  DeclRefTypeRepr *DeclRefTR = nullptr;
-  if (!ComponentsR.empty()) {
-    DeclRefTR = MemberTypeRepr::create(Context, ComponentsR);
-  }
-
   if (Status.hasCodeCompletion()) {
     if (Tok.isNot(tok::code_complete)) {
       // We have a dot.
       consumeToken();
       if (CodeCompletionCallbacks) {
-        CodeCompletionCallbacks->completeTypeSimpleWithDot(DeclRefTR);
+        CodeCompletionCallbacks->completeTypeSimpleWithDot(Result);
       }
     } else {
       if (CodeCompletionCallbacks) {
-        CodeCompletionCallbacks->completeTypeSimpleWithoutDot(DeclRefTR);
+        CodeCompletionCallbacks->completeTypeSimpleWithoutDot(Result);
       }
     }
     // Eat the code completion token because we handled it.
     consumeToken(tok::code_complete);
   }
 
-  return makeParserResult(Status, DeclRefTR);
+  return makeParserResult(Status, Result);
 }
 
-ParserResult<IdentTypeRepr> Parser::parseTypeIdentifier() {
+ParserResult<DeclRefTypeRepr> Parser::parseTypeIdentifier(TypeRepr *Base) {
   // FIXME: We should parse e.g. 'X.var'. Almost any keyword is a valid member
   // component.
   DeclNameLoc Loc;
@@ -846,7 +841,7 @@ ParserResult<IdentTypeRepr> Parser::parseTypeIdentifier() {
     return makeParserError();
 
   ParserStatus Status;
-  IdentTypeRepr *IdTR;
+  DeclRefTypeRepr *Result;
 
   if (startsWithLess(Tok)) {
     SourceLoc LAngle, RAngle;
@@ -855,20 +850,20 @@ ParserResult<IdentTypeRepr> Parser::parseTypeIdentifier() {
     if (ArgsStatus.isErrorOrHasCompletion())
       return ArgsStatus;
 
-    IdTR = GenericIdentTypeRepr::create(Context, Loc, Name, GenericArgs,
-                                        SourceRange(LAngle, RAngle));
+    Result = DeclRefTypeRepr::create(Context, Base, Loc, Name, GenericArgs,
+                                     SourceRange(LAngle, RAngle));
   } else {
-    IdTR = new (Context) SimpleIdentTypeRepr(Loc, Name);
+    Result = DeclRefTypeRepr::create(Context, Base, Loc, Name);
   }
 
-  return makeParserResult(IdTR);
+  return makeParserResult(Result);
 }
 
 ParserResult<TypeRepr> Parser::parseTypeDotted(ParserResult<TypeRepr> Base) {
   assert(Base.isNonNull());
   assert(Tok.isAny(tok::period, tok::period_prefix));
 
-  SmallVector<IdentTypeRepr *, 4> MemberComponents;
+  TypeRepr *Result = Base.get();
 
   while (Tok.isAny(tok::period, tok::period_prefix)) {
     if (peekToken().is(tok::code_complete)) {
@@ -881,32 +876,25 @@ ParserResult<TypeRepr> Parser::parseTypeDotted(ParserResult<TypeRepr> Base) {
 
     if (Tok.isContextualKeyword("Type") ||
         Tok.isContextualKeyword("Protocol")) {
-      TypeRepr *MetaBase =
-          MemberTypeRepr::create(Context, Base.get(), MemberComponents);
       if (Tok.getRawText() == "Type") {
-        Base = makeParserResult(Base,
-                                new (Context) MetatypeTypeRepr(
-                                    MetaBase, consumeToken(tok::identifier)));
+        Result = new (Context)
+            MetatypeTypeRepr(Result, consumeToken(tok::identifier));
       } else {
-        Base = makeParserResult(Base,
-                                new (Context) ProtocolTypeRepr(
-                                    MetaBase, consumeToken(tok::identifier)));
+        Result = new (Context)
+            ProtocolTypeRepr(Result, consumeToken(tok::identifier));
       }
 
-      // Start anew with a metatype base.
-      MemberComponents.clear();
       continue;
     }
 
-    auto IdentResult = parseTypeIdentifier();
-    if (IdentResult.isParseErrorOrHasCompletion())
-      return IdentResult | ParserStatus(Base);
+    auto PartialResult = parseTypeIdentifier(/*Base=*/Result);
+    if (PartialResult.isParseErrorOrHasCompletion())
+      return PartialResult | ParserStatus(Base);
 
-    MemberComponents.push_back(cast<IdentTypeRepr>(IdentResult.get()));
+    Result = PartialResult.get();
   }
 
-  return makeParserResult(
-      Base, MemberTypeRepr::create(Context, Base.get(), MemberComponents));
+  return makeParserResult(Base, Result);
 }
 
 /// parseTypeSimpleOrComposition