[ASTGen] Handle composition types parsed through parseType().

Protocol composition types such as `P & Q` are similar to nested types
like `A.B` because the innermost type syntax node at the given position
doesn't cover the whole type. Adjust by looking back up the tree.
This all feels like a hack, and there should be a better way.

While here, fix the source ranges passed in to create
`CompositionTypeRepr`. We were tripping assertions due to missing
source-location information.

Author: DougGregor

include/swift/AST/CASTBridging.h

@@ -348,7 +348,7 @@ void *GenericIdentTypeRepr_create(void *ctx, BridgedIdentifier name,
                                   void *lAngle, void *rAngle);
 void *EmptyCompositionTypeRepr_create(void *ctx, void *anyLoc);
 void *CompositionTypeRepr_create(void *ctx, BridgedArrayRef types,
-                                 void *firstTypeLoc);
+                                 void *firstTypeLoc, void *firstAmpLoc);
 void *FunctionTypeRepr_create(void *ctx, void *argsTy, void *_Nullable asyncLoc,
                               void *_Nullable throwsLoc, void *arrowLoc,
                               void *returnType);

lib/AST/CASTBridging.cpp

@@ -611,12 +611,15 @@ void *EmptyCompositionTypeRepr_create(void *ctx, void *anyLocPtr) {
   return CompositionTypeRepr::createEmptyComposition(Context, anyLoc);
 }
 
-void *CompositionTypeRepr_create(void *ctx, BridgedArrayRef types,
-                                 void *firstTypeLoc) {
+void *CompositionTypeRepr_create(void *ctx, BridgedArrayRef typesPtr,
+                                 void *firstTypeLoc, void *firstAmpLocPtr) {
   ASTContext &Context = *static_cast<ASTContext *>(ctx);
   SourceLoc firstType = getSourceLocFromPointer(firstTypeLoc);
-  return CompositionTypeRepr::create(Context, getArrayRef<TypeRepr *>(types),
-                                     firstType, SourceRange{});
+  SourceLoc firstAmpLoc = getSourceLocFromPointer(firstAmpLocPtr);
+  auto types = getArrayRef<TypeRepr *>(typesPtr);
+  return CompositionTypeRepr::create(
+      Context, types, firstType,
+      SourceRange{firstAmpLoc, types.back()->getEndLoc()});
 }
 
 void *FunctionTypeRepr_create(void *ctx, void *argsTy, void *_Nullable asyncLoc,

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -682,8 +682,18 @@ func findSyntaxNodeInSourceFile<Node: SyntaxProtocol>(
   }
 
   // If we want the outermost node, keep looking.
+  // FIXME: This is VERY SPECIFIC to handling of types. We must be able to
+  // do better.
   if wantOutermost {
     while let parentSyntax = resultSyntax.parent {
+      // Look through type compositions.
+      if let compositionElement = parentSyntax.as(CompositionTypeElementSyntax.self),
+         let compositionList = compositionElement.parent?.as(CompositionTypeElementListSyntax.self),
+         let typedParent = compositionList.parent?.as(type) {
+        resultSyntax = typedParent
+        continue
+      }
+
       guard let typedParent = parentSyntax.as(type),
             typedParent.position == resultSyntax.position else {
         break

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -128,9 +128,11 @@ extension ASTGenVisitor {
     assert(node.elements.count > 1)
     let types = node.elements.map { visit($0.type) }.map { $0.rawValue }
     let firstTypeLoc = self.base.advanced(by: node.elements.first!.type.position.utf8Offset).raw
+    let firstAmpOffset = node.elements.first?.ampersand.map { $0.position.utf8Offset } ?? 0
+    let firstAmpLoc = self.base.advanced(by: firstAmpOffset).raw
     return .type(
       types.withBridgedArrayRef { types in
-        return CompositionTypeRepr_create(self.ctx, types, firstTypeLoc)
+        return CompositionTypeRepr_create(self.ctx, types, firstTypeLoc, firstAmpLoc)
       })
   }
 

test/ASTGen/types.swift

@@ -3,6 +3,9 @@
 // -enable-experimental-feature requires an asserts build
 // REQUIRES: asserts
 
+protocol P { }
+protocol Q { }
+typealias PQ = P & Q
 
 func test7(_ b: inout Bool) {
   b = true