Fix issue in release builds by allocating memory for captures

Author: calda

lib/Sema/TypeCheckType.cpp

@@ -6976,169 +6976,178 @@ void TypeChecker::checkExistentialTypes(
   checker.checkRequirements(genericParams->getRequirements());
 }
 
-/// Retrieves the valid result types of the result builder
-/// (the return types of `buildFinalResult` / `buildBlock` /
-/// `buildPartialResult`).
-llvm::SmallVector<Type, 4>
-retrieveResultBuilderResultTypes(NominalTypeDecl *builder) {
-  ASTContext &ctx = builder->getASTContext();
-  llvm::SmallVector<Type, 4> resultTypes;
-
-  Identifier methodIds[] = {ctx.Id_buildFinalResult, ctx.Id_buildBlock,
-                            ctx.Id_buildPartialBlock};
-
-  for (auto methodId : methodIds) {
-    SmallVector<ValueDecl *, 4> potentialMatches;
-    bool supportsMethod = TypeChecker::typeSupportsBuilderOp(
-        builder->getDeclaredInterfaceType(), builder, methodId,
-        /*argLabels=*/{}, &potentialMatches);
-
-    if (!supportsMethod)
-      continue;
+/// Opens a result builder `UnboundGenericType` into a `BoundGenericType`
+/// by creating and solving a constraint between the result builder's
+/// result type and the return type of the attached declaration.
+struct ResultBuilderUnboundTypeOpener {
+  DeclContext *dc;
+  CustomAttr *attr;
+
+  Type operator()(UnboundGenericType *unboundTy) const {
+    auto resultBuilderDecl =
+        dyn_cast_or_null<NominalTypeDecl>(unboundTy->getDecl());
+    if (!resultBuilderDecl ||
+        !resultBuilderDecl->getAttrs().hasAttribute<ResultBuilderAttr>()) {
+      return invalidResultBuilderType(unboundTy);
+    }
+
+    Decl *owningDecl = attr->getOwner().getAsDecl();
+    if (!owningDecl) {
+      return invalidResultBuilderType(unboundTy);
+    }
+
+    // Retrieve the return type of the owning declaration that
+    // provides type inference for the result builder type.
+    Type owningDeclResultType;
+    if (auto varDecl = dyn_cast<VarDecl>(owningDecl)) {
+      if (auto closureResultType =
+              varDecl->getInterfaceType()->getAs<FunctionType>()) {
+        owningDeclResultType = closureResultType->getResult();
+      } else {
+        owningDeclResultType = varDecl->getInterfaceType();
+      }
+    } else if (auto funcDecl = dyn_cast<FuncDecl>(owningDecl)) {
+      owningDeclResultType = funcDecl->getResultInterfaceType();
+    }
 
-    for (auto decl : potentialMatches) {
-      auto func = dyn_cast<FuncDecl>(decl);
-      if (!func || !func->isStatic())
-        continue;
+    if (!owningDeclResultType) {
+      return invalidResultBuilderType(unboundTy);
+    }
 
-      auto resultType = func->getResultInterfaceType();
-      if (!resultType || resultType->hasError())
-        continue;
+    // Retrieve the supported result types of the result builder.
+    auto resultTypes = retrieveResultBuilderResultTypes(resultBuilderDecl);
+    if (resultTypes.empty()) {
+      return invalidResultBuilderType(unboundTy);
+    }
 
-      // Add the result type if we haven't seen it before
-      bool isDuplicate = false;
-      for (auto existingType : resultTypes) {
-        if (existingType->isEqual(resultType)) {
-          isDuplicate = true;
-          break;
-        }
-      }
+    auto genericSig = resultBuilderDecl->getGenericSignature();
+
+    // Try each result type and return the first one that produces a valid
+    // solution
+    for (auto componentType : resultTypes) {
+      using namespace constraints;
+      ConstraintSystem cs(dc, std::nullopt);
 
-      if (!isDuplicate) {
-        resultTypes.push_back(resultType);
+      // Create a type variable for each of the result builder's generic params
+      llvm::SmallVector<Type, 8> typeVarReplacements;
+      llvm::SmallVector<TypeVariableType *, 8> typeVars;
+      for (unsigned i = 0; i < genericSig.getGenericParams().size(); ++i) {
+        auto locator = cs.getConstraintLocator(
+            resultBuilderDecl, {ConstraintLocator::GenericArgument, i});
+        auto typeVar = cs.createTypeVariable(locator, TVO_CanBindToHole);
+        typeVarReplacements.push_back(typeVar);
+        typeVars.push_back(typeVar);
       }
-    }
-  }
 
-  return resultTypes;
-}
+      // Replace any references to the result builder's generic params
+      // in the result type with the corresponding type variables.
+      auto subMap = SubstitutionMap::get(genericSig, typeVarReplacements,
+                                         LookUpConformanceInModule());
 
-Type invalidResultBuilderType(UnboundGenericType* unboundTy,
-                              CustomAttr *attr, DeclContext *dc) {
-  dc->getASTContext().Diags.diagnose(
-    attr->getTypeExpr()->getLoc(),
-    diag::result_builder_generic_inference_failed,
-    unboundTy->getDecl()->getName());
-  
-  return ErrorType::get(dc->getASTContext());
-}
+      auto componentTypeWithTypeVars = componentType.subst(subMap);
 
-/// Opens a result builder `UnboundGenericType` into a `BoundGenericType`
-/// by creating and solving a constraint between the result builder's
-/// result type and the return type of the attached declaration.
-Type openUnboundResultBuilderType(UnboundGenericType* unboundTy,
-                                  CustomAttr *attr, DeclContext *dc) {
-  auto resultBuilderDecl =
-      dyn_cast_or_null<NominalTypeDecl>(unboundTy->getDecl());
-  if (!resultBuilderDecl) {
-    return invalidResultBuilderType(unboundTy, attr, dc);
-  }
-
-  // Retrieve the return type of the owning declaration that
-  // provides type inference for the result builder type.
-  Type owningDeclResultType;
-  Decl *owningDecl = attr->getOwner().getAsDecl();
-  
-  if (auto varDecl = dyn_cast_or_null<VarDecl>(owningDecl)) {
-    if (auto closureResultType = varDecl->getInterfaceType()->getAs<FunctionType>()) {
-      owningDeclResultType = closureResultType->getResult();
-    } else {
-      owningDeclResultType = varDecl->getInterfaceType();
+      // The result builder result type should be equal to the return type of
+      // the attached declaration.
+      cs.addConstraint(ConstraintKind::Equal, owningDeclResultType,
+                       componentTypeWithTypeVars,
+                       /*preparedOverload:*/ nullptr);
+
+      auto solution = cs.solveSingle();
+
+      // If a solution exists, bind the result builder's generic params to the
+      // solved types.
+      if (solution) {
+        llvm::SmallVector<Type, 8> solvedReplacements;
+        for (auto typeVar : typeVars) {
+          solvedReplacements.push_back(solution->typeBindings[typeVar]);
+        }
+
+        return BoundGenericType::get(resultBuilderDecl, unboundTy->getParent(),
+                                     solvedReplacements);
+      }
     }
-  } else if (auto funcDecl = dyn_cast_or_null<FuncDecl>(owningDecl)) {
-    owningDeclResultType = funcDecl->getResultInterfaceType();
-  }
-  
-  if (!owningDeclResultType) {
-    return invalidResultBuilderType(unboundTy, attr, dc);
+
+    // No result type produced a valid solution
+    return invalidResultBuilderType(unboundTy);
   }
 
-  // Retrieve the supported result types of the result builder.
-  auto resultTypes = retrieveResultBuilderResultTypes(resultBuilderDecl);
-  if (resultTypes.empty()) {
-    return invalidResultBuilderType(unboundTy, attr, dc);
+private:
+  Type invalidResultBuilderType(UnboundGenericType *unboundTy) const {
+    dc->getASTContext().Diags.diagnose(
+        attr->getTypeExpr()->getLoc(),
+        diag::result_builder_generic_inference_failed,
+        unboundTy->getDecl()->getName());
+
+    return ErrorType::get(dc->getASTContext());
   }
 
-  auto genericSig = resultBuilderDecl->getGenericSignature();
+  /// Retrieves the valid result types of the result builder
+  /// (the return types of `buildFinalResult` / `buildBlock` /
+  /// `buildPartialBlock`).
+  llvm::SmallVector<Type, 4>
+  retrieveResultBuilderResultTypes(NominalTypeDecl *builder) const {
+    ASTContext &ctx = builder->getASTContext();
+    llvm::SmallVector<Type, 4> resultTypes;
 
-  for (auto componentType : resultTypes) {
-    using namespace constraints;
-    ConstraintSystem cs(dc, std::nullopt);
+    Identifier methodIds[] = {ctx.Id_buildFinalResult, ctx.Id_buildBlock,
+                              ctx.Id_buildPartialBlock};
 
-    // Create a type variable for each of the result builder's generic params
-    llvm::SmallVector<Type, 8> typeVarReplacements;
-    llvm::SmallVector<TypeVariableType *, 8> typeVars;
-    for (unsigned i = 0; i < genericSig.getGenericParams().size(); ++i) {
-      auto locator = cs.getConstraintLocator(
-          resultBuilderDecl, {ConstraintLocator::GenericArgument, i});
-      auto typeVar = cs.createTypeVariable(locator, TVO_CanBindToHole);
-      typeVarReplacements.push_back(typeVar);
-      typeVars.push_back(typeVar);
-    }
+    for (auto methodId : methodIds) {
+      SmallVector<ValueDecl *, 4> potentialMatches;
+      bool supportsMethod = TypeChecker::typeSupportsBuilderOp(
+          builder->getDeclaredInterfaceType(), builder, methodId,
+          /*argLabels=*/{}, &potentialMatches);
 
-    // Replace any references to the result builder's generic params
-    // in the result type with the corresponding type variables.
-    auto subMap = SubstitutionMap::get(genericSig, typeVarReplacements,
-                                       LookUpConformanceInModule());
+      if (!supportsMethod)
+        continue;
 
-    auto componentTypeWithTypeVars = componentType.subst(subMap);
+      for (auto decl : potentialMatches) {
+        auto func = dyn_cast<FuncDecl>(decl);
+        if (!func || !func->isStatic())
+          continue;
 
-    // The result builder result type should be equal to the return type of the
-    // attached declaration.
-    cs.addConstraint(ConstraintKind::Equal, owningDeclResultType,
-                     componentTypeWithTypeVars,
-                     /*preparedOverload:*/ nullptr);
+        auto resultType = func->getResultInterfaceType();
+        if (!resultType || resultType->hasError())
+          continue;
 
-    auto solution = cs.solveSingle();
+        // Add the result type if we haven't seen it before
+        bool isDuplicate = false;
+        for (auto existingType : resultTypes) {
+          if (existingType->isEqual(resultType)) {
+            isDuplicate = true;
+            break;
+          }
+        }
 
-    // If a solution exists, bind the result builder's generic params to the
-    // solved types.
-    if (solution) {
-      llvm::SmallVector<Type, 8> solvedReplacements;
-      for (auto typeVar : typeVars) {
-        solvedReplacements.push_back(solution->typeBindings[typeVar]);
+        if (!isDuplicate) {
+          resultTypes.push_back(resultType);
+        }
       }
-
-      return BoundGenericType::get(resultBuilderDecl, unboundTy->getParent(),
-                                   solvedReplacements);
     }
-  }
 
-  // No result type produced a valid solution
-  return invalidResultBuilderType(unboundTy, attr, dc);
-}
+    return resultTypes;
+  }
+};
 
 Type CustomAttrTypeRequest::evaluate(Evaluator &eval, CustomAttr *attr,
                                      DeclContext *dc,
                                      CustomAttrTypeKind typeKind) const {
   const TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
 
   OpenUnboundGenericTypeFn unboundTyOpener = nullptr;
-  
-  // Property delegates allow their type to be an unbound generic.
+
+  // Property wrappers and result builders allow their type to be an unbound
+  // generic.
   if (typeKind == CustomAttrTypeKind::PropertyWrapper) {
     unboundTyOpener = TypeResolution::defaultUnboundTypeOpener;
-  }
-  
-  /// Result builder types can have their generics parameters inferred
-  /// from the attached declaration.
-  else if (typeKind == CustomAttrTypeKind::ResultBuilder){
-    unboundTyOpener = [attr, dc](UnboundGenericType* unboundTy) -> Type {
-      return openUnboundResultBuilderType(unboundTy, attr, dc);
-    };
+  } else if (typeKind == CustomAttrTypeKind::ResultBuilder) {
+    auto &ctx = dc->getASTContext();
+    void *mem = ctx.Allocate(sizeof(ResultBuilderUnboundTypeOpener),
+                             alignof(ResultBuilderUnboundTypeOpener));
+    unboundTyOpener = *new (mem) ResultBuilderUnboundTypeOpener{dc, attr};
   }
 
-  const auto type = TypeResolution::resolveContextualType(
+  auto type = TypeResolution::resolveContextualType(
       attr->getTypeRepr(), dc, options, unboundTyOpener,
       /*placeholderHandler*/ nullptr, /*packElementOpener*/ nullptr);
 

test/decl/var/result_builders.swift

@@ -72,7 +72,7 @@ struct GenericContainer<T> {
   struct Maker {} // expected-error {{result builder must provide at least one static 'buildBlock' method}}
 }
 
-func makeParamUnbound(@GenericMaker // expected-error {{unable to infer generic parameters for result builder 'GenericMaker'}}
+func makeParamUnbound(@GenericMaker
                       fn: () -> ()) {}
 
 func makeParamBound(@GenericMaker<Int>