DI: Suggest "self.init()" for extension initializers of C structs

...unless the struct contains a field that cannot be zero-initialized,
such as a non-nullable pointer.

This suggestion is only made for C structs because 'init()' may not be
the right choice for other structs.

Author: jrose-apple

include/swift/AST/DiagnosticsSIL.def

@@ -217,8 +217,11 @@ ERROR(mutating_protocol_witness_method_on_let_constant,none,
 
 WARNING(designated_init_in_cross_module_extension,none,
         "initializer for struct %0 must use \"self.init(...)\" or \"self = ...\""
-        "%select{| on all paths}1 because it is not in module %2",
-        (Type, bool, Identifier))
+        "%select{| on all paths}1 because "
+        "%select{it is not in module %2|the struct was imported from C}3",
+        (Type, bool, Identifier, bool))
+NOTE(designated_init_c_struct_fix,none,
+     "use \"self.init()\" to initialize the struct with zero values", ())
 
 
 // Control flow diagnostics.

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -15,6 +15,7 @@
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Expr.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
@@ -46,10 +47,13 @@ llvm::cl::opt<bool> TriggerUnreachableOnFailure(
 STATISTIC(NumAssignRewritten, "Number of assigns rewritten");
 
 template<typename ...ArgTypes>
-static void diagnose(SILModule &M, SILLocation loc, ArgTypes... args) {
-  M.getASTContext().Diags.diagnose(loc.getSourceLoc(), Diagnostic(args...));
+static InFlightDiagnostic diagnose(SILModule &M, SILLocation loc,
+                                   ArgTypes... args) {
+  auto diag = M.getASTContext().Diags.diagnose(loc.getSourceLoc(),
+                                               Diagnostic(args...));
   if (TriggerUnreachableOnFailure)
     llvm_unreachable("Triggering standard assertion failure routine");
+  return diag;
 }
 
 enum class PartialInitializationKind {
@@ -1041,10 +1045,30 @@ void LifetimeChecker::handleStoreUse(unsigned UseID) {
     else
       selfTy = TheMemory.getType();
 
+    StructDecl *theStruct = selfTy->getStructOrBoundGenericStruct();
+    assert(theStruct);
+
     diagnose(Module, Use.Inst->getLoc(),
              diag::designated_init_in_cross_module_extension,
              selfTy, !isFullyUninitialized,
-             selfTy->getAnyNominal()->getParentModule()->getName());
+             theStruct->getParentModule()->getName(),
+             theStruct->hasClangNode());
+
+    // Special case: most (but not all) C structs have a zeroing no-argument
+    // initializer. If this struct is such a type, suggest inserting
+    // "self.init()".
+    if (theStruct->hasClangNode()) {
+      ASTContext &ctx = Module.getASTContext();
+      DeclName noArgInit(ctx, ctx.Id_init, ArrayRef<Identifier>());
+      auto lookupResults = theStruct->lookupDirect(noArgInit);
+      if (lookupResults.size() == 1 &&
+          lookupResults.front()->getDeclContext() == theStruct) {
+        diagnose(Module, Use.Inst->getLoc(),
+                 diag::designated_init_c_struct_fix)
+          .fixItInsert(Use.Inst->getLoc().getStartSourceLoc(),
+                       "self.init()\n");
+      }
+    }
 
     // Don't emit more than one of these diagnostics per initializer.
     WantsCrossModuleStructInitializerDiagnostic = false;

test/SILOptimizer/Inputs/definite_init_cross_module_swift4/BridgingHeader.h

@@ -0,0 +1,7 @@
+struct CPoint {
+  double x, y;
+};
+
+struct NonnullWrapper {
+  void * _Nonnull ptr;
+};

test/SILOptimizer/definite_init_cross_module_swift4.swift

@@ -1,6 +1,6 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-frontend -emit-module -emit-module-path=%t/OtherModule.swiftmodule %S/Inputs/definite_init_cross_module_swift4/OtherModule.swift
-// RUN: %target-swift-frontend -emit-sil -verify -I %t -swift-version 4 %s > /dev/null
+// RUN: %target-swift-frontend -emit-sil -verify -I %t -swift-version 4 %s > /dev/null -import-objc-header %S/Inputs/definite_init_cross_module_swift4/BridgingHeader.h
 
 import OtherModule
 
@@ -172,3 +172,52 @@ extension MyGenericPoint {
     self.y = myY
   }
 }
+
+extension CPoint {
+  init(xx: Double, yy: Double) {
+    self.x = xx // expected-warning {{initializer for struct 'CPoint' must use "self.init(...)" or "self = ..." because the struct was imported from C}} expected-note {{use "self.init()" to initialize the struct with zero values}} {{5-5=self.init()\n}}
+    self.y = yy
+  }
+
+  init(xxx: Double, yyy: Double) {
+    // This is OK
+    self.init(x: xxx, y: yyy)
+  }
+
+  init(other: CPoint) {
+    // This is OK
+    self = other
+  }
+
+  init(other: CPoint, x: Double) {
+    // This is OK
+    self = other
+    self.x = x
+  }
+
+  init(other: CPoint, xx: Double) {
+    self.x = xx // expected-warning {{initializer for struct 'CPoint' must use "self.init(...)" or "self = ..." because the struct was imported from C}} expected-note {{use "self.init()" to initialize the struct with zero values}} {{5-5=self.init()\n}}
+    self = other
+  }
+
+  init(other: CPoint, x: Double, cond: Bool) {
+    // This is OK
+    self = other
+    if cond { self.x = x }
+  }
+
+  init(other: CPoint, xx: Double, cond: Bool) {
+    if cond { self = other }
+    self.x = xx // expected-warning {{initializer for struct 'CPoint' must use "self.init(...)" or "self = ..." on all paths because the struct was imported from C}} expected-note {{use "self.init()" to initialize the struct with zero values}} {{5-5=self.init()\n}}
+    self.y = 0
+  }
+}
+
+
+extension NonnullWrapper {
+  init(p: UnsafeMutableRawPointer) {
+    self.ptr = p // expected-warning {{initializer for struct 'NonnullWrapper' must use "self.init(...)" or "self = ..." because the struct was imported from C}}
+    // No suggestion for "self.init()" because this struct does not support a
+    // zeroing initializer.
+  }
+}