Start Lowering Generic ASTs

CodaFi · DougGregor · commit 032e8d5e1d2d · 2022-10-27T11:11:11.000-07:00
Lower generic argument lists and generic parameter lists, then expand the lowering for identifiers to take generic arguments into account.
diff --git a/include/swift/AST/CASTBridging.h b/include/swift/AST/CASTBridging.h
@@ -58,6 +58,33 @@ typedef struct {
   void *Type;
   void *_Nullable TrailingCommaLoc;
 } BridgedTupleTypeElement;
+
+typedef enum __attribute__((enum_extensibility(open))) BridgedRequirementReprKind : long {
+  /// A type bound T : P, where T is a type that depends on a generic
+  /// parameter and P is some type that should bound T, either as a concrete
+  /// supertype or a protocol to which T must conform.
+  BridgedRequirementReprKindTypeConstraint,
+
+  /// A same-type requirement T == U, where T and U are types that shall be
+  /// equivalent.
+  BridgedRequirementReprKindSameType,
+
+  /// A layout bound T : L, where T is a type that depends on a generic
+  /// parameter and L is some layout specification that should bound T.
+  BridgedRequirementReprKindLayoutConstraint,
+
+  // Note: there is code that packs this enum in a 2-bit bitfield.  Audit users
+  // when adding enumerators.
+} BridgedRequirementReprKind;
+
+typedef struct {
+  void *_Nullable SeparatorLoc;
+  BridgedRequirementReprKind Kind;
+  void *FirstType;
+  void *SecondType;
+  // FIXME: Handle Layout Requirements
+} BridgedRequirementRepr;
+
 #ifdef __cplusplus
 extern "C" {
 
@@ -133,7 +160,7 @@ struct DeclContextAndDecl {
 };
 
 struct DeclContextAndDecl StructDecl_create(
-    void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *dc);
+    void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *_Nullable genericParams, void *dc);
 struct DeclContextAndDecl ClassDecl_create(
     void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *dc);
 
@@ -152,11 +179,19 @@ void *FunctionTypeRepr_create(void *ctx, void *argsTy, void *_Nullable asyncLoc,
 void *NamedOpaqueReturnTypeRepr_create(void *ctx, void *baseTy);
 void *OpaqueReturnTypeRepr_create(void *ctx, void *opaqueLoc, void *baseTy);
 void *ExistentialTypeRepr_create(void *ctx, void *anyLoc, void *baseTy);
+void *GenericParamList_create(void *ctx, void *lAngleLoc, BridgedArrayRef params, void *_Nullable whereLoc, BridgedArrayRef reqs, void *rAngleLoc);
+void *GenericTypeParamDecl_create(void *ctx, void *declContext, BridgedIdentifier name, void *nameLoc, void *_Nullable ellipsisLoc, long index, _Bool isParameterPack);
+void GenericTypeParamDecl_setInheritedType(void *ctx, void *Param, void *ty);
+
+struct DeclContextAndDecl TypeAliasDecl_create(void *ctx, void *declContext, void *aliasLoc, void *equalLoc, BridgedIdentifier name, void *nameLoc, void *_Nullable genericParams);
+void TypeAliasDecl_setUnderlyingTypeRepr(void *decl, void *underlyingType);
+
 
 void TopLevelCodeDecl_dump(void *);
 void Expr_dump(void *);
 void Decl_dump(void *);
 void Stmt_dump(void *);
+void TypeRepr_dump(void *);
 
 #ifdef __cplusplus
 }
diff --git a/lib/AST/CASTBridging.cpp b/lib/AST/CASTBridging.cpp
@@ -4,6 +4,7 @@
 #include "swift/AST/ASTNode.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/GenericParamList.h"
 #include "swift/AST/Stmt.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/ParameterList.h"
@@ -268,12 +269,13 @@ void NominalTypeDecl_setMembers(void *decl, BridgedArrayRef members) {
 }
 
 DeclContextAndDecl StructDecl_create(
-    void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *dc) {
+    void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *_Nullable genericParams, void *dc) {
   ASTContext &Context = *static_cast<ASTContext *>(ctx);
   auto *out = new (Context) StructDecl(getSourceLocFromPointer(loc),
                                        Identifier::getFromOpaquePointer(name),
                                        getSourceLocFromPointer(nameLoc),
-                                       {}, nullptr,
+                                       {},
+                                       (GenericParamList *)genericParams,
                                        (DeclContext *)dc);
   out->setImplicit(); // TODO: remove this.
   return {(DeclContext *)out, (NominalTypeDecl *)out, (Decl *)out};
@@ -389,8 +391,71 @@ void *ExistentialTypeRepr_create(void *ctx, void *anyLoc, void *baseTy) {
   return new (Context) ExistentialTypeRepr(getSourceLocFromPointer(anyLoc), (TypeRepr *)baseTy);
 }
 
+void *GenericParamList_create(void *ctx, void *lAngleLoc, BridgedArrayRef params, void *_Nullable whereLoc, BridgedArrayRef reqs, void *rAngleLoc) {
+  ASTContext &Context = *static_cast<ASTContext *>(ctx);
+  SmallVector<RequirementRepr> requirements;
+  for (auto req : getArrayRef<BridgedRequirementRepr>(reqs)) {
+    switch (req.Kind) {
+    case BridgedRequirementReprKindTypeConstraint:
+        requirements.push_back(
+            RequirementRepr::getTypeConstraint((TypeRepr *)req.FirstType,
+                                               getSourceLocFromPointer(req.SeparatorLoc),
+                                               (TypeRepr *)req.SecondType));
+        break;
+    case BridgedRequirementReprKindSameType:
+        requirements.push_back(
+            RequirementRepr::getSameType((TypeRepr *)req.FirstType,
+                                         getSourceLocFromPointer(req.SeparatorLoc),
+                                         (TypeRepr *)req.SecondType));
+        break;
+    case BridgedRequirementReprKindLayoutConstraint:
+        llvm_unreachable("cannot handle layout constraints!");
+    }
+  }
+  return GenericParamList::create(Context,
+                                  getSourceLocFromPointer(lAngleLoc),
+                                  getArrayRef<GenericTypeParamDecl *>(params),
+                                  getSourceLocFromPointer(whereLoc),
+                                  requirements,
+                                  getSourceLocFromPointer(rAngleLoc));
+}
+
+void *GenericTypeParamDecl_create(void *ctx, void *declContext, BridgedIdentifier name, void *nameLoc, void *_Nullable ellipsisLoc, long index, bool isParameterPack) {
+  return GenericTypeParamDecl::createParsed(static_cast<DeclContext *>(declContext),
+                                            Identifier::getFromOpaquePointer(name),
+                                            getSourceLocFromPointer(nameLoc),
+                                            getSourceLocFromPointer(ellipsisLoc),
+                                             /*index*/ index,
+                                            isParameterPack);
+}
+
+void GenericTypeParamDecl_setInheritedType(void *ctx, void *Param, void *ty) {
+  ASTContext &Context = *static_cast<ASTContext *>(ctx);
+  auto entries = Context.AllocateCopy(ArrayRef<InheritedEntry>{
+    InheritedEntry{(TypeRepr *)ty}
+  });
+  ((GenericTypeParamDecl *)Param)->setInherited(entries);
+}
+
+
+DeclContextAndDecl TypeAliasDecl_create(void *ctx, void *declContext, void *aliasLoc, void *equalLoc, BridgedIdentifier name, void *nameLoc, void *_Nullable genericParams) {
+  ASTContext &Context = *static_cast<ASTContext *>(ctx);
+  auto *out = new (Context) TypeAliasDecl(getSourceLocFromPointer(aliasLoc),
+                                          getSourceLocFromPointer(equalLoc),
+                                          Identifier::getFromOpaquePointer(name),
+                                          getSourceLocFromPointer(nameLoc),
+                                          (GenericParamList *)genericParams,
+                                          (DeclContext *)declContext);
+  return {(DeclContext *)out, (TypeAliasDecl *)out, (Decl *)out};
+}
+
+void TypeAliasDecl_setUnderlyingTypeRepr(void *decl, void *underlyingType) {
+  ((TypeAliasDecl *)decl)->setUnderlyingTypeRepr((TypeRepr *)underlyingType);
+}
+
 void TopLevelCodeDecl_dump(void *decl) { ((TopLevelCodeDecl *)decl)->dump(llvm::errs()); }
 
 void Expr_dump(void *expr) { ((Expr *)expr)->dump(llvm::errs()); }
 void Decl_dump(void *expr) { ((Decl *)expr)->dump(llvm::errs()); }
 void Stmt_dump(void *expr) { ((Stmt *)expr)->dump(llvm::errs()); }
+void TypeRepr_dump(void *repr) { ((TypeRepr *)repr)->dump(); }
diff --git a/lib/ASTGen/CMakeLists.txt b/lib/ASTGen/CMakeLists.txt
@@ -3,6 +3,7 @@ if (SWIFT_SWIFT_PARSER)
     Sources/ASTGen/ASTGen.swift
     Sources/ASTGen/Decls.swift
     Sources/ASTGen/Exprs.swift
+    Sources/ASTGen/Generics.swift
     Sources/ASTGen/Literals.swift
     Sources/ASTGen/Macros.swift
     Sources/ASTGen/Misc.swift
diff --git a/lib/ASTGen/Sources/ASTGen/Decls.swift b/lib/ASTGen/Sources/ASTGen/Decls.swift
@@ -4,14 +4,36 @@ import SwiftSyntax
 import CASTBridging
 
 extension ASTGenVisitor {
+  public func visit(_ node: TypealiasDeclSyntax) -> UnsafeMutableRawPointer {
+    let aliasLoc = self.base.advanced(by: node.typealiasKeyword.position.utf8Offset).raw
+    let equalLoc = self.base.advanced(by: node.initializer.equal.position.utf8Offset).raw
+    var nameText = node.identifier.text
+    let name = nameText.withUTF8 { buf in
+      return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
+    }
+    let nameLoc = self.base.advanced(by: node.identifier.position.utf8Offset).raw
+    let genericParams = node.genericParameterClause.map(self.visit)
+    let out = TypeAliasDecl_create(self.ctx, self.declContext, aliasLoc, equalLoc, name, nameLoc, genericParams)
+
+    let oldDeclContext = declContext
+    declContext = out.declContext
+    defer { declContext = oldDeclContext }
+
+    let underlying = self.visit(node.initializer.value)
+    TypeAliasDecl_setUnderlyingTypeRepr(out.nominalDecl, underlying)
+
+    return out.decl
+  }
+
   public func visit(_ node: StructDeclSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
     var nameText = node.identifier.text
     let name = nameText.withUTF8 { buf in
       return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
     }
-    
-    let out = StructDecl_create(ctx, loc, name, loc, declContext)
+
+    let genericParams = node.genericParameterClause.map(self.visit)
+    let out = StructDecl_create(ctx, loc, name, loc, genericParams, declContext)
     let oldDeclContext = declContext
     declContext = out.declContext
     defer { declContext = oldDeclContext }
diff --git a/lib/ASTGen/Sources/ASTGen/Generics.swift b/lib/ASTGen/Sources/ASTGen/Generics.swift
@@ -0,0 +1,79 @@
+import SwiftParser
+import SwiftSyntax
+
+import CASTBridging
+
+extension ASTGenVisitor {
+  func visit(_ node: GenericParameterClauseSyntax) -> UnsafeMutableRawPointer {
+    let lAngleLoc = self.base.advanced(by: node.leftAngleBracket.position.utf8Offset).raw
+    let whereLoc = node.genericWhereClause.map { self.base.advanced(by: $0.whereKeyword.position.utf8Offset).raw }
+    let rAngleLoc = self.base.advanced(by: node.rightAngleBracket.position.utf8Offset).raw
+    return self.withBridgedParametersAndRequirements(node) { params, reqs in
+      return GenericParamList_create(self.ctx, lAngleLoc, params, whereLoc, reqs, rAngleLoc)
+    }
+  }
+
+  func visit(_ node: GenericParameterSyntax) -> UnsafeMutableRawPointer {
+    var nodeName = node.name.text
+    let name = nodeName.withUTF8 { buf in
+      return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
+    }
+    let nameLoc = self.base.advanced(by: node.name.position.utf8Offset).raw
+    let ellipsisLoc = node.ellipsis.map { self.base.advanced(by: $0.position.utf8Offset).raw }
+
+    return GenericTypeParamDecl_create(self.ctx, self.declContext, name, nameLoc, ellipsisLoc, node.indexInParent / 2, ellipsisLoc != nil)
+  }
+}
+
+extension ASTGenVisitor {
+  private func withBridgedParametersAndRequirements<T>(
+    _ node: GenericParameterClauseSyntax,
+    action: (BridgedArrayRef, BridgedArrayRef) -> T
+  ) -> T {
+    var params = [UnsafeMutableRawPointer]()
+    var requirements = [BridgedRequirementRepr]()
+    for param in node.genericParameterList {
+      let loweredParameter = self.visit(param)
+      params.append(loweredParameter)
+
+      guard let requirement = param.inheritedType else {
+        continue
+      }
+
+      let loweredRequirement = self.visit(requirement)
+      GenericTypeParamDecl_setInheritedType(self.ctx, loweredParameter, loweredRequirement);
+    }
+
+    if let nodeRequirements = node.genericWhereClause?.requirementList {
+      for requirement in nodeRequirements {
+        switch requirement.body {
+        case .conformanceRequirement(let conformance):
+          let firstType = self.visit(conformance.leftTypeIdentifier)
+          let separatorLoc = self.base.advanced(by: conformance.colon.position.utf8Offset).raw
+          let secondType = self.visit(conformance.rightTypeIdentifier)
+          requirements.append(BridgedRequirementRepr(
+            SeparatorLoc: separatorLoc,
+            Kind: .typeConstraint,
+            FirstType: firstType,
+            SecondType: secondType))
+        case .sameTypeRequirement(let sameType):
+          let firstType = self.visit(sameType.leftTypeIdentifier)
+          let separatorLoc = self.base.advanced(by: sameType.equalityToken.position.utf8Offset).raw
+          let secondType = self.visit(sameType.rightTypeIdentifier)
+          requirements.append(BridgedRequirementRepr(
+            SeparatorLoc: separatorLoc,
+            Kind: .sameType,
+            FirstType: firstType,
+            SecondType: secondType))
+        case .layoutRequirement(_):
+          fatalError("Cannot handle layout requirements!")
+        }
+      }
+    }
+    return params.withBridgedArrayRef { params in
+      return requirements.withBridgedArrayRef { reqs in
+        return action(params, reqs)
+      }
+    }
+  }
+}
diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift
@@ -35,7 +35,15 @@ extension ASTGenVisitor {
       }
       let nameLoc = self.base.advanced(by: pathElement.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(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))
+      }
     }
 
     return elements.withBridgedArrayRef { elements in

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,15 @@ extension ASTGenVisitor {`
`35`	`35`	`}`
`36`	`36`	`let nameLoc = self.base.advanced(by: pathElement.position.utf8Offset).raw`
`37`	`37`
	`38`	`+ if let generics = generics {`
	`39`	`+ let lAngle = self.base.advanced(by: generics.leftAngleBracket.position.utf8Offset).raw`
	`40`	`+ let rAngle = self.base.advanced(by: generics.rightAngleBracket.position.utf8Offset).raw`
	`41`	`+ elements.append(generics.arguments.map({ self.visit($0.argumentType) }).withBridgedArrayRef { genericArgs in`
	`42`	`+ GenericIdentTypeRepr_create(self.ctx, name, nameLoc, genericArgs, lAngle, rAngle)`
	`43`	`+ })`
	`44`	`+ } else {`
`38`	`45`	`elements.append(SimpleIdentTypeRepr_create(self.ctx, nameLoc, name))`
	`46`	`+ }`
`39`	`47`	`}`
`40`	`48`
`41`	`49`	`return elements.withBridgedArrayRef { elements in`