[ASTGen] Misc fixes

include/swift/AST/ASTBridging.h

@@ -2885,29 +2885,27 @@ struct BridgedRequirementRepr {
   BridgedNullableTypeRepr SecondType;
   BridgedLayoutConstraint LayoutConstraint;
   BridgedSourceLoc LayoutConstraintLoc;
-
-  // TODO: bool IsExpansionPattern;
+  bool IsExpansionPattern;
 
   swift::RequirementRepr unbridged() const;
 };
 
-SWIFT_NAME(
-    "BridgedRequirementRepr.createTypeConstraint(subject:colonLoc:constraint:)")
-BridgedRequirementRepr
-BridgedRequirementRepr_createTypeConstraint(BridgedTypeRepr cSubject,
-                                            BridgedSourceLoc cColonLoc,
-                                            BridgedTypeRepr cConstraint);
-SWIFT_NAME(
-    "BridgedRequirementRepr.createSameType(firstType:equalLoc:secondType:)")
-BridgedRequirementRepr
-BridgedRequirementRepr_createSameType(BridgedTypeRepr cFirstType,
-                                      BridgedSourceLoc cEqualLoc,
-                                      BridgedTypeRepr cSecondType);
+SWIFT_NAME("BridgedRequirementRepr.createTypeConstraint(subject:colonLoc:"
+           "constraint:isExpansionPattern:)")
+BridgedRequirementRepr BridgedRequirementRepr_createTypeConstraint(
+    BridgedTypeRepr cSubject, BridgedSourceLoc cColonLoc,
+    BridgedTypeRepr cConstraint, bool isExpansionPattern);
+SWIFT_NAME("BridgedRequirementRepr.createSameType(firstType:equalLoc:"
+           "secondType:isExpansionPattern:)")
+BridgedRequirementRepr BridgedRequirementRepr_createSameType(
+    BridgedTypeRepr cFirstType, BridgedSourceLoc cEqualLoc,
+    BridgedTypeRepr cSecondType, bool isExpansionPattern);
 SWIFT_NAME("BridgedRequirementRepr.createLayoutConstraint(subject:colonLoc:"
-           "layout:layoutLoc:)")
+           "layout:layoutLoc:isExpansionPattern:)")
 BridgedRequirementRepr BridgedRequirementRepr_createLayoutConstraint(
     BridgedTypeRepr cSubject, BridgedSourceLoc cColonLoc,
-    BridgedLayoutConstraint cLayout, BridgedSourceLoc cLayoutLoc);
+    BridgedLayoutConstraint cLayout, BridgedSourceLoc cLayoutLoc,
+    bool isExpansionPattern);
 
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedGenericTypeParamKind : size_t {
   /// A regular generic type parameter: 'T'

lib/AST/Bridging/GenericsBridging.cpp

@@ -101,57 +101,59 @@ RequirementRepr BridgedRequirementRepr::unbridged() const {
   case BridgedRequirementReprKindTypeConstraint:
     return RequirementRepr::getTypeConstraint(
         FirstType.unbridged(), SeparatorLoc.unbridged(), SecondType.unbridged(),
-        /*IsExpansionPattern=*/false);
+        IsExpansionPattern);
   case BridgedRequirementReprKindSameType:
     return RequirementRepr::getSameType(
         FirstType.unbridged(), SeparatorLoc.unbridged(), SecondType.unbridged(),
-        /*IsExpansionPattern=*/false);
+        IsExpansionPattern);
   case BridgedRequirementReprKindLayoutConstraint:
     return RequirementRepr::getLayoutConstraint(
         FirstType.unbridged(), SeparatorLoc.unbridged(),
         {LayoutConstraint.unbridged(), LayoutConstraintLoc.unbridged()},
-        /*IsExpansionPattern=*/false);
+        IsExpansionPattern);
   }
 }
 
-BridgedRequirementRepr
-BridgedRequirementRepr_createTypeConstraint(BridgedTypeRepr cSubject,
-                                            BridgedSourceLoc cColonLoc,
-                                            BridgedTypeRepr cConstraint) {
+BridgedRequirementRepr BridgedRequirementRepr_createTypeConstraint(
+    BridgedTypeRepr cSubject, BridgedSourceLoc cColonLoc,
+    BridgedTypeRepr cConstraint, bool isExpansionPattern) {
   return {
       /*SeparatorLoc=*/cColonLoc,
       /*Kind=*/BridgedRequirementReprKindTypeConstraint,
       /*FirstType=*/cSubject,
       /*SecondType=*/cConstraint.unbridged(),
       /*LayoutConstraint=*/{},
       /*LayoutConstraintLoc=*/{},
+      /*IsExpansionPattern=*/isExpansionPattern,
   };
 }
 
-BridgedRequirementRepr
-BridgedRequirementRepr_createSameType(BridgedTypeRepr cFirstType,
-                                      BridgedSourceLoc cEqualLoc,
-                                      BridgedTypeRepr cSecondType) {
+BridgedRequirementRepr BridgedRequirementRepr_createSameType(
+    BridgedTypeRepr cFirstType, BridgedSourceLoc cEqualLoc,
+    BridgedTypeRepr cSecondType, bool isExpansionPattern) {
   return {
       /*SeparatorLoc=*/cEqualLoc,
       /*Kind=*/BridgedRequirementReprKindSameType,
       /*FirstType=*/cFirstType,
       /*SecondType=*/cSecondType.unbridged(),
       /*LayoutConstraint=*/{},
       /*LayoutConstraintLoc=*/{},
+      /*IsExpansionPattern=*/isExpansionPattern,
   };
 }
 
 BridgedRequirementRepr BridgedRequirementRepr_createLayoutConstraint(
     BridgedTypeRepr cSubject, BridgedSourceLoc cColonLoc,
-    BridgedLayoutConstraint cLayout, BridgedSourceLoc cLayoutLoc) {
+    BridgedLayoutConstraint cLayout, BridgedSourceLoc cLayoutLoc,
+    bool isExpansionPattern) {
   return {
       /*SeparatorLoc=*/cColonLoc,
       /*Kind=*/BridgedRequirementReprKindLayoutConstraint,
       /*FirstType=*/cSubject,
       /*SecondType=*/nullptr,
       /*LayoutConstraint=*/cLayout,
       /*LayoutConstraintLoc=*/cLayoutLoc,
+      /*IsExpansionPattern=*/isExpansionPattern,
   };
 }
 

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -189,6 +189,10 @@ extension ASTGenVisitor {
         return handle(self.generateUnavailableFromAsyncAttr(attribute: node)?.asDeclAttribute)
       case .none where attrName == "_unavailableInEmbedded":
         return handle(self.generateUnavailableInEmbeddedAttr(attribute: node)?.asDeclAttribute)
+      case .none where attrName == "_functionBuilder":
+        // TODO: Diagnostics. '_functionBuilder' is renamed to 'resultBuilder'
+        return handle(self.generateSimpleDeclAttr(attribute: node, kind: .resultBuilder))
+
 
       // Simple attributes.
       case .addressableSelf,
@@ -1682,7 +1686,7 @@ extension ASTGenVisitor {
           return nil
         }
 
-        guard let moveAsLike = args.isEmpty ? false : generateConsumingMoveAsLike() else {
+        guard let moveAsLike = args.isEmpty ? false : generateConsumingMovesAsLike() else {
           return nil
         }
 
@@ -1711,7 +1715,7 @@ extension ASTGenVisitor {
           return nil
         }
 
-        guard let moveAsLike = args.isEmpty ? false : generateConsumingMoveAsLike() else {
+        guard let moveAsLike = args.isEmpty ? false : generateConsumingMovesAsLike() else {
           return nil
         }
 
@@ -1738,10 +1742,10 @@ extension ASTGenVisitor {
         }
       }
 
-      func generateConsumingMoveAsLike() -> Bool? {
+      func generateConsumingMovesAsLike() -> Bool? {
         self.generateConsumingPlainIdentifierAttrOption(args: &args) {
           switch $0.rawText {
-          case "moveAsLike":
+          case "movesAsLike":
             return true
           default:
             // TODO: Diagnose.

lib/ASTGen/Sources/ASTGen/Generics.swift

@@ -111,25 +111,41 @@ extension ASTGenVisitor {
 
   func generate(genericWhereClause node: GenericWhereClauseSyntax) -> BridgedTrailingWhereClause {
     let requirements  = node.requirements.lazy.map { elem -> BridgedRequirementRepr in
+
+      // Unwrap 'repeat T' to  (isRequirementExpansion: true, type: T)
+      func generateIsExpansionPattern<Node: SyntaxProtocol>(type node: Node) -> (isExpansionPattern: Bool, type: Node) {
+        if let expansion = node.as(PackExpansionTypeSyntax.self) {
+          // Force unwrapping is safe because both 'TypeSyntax' and 'SameTypeRequirementSyntax.LeftType' accept 'TypeSyntax'.
+          return (true, Node(expansion.repetitionPattern)!)
+        }
+        return (false, node)
+      }
+
       switch elem.requirement {
       case .conformanceRequirement(let conformance):
+        let (isExpansionPattern, leftType) = generateIsExpansionPattern(type: conformance.leftType)
         return .createTypeConstraint(
-          subject: self.generate(type: conformance.leftType),
+          subject: self.generate(type: leftType),
           colonLoc: self.generateSourceLoc(conformance.colon),
-          constraint: self.generate(type: conformance.rightType)
+          constraint: self.generate(type: conformance.rightType),
+          isExpansionPattern: isExpansionPattern
         )
       case .sameTypeRequirement(let sameType):
+        let (isExpansionPattern, leftType) = generateIsExpansionPattern(type: sameType.leftType)
         return .createSameType(
-          firstType: self.generate(sameTypeLeftType: sameType.leftType),
+          firstType: self.generate(sameTypeLeftType: leftType),
           equalLoc: self.generateSourceLoc(sameType.equal),
-          secondType: self.generate(sameTypeRightType: sameType.rightType)
+          secondType: self.generate(sameTypeRightType: sameType.rightType),
+          isExpansionPattern: isExpansionPattern
         )
       case .layoutRequirement(let layout):
+        let (isExpansionPattern, leftType) = generateIsExpansionPattern(type: layout.type)
         return .createLayoutConstraint(
-          subject: self.generate(type: layout.type),
+          subject: self.generate(type: leftType),
           colonLoc: self.generateSourceLoc(layout.colon),
           layout: self.generate(layoutRequirement: layout),
-          layoutLoc: self.generateSourceLoc(layout.layoutSpecifier)
+          layoutLoc: self.generateSourceLoc(layout.layoutSpecifier),
+          isExpansionPattern: isExpansionPattern
         )
       }
     }

test/ASTGen/attrs.swift

@@ -240,6 +240,7 @@ struct ReferenceOwnershipModifierTest<X: AnyObject> {
 }
 
 @_rawLayout(like: T) struct RawStorage<T>: ~Copyable {}
+@_rawLayout(like: T, movesAsLike) struct RawStorage2<T>: ~Copyable {}
 @_rawLayout(likeArrayOf: T, count: 4) struct RawSmallArray<T>: ~Copyable {}
 @_rawLayout(size: 4, alignment: 4) struct Lock: ~Copyable {}
 

test/ASTGen/decls.swift

@@ -346,3 +346,5 @@ func testBuilder() {
     1
   }
 }
+
+struct ExpansionRequirementTest<each T> where repeat each T: Comparable {}

test/ASTGen/diagnostics.swift

@@ -33,3 +33,6 @@ struct S {
     subscript(x: Int) { _ = 1 } // expected-error@:23 {{expected '->' and return type in subscript}}
                                 // expected-note@-1:23 {{insert '->' and return type}}
 }
+
+struct ExpansionRequirementTest<each T> {}
+extension ExpansionRequirementTest where repeat each T == Int {} // expected-error {{same-element requirements are not yet supported}}