Sema: Result builder inference always favors explicit attr on storage decl

Author: AnthonyLatsis

lib/Sema/TypeCheckRequestFunctions.cpp

@@ -201,30 +201,36 @@ AttachedResultBuilderRequest::evaluate(Evaluator &evaluator,
 /// Attempt to infer the result builder type for a declaration.
 static Type inferResultBuilderType(ValueDecl *decl)  {
   auto dc = decl->getDeclContext();
-  if (!dc->isTypeContext() || isa<ProtocolDecl>(dc))
+  if (isa<ProtocolDecl>(dc))
     return Type();
 
   auto funcDecl = dyn_cast<FuncDecl>(decl);
   if (!funcDecl || !funcDecl->hasBody() ||
       !decl->getDeclContext()->getParentSourceFile())
     return Type();
 
-  // Check whether there are any return statements in the function's body.
-  // If there are, the result builder transform will be disabled,
-  // so don't infer a result builder.
-  if (!TypeChecker::findReturnStatements(funcDecl).empty())
-    return Type();
-
-  // Only getters can have result builders. When we find one, look at
-  // the storage declaration for the purposes of witness matching.
-  auto lookupDecl = decl;
+  // For a getter, always favor the result builder type of its storage
+  // declaration if not null. Other accessors are not supported by inference.
   if (auto accessor = dyn_cast<AccessorDecl>(funcDecl)) {
     if (accessor->getAccessorKind() != AccessorKind::Get)
       return Type();
 
-    lookupDecl = accessor->getStorage();
+    if (auto type = accessor->getStorage()->getResultBuilderType()) {
+      return type;
+    }
+  }
+
+  // FIXME: We could infer from a dynamically replaced decl in non-type contexts too.
+  if (!dc->isTypeContext()) {
+    return Type();
   }
 
+  // Check whether there are any return statements in the function's body.
+  // If there are, the result builder transform will be disabled,
+  // so don't infer a result builder.
+  if (!TypeChecker::findReturnStatements(funcDecl).empty())
+    return Type();
+
   // Find all of the potentially inferred result builder types.
   struct Match {
     enum Kind {
@@ -323,6 +329,13 @@ static Type inferResultBuilderType(ValueDecl *decl)  {
     }
   };
 
+  ValueDecl *lookupDecl = nullptr;
+  if (auto *accessor = dyn_cast<AccessorDecl>(funcDecl)) {
+    lookupDecl = accessor->getStorage();
+  } else {
+    lookupDecl = decl;
+  }
+
   addConformanceMatches(lookupDecl);
 
   // Look for result builder types inferred through dynamic replacements.

lib/Sema/TypeCheckStmt.cpp

@@ -2124,20 +2124,6 @@ void TypeChecker::typeCheckASTNode(ASTNode &node, DeclContext *DC,
   stmtChecker.typeCheckASTNode(node);
 }
 
-static Type getResultBuilderType(FuncDecl *FD) {
-  Type builderType = FD->getResultBuilderType();
-
-  // For getters, fall back on looking on the attribute on the storage.
-  if (!builderType) {
-    auto accessor = dyn_cast<AccessorDecl>(FD);
-    if (accessor && accessor->getAccessorKind() == AccessorKind::Get) {
-      builderType = accessor->getStorage()->getResultBuilderType();
-    }
-  }
-
-  return builderType;
-}
-
 /// Attempts to build an implicit call within the provided constructor
 /// to the provided class's zero-argument super initializer.
 /// @returns nullptr if there was an error and a diagnostic was emitted.
@@ -2617,7 +2603,7 @@ bool TypeCheckASTNodeAtLocRequest::evaluate(
 
   // Function builder function doesn't support partial type checking.
   if (auto *func = dyn_cast<FuncDecl>(DC)) {
-    if (Type builderType = getResultBuilderType(func)) {
+    if (Type builderType = func->getResultBuilderType()) {
       if (func->getBody()) {
         auto optBody =
             TypeChecker::applyResultBuilderBodyTransform(func, builderType);
@@ -2694,7 +2680,7 @@ static void addImplicitReturnIfNeeded(BraceStmt *body, DeclContext *dc) {
 
   if (auto *fd = dyn_cast<FuncDecl>(dc)) {
     // Don't apply if we have a result builder, or a Void return type.
-    if (getResultBuilderType(fd) || fd->getResultInterfaceType()->isVoid())
+    if (fd->getResultBuilderType() || fd->getResultInterfaceType()->isVoid())
       return;
   }
 
@@ -2894,7 +2880,7 @@ TypeCheckFunctionBodyRequest::evaluate(Evaluator &eval,
   // produce a type-checked body.
   bool alreadyTypeChecked = false;
   if (auto *func = dyn_cast<FuncDecl>(AFD)) {
-    if (Type builderType = getResultBuilderType(func)) {
+    if (Type builderType = func->getResultBuilderType()) {
       if (auto optBody =
               TypeChecker::applyResultBuilderBodyTransform(
                 func, builderType)) {

test/Constraints/result_builder_infer.swift

@@ -142,6 +142,28 @@ struct TupleMe2: Tupled, Tupled2 {
   }
 }
 
+protocol Tupled3 {
+  associatedtype TupleType
+
+  var tuple: TupleType { @TupleBuilder get }
+}
+
+struct TupleMe3: Tupled3 {
+  var condition: Bool
+
+  // FIXME: Not inferred from getter requirement
+  // expected-error@+1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
+  var tuple: some Any {
+    "hello" // expected-warning{{literal is unused}}
+    if condition {
+      "nested" // expected-warning{{literal is unused}}
+    }
+    3.14159 // expected-warning{{literal is unused}}
+    "world" // expected-warning{{literal is unused}}
+    // expected-note@-1 {{did you mean to return the last expression?}}
+  }
+}
+
 protocol OtherTupled {
   associatedtype OtherTupleType
 
@@ -233,3 +255,35 @@ extension DynamicTupled3: OtherTupled {
     0
   }
 }
+
+do {
+  @resultBuilder
+  enum BuildBoolFrom<T> {
+    static func buildBlock(_ t: T...) -> Bool {}
+  }
+
+  protocol P {
+    @BuildBoolFrom<String>
+    var property: Bool { get }
+  }
+
+  struct Conformer1: P {
+    @BuildBoolFrom<Int>
+    var property: Bool {
+      // OK, explicit result builder disables inference through protocol.
+      1
+      2
+    }
+  }
+
+  struct Conformer2: P {
+    var property: Bool {
+      @BuildBoolFrom<Int>
+      get {
+        // OK, explicit result builder disables inference through protocol.
+        1
+        2
+      }
+    }
+  }
+}