Simplify packCount IRGen

Author: Azoy

lib/AST/Builtins.cpp

@@ -247,13 +247,13 @@ createGenericParam(ASTContext &ctx, const char *name, unsigned index,
 /// Create a generic parameter list with multiple generic parameters.
 static GenericParamList *getGenericParams(ASTContext &ctx,
                                           unsigned numParameters,
-                                          bool areParametersPacks = false) {
+                                          bool areParameterPacks = false) {
   assert(numParameters <= std::size(GenericParamNames));
 
   SmallVector<GenericTypeParamDecl *, 2> genericParams;
   for (unsigned i = 0; i != numParameters; ++i)
     genericParams.push_back(createGenericParam(ctx, GenericParamNames[i], i,
-                                               areParametersPacks));
+                                               areParameterPacks));
 
   auto paramList = GenericParamList::create(ctx, SourceLoc(), genericParams,
                                             SourceLoc());
@@ -754,16 +754,9 @@ namespace {
     };
     struct ParameterGenerator {
       unsigned Index;
-      bool isPackExpansion;
       Type build(BuiltinFunctionBuilder &builder) const {
-        auto ty = builder.TheGenericParamList->getParams()[Index]
+        return builder.TheGenericParamList->getParams()[Index]
                     ->getDeclaredInterfaceType();
-
-        if (isPackExpansion) {
-          return PackExpansionType::get(ty, ty);
-        }
-
-        return ty;
       }
     };
     struct LambdaGenerator {
@@ -780,6 +773,15 @@ namespace {
         return MetatypeType::get(Object.build(builder), Repr);
       }
     };
+    struct ParameterPackGenerator {
+      unsigned Index;
+      Type build(BuiltinFunctionBuilder &builder) const {
+        auto ty = builder.TheGenericParamList->getParams()[Index]
+                      ->getDeclaredInterfaceType();
+
+        return PackExpansionType::get(ty, ty);
+      }
+    };
   };
 } // end anonymous namespace
 
@@ -789,8 +791,8 @@ makeConcrete(Type type) {
 }
 
 static BuiltinFunctionBuilder::ParameterGenerator
-makeGenericParam(unsigned index = 0, bool isPackExpansion = false) {
-  return { index, isPackExpansion };
+makeGenericParam(unsigned index = 0) {
+  return { index };
 }
 
 template <class... Gs>
@@ -827,6 +829,11 @@ makeMetatype(const T &object,
   return { object, repr };
 }
 
+static BuiltinFunctionBuilder::ParameterPackGenerator
+makeParameterPack(unsigned index = 0) {
+  return { index };
+}
+
 /// Create a function with type <T> T -> ().
 static ValueDecl *getRefCountingOperation(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id, _thin,
@@ -1952,8 +1959,7 @@ static ValueDecl *getPackCount(ASTContext &ctx, Identifier id) {
                                  /* anyObject */ false,
                                  /* areParametersPack */ true);
 
-  auto packEx = makeGenericParam(/* index */ 0, /* isPackExpansion */ true);
-  auto paramTy = makeMetatype(makeTuple(packEx));
+  auto paramTy = makeMetatype(makeTuple(makeParameterPack()));
   builder.addParameter(paramTy);
   builder.setResult(makeConcrete(BuiltinIntegerType::getWordType(ctx)));
 

lib/IRGen/GenBuiltin.cpp

@@ -1359,23 +1359,8 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
   if (Builtin.ID == BuiltinValueKind::PackCount) {
     (void) args.claimAll();
 
-    auto metaTy = argTypes[0].getASTType()->castTo<MetatypeType>();
-    auto tupleTy = metaTy->getInstanceType()->castTo<TupleType>();
-
-    llvm::Value *count = llvm::ConstantInt::get(IGF.IGM.SizeTy, 0);
-
-    // Accumulate the count of the pack.
-    for (auto eltTy : tupleTy->getElementTypes()) {
-      if (auto packExpTy = dyn_cast<PackExpansionType>(eltTy)) {
-        auto countTy = packExpTy->getCountType()->getCanonicalType();
-        auto packCount = IGF.emitPackShapeExpression(countTy);
-        count = IGF.Builder.CreateAdd(count, packCount);
-        continue;
-      }
-
-      count = IGF.Builder.CreateAdd(count,
-                                    llvm::ConstantInt::get(IGF.IGM.SizeTy, 1));
-    }
+    auto packTy = substitutions.getReplacementTypes()[0]->castTo<PackType>();
+    auto count = IGF.emitPackShapeExpression(packTy->getCanonicalType());
 
     out.add(count);
     return;