[Diagnostics] Result Builders: Extract pattern binding and var storage diagnostics into methods

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -5870,68 +5870,79 @@ static bool hasMissingElseInChain(IfStmt *ifStmt) {
   return false;
 }
 
-void SkipUnhandledConstructInResultBuilderFailure::diagnosePrimary(
-    bool asNote) {
+bool SkipUnhandledConstructInResultBuilderFailure::diagnosePatternBinding(
+    PatternBindingDecl *PB) const {
+  bool diagnosed = false;
 
-  if (auto *decl = unhandled.dyn_cast<Decl *>()) {
-    if (auto *PB = dyn_cast<PatternBindingDecl>(decl)) {
-      // Tailored diagnostics for computed properties.
-      if (!PB->hasStorage()) {
-      }
+  for (unsigned i : range(PB->getNumPatternEntries())) {
+    auto *pattern = PB->getPattern(i);
+
+    // Each variable bound by the pattern must be stored.
+    {
+      SmallVector<VarDecl *, 8> variables;
+      pattern->collectVariables(variables);
 
-      enum class PropertyKind : unsigned { lazy, wrapped, computed };
+      bool diagnosedStorage = false;
+      for (auto *var : variables)
+        diagnosedStorage |= diagnoseStorage(var);
+
+      // if storage has been diagnosed, let's move to the next entry.
+      if (diagnosedStorage) {
+        diagnosed = true;
+        continue;
+      }
+    }
 
-      // Diagnose all of the patterns without explicit initializers.
-      bool diagnosed = false;
-      for (unsigned i : range(PB->getNumPatternEntries())) {
-        auto *pattern = PB->getPattern(i);
+    // Diagnose all of the patterns without explicit initializers.
+    if (PB->isExplicitlyInitialized(i))
+      continue;
 
-        // Each variable bound by the pattern must be stored.
-        SmallVector<VarDecl *, 8> variables;
-        pattern->collectVariables(variables);
+    StringRef name;
 
-        for (auto *var : variables) {
-          if (var->getImplInfo().isSimpleStored())
-            continue;
+    if (auto *TP = dyn_cast<TypedPattern>(pattern)) {
+      if (auto *NP = dyn_cast<NamedPattern>(TP->getSubPattern()))
+        name = NP->getNameStr();
+    }
 
-          PropertyKind kind;
-          if (var->getAttrs().hasAttribute<LazyAttr>()) {
-            kind = PropertyKind::lazy;
-          } else if (var->hasAttachedPropertyWrapper()) {
-            kind = PropertyKind::wrapped;
-          } else {
-            kind = PropertyKind::computed;
-          }
+    emitDiagnosticAt(pattern->getLoc(),
+                     diag::result_builder_requires_explicit_var_initialization,
+                     !name.empty(), name, builder->getName())
+        .fixItInsertAfter(pattern->getEndLoc(), " = <#value#>");
 
-          emitDiagnosticAt(PB->getLoc(),
-                           diag::cannot_declare_computed_var_in_result_builder,
-                           static_cast<unsigned>(kind));
+    diagnosed = true;
+  }
 
-          diagnosed = true;
-        }
+  return diagnosed;
+}
 
-        if (PB->isExplicitlyInitialized(i))
-          continue;
+bool SkipUnhandledConstructInResultBuilderFailure::diagnoseStorage(
+    VarDecl *var) const {
+  enum class PropertyKind : unsigned { lazy, wrapped, computed };
 
-        StringRef name;
+  if (var->getImplInfo().isSimpleStored())
+    return false;
 
-        if (auto *TP = dyn_cast<TypedPattern>(pattern)) {
-          if (auto *NP = dyn_cast<NamedPattern>(TP->getSubPattern()))
-            name = NP->getNameStr();
-        }
+  PropertyKind kind;
+  if (var->getAttrs().hasAttribute<LazyAttr>()) {
+    kind = PropertyKind::lazy;
+  } else if (var->hasAttachedPropertyWrapper()) {
+    kind = PropertyKind::wrapped;
+  } else {
+    kind = PropertyKind::computed;
+  }
 
-        emitDiagnosticAt(
-            pattern->getLoc(),
-            diag::result_builder_requires_explicit_var_initialization,
-            !name.empty(), name, builder->getName())
-            .fixItInsertAfter(pattern->getEndLoc(), " = <#value#>");
+  emitDiagnosticAt(var, diag::cannot_declare_computed_var_in_result_builder,
+                   static_cast<unsigned>(kind));
+  return true;
+}
 
-        diagnosed = true;
-      }
+void SkipUnhandledConstructInResultBuilderFailure::diagnosePrimary(
+    bool asNote) {
 
-      if (diagnosed)
-        return;
-    }
+  if (auto *decl = unhandled.dyn_cast<Decl *>()) {
+    auto *PB = dyn_cast<PatternBindingDecl>(decl);
+    if (PB && diagnosePatternBinding(PB))
+      return;
   }
 
   if (auto stmt = unhandled.dyn_cast<Stmt *>()) {

lib/Sema/CSDiagnostics.h

@@ -1862,6 +1862,13 @@ class SkipUnhandledConstructInResultBuilderFailure final
 
   bool diagnoseAsError() override;
   bool diagnoseAsNote() override;
+
+private:
+  /// Tailored diagnostics for an unsupported variable declaration.
+  bool diagnosePatternBinding(PatternBindingDecl *PB) const;
+
+  /// Tailored diagnostics for lazy/wrapped/computed variable declarations.
+  bool diagnoseStorage(VarDecl *var) const;
 };
 
 /// Diagnose situation when a single "tuple" parameter is given N arguments e.g.