[NFC] ASTGen: Refactor for recursive MemberTypeRepr representation

Author: AnthonyLatsis

include/swift/AST/ASTBridging.h

@@ -1569,11 +1569,11 @@ BridgedInverseTypeRepr_createParsed(BridgedASTContext cContext,
                                     BridgedSourceLoc cTildeLoc,
                                     BridgedTypeRepr cConstraint);
 
-SWIFT_NAME("BridgedMemberTypeRepr.createParsed(_:base:members:)")
-BridgedTypeRepr
-BridgedMemberTypeRepr_createParsed(BridgedASTContext cContext,
-                                   BridgedTypeRepr baseComponent,
-                                   BridgedArrayRef bridgedMemberComponents);
+SWIFT_NAME("BridgedDeclRefTypeRepr.createParsed(_:base:name:nameLoc:genericArguments:angleRange:)")
+BridgedDeclRefTypeRepr BridgedDeclRefTypeRepr_createParsed(
+    BridgedASTContext cContext, BridgedTypeRepr cBase, BridgedIdentifier cName,
+    BridgedSourceLoc cLoc, BridgedArrayRef cGenericArguments,
+    BridgedSourceRange cAngleRange);
 
 SWIFT_NAME("BridgedMetatypeTypeRepr.createParsed(_:base:typeKeywordLoc:)")
 BridgedMetatypeTypeRepr

include/swift/Basic/BasicBridging.h

@@ -292,6 +292,8 @@ class BridgedSourceRange {
   SWIFT_NAME("end")
   BridgedSourceLoc End;
 
+  BridgedSourceRange() : Start(), End() {}
+
   SWIFT_NAME("init(start:end:)")
   BridgedSourceRange(BridgedSourceLoc start, BridgedSourceLoc end)
       : Start(start), End(end) {}

lib/AST/ASTBridging.cpp

@@ -2225,15 +2225,19 @@ BridgedTupleTypeRepr BridgedTupleTypeRepr_createParsed(
                                SourceRange{lParen, rParen});
 }
 
-BridgedTypeRepr
-BridgedMemberTypeRepr_createParsed(BridgedASTContext cContext,
-                                   BridgedTypeRepr baseComponent,
-                                   BridgedArrayRef bridgedMemberComponents) {
+BridgedDeclRefTypeRepr BridgedDeclRefTypeRepr_createParsed(
+    BridgedASTContext cContext, BridgedTypeRepr cBase, BridgedIdentifier cName,
+    BridgedSourceLoc cLoc, BridgedArrayRef cGenericArguments,
+    BridgedSourceRange cAngleRange) {
   ASTContext &context = cContext.unbridged();
-  auto memberComponents = bridgedMemberComponents.unbridged<IdentTypeRepr *>();
+  auto genericArguments = cGenericArguments.unbridged<TypeRepr *>();
+  auto angleRange = cAngleRange.unbridged();
 
-  return MemberTypeRepr::create(context, baseComponent.unbridged(),
-                                memberComponents);
+  assert(angleRange.isValid() || genericArguments.empty());
+
+  return DeclRefTypeRepr::create(
+      context, cBase.unbridged(), DeclNameLoc(cLoc.unbridged()),
+      DeclNameRef(cName.unbridged()), genericArguments, angleRange);
 }
 
 BridgedCompositionTypeRepr

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -82,7 +82,7 @@ extension ASTGenVisitor {
     case .implicitlyUnwrappedOptionalType(let node):
       return self.generate(implicitlyUnwrappedOptionalType: node).asTypeRepr
     case .memberType(let node):
-      return self.generate(memberType: node)
+      return self.generate(memberType: node).asTypeRepr
     case .metatypeType(let node):
       return self.generate(metatypeType: node)
     case .missingType:
@@ -137,45 +137,29 @@ extension ASTGenVisitor {
     ).asTypeRepr
   }
 
-  func generate(memberType node: MemberTypeSyntax) -> BridgedTypeRepr {
-    // Gather the member components, in decreasing depth order.
-    var reverseMemberComponents = [BridgedTypeRepr]()
+  func generate(memberType node: MemberTypeSyntax) -> BridgedDeclRefTypeRepr {
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
-    var baseType = TypeSyntax(node)
-    while let memberType = baseType.as(MemberTypeSyntax.self) {
-      let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
+    let genericArguments: BridgedArrayRef
+    let angleRange: BridgedSourceRange
+    if let generics = node.genericArgumentClause {
+      genericArguments = generics.arguments.lazy.map {
+        self.generate(type: $0.argument)
+      }.bridgedArray(in: self)
 
-      if let generics = memberType.genericArgumentClause {
-        let genericArguments = generics.arguments.lazy.map {
-          self.generate(type: $0.argument)
-        }
-
-        reverseMemberComponents.append(
-          BridgedGenericIdentTypeRepr.createParsed(
-            self.ctx,
-            name: name,
-            nameLoc: nameLoc,
-            genericArgs: genericArguments.bridgedArray(in: self),
-            leftAngleLoc: self.generateSourceLoc(generics.leftAngle),
-            rightAngleLoc: self.generateSourceLoc(generics.rightAngle)
-          ).asTypeRepr
-        )
-      } else {
-        reverseMemberComponents.append(
-          BridgedSimpleIdentTypeRepr.createParsed(self.ctx, loc: nameLoc, name: name).asTypeRepr
-        )
-      }
-
-      baseType = memberType.baseType
+      angleRange = self.generateSourceRange(start: generics.leftAngle, end: generics.rightAngle)
+    } else {
+      genericArguments = .init()
+      angleRange = .init()
     }
 
-    let baseComponent = generate(type: baseType)
-    let memberComponents = reverseMemberComponents.reversed().bridgedArray(in: self)
-
-    return BridgedMemberTypeRepr.createParsed(
+    return BridgedDeclRefTypeRepr.createParsed(
       self.ctx,
-      base: baseComponent,
-      members: memberComponents
+      base: self.generate(type: node.baseType),
+      name: name,
+      nameLoc: nameLoc,
+      genericArguments: genericArguments,
+      angleRange: angleRange
     )
   }