---

yaml
---
r: 341709
b: refs/heads/rxwei-patch-1
c: 9c17bb1
h: refs/heads/master
i:
  341707: cd70284

Author: DougGregor

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: d01e80f8200788d8f2f44c01b66f537b87909f03
+refs/heads/rxwei-patch-1: 9c17bb1ffe0ba17eae40eb87454b84f685bdb091
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/lib/ClangImporter/ImportDecl.cpp

@@ -1251,75 +1251,80 @@ makeBitFieldAccessors(ClangImporter::Implementation &Impl,
   return { getterDecl, setterDecl };
 }
 
-/// Create a default constructor that initializes a struct to zero.
-static ConstructorDecl *
-createDefaultConstructor(ClangImporter::Implementation &Impl,
-                         StructDecl *structDecl) {
-  auto &context = Impl.SwiftContext;
-
-  auto emptyPL = ParameterList::createEmpty(context);
-
-  // Create the constructor.
-  DeclName name(context, DeclBaseName::createConstructor(), emptyPL);
-  auto constructor = new (context) ConstructorDecl(
-      name, structDecl->getLoc(), OTK_None, /*FailabilityLoc=*/SourceLoc(),
-      /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(), emptyPL,
-      /*GenericParams=*/nullptr, structDecl);
-
-  // Set the constructor's type.
-  constructor->computeType();
-  constructor->setValidationToChecked();
-
-  constructor->setAccess(AccessLevel::Public);
-
-  // Mark the constructor transparent so that we inline it away completely.
-  constructor->getAttrs().add(new (context) TransparentAttr(/*implicit*/ true));
-
-  if (Impl.hasFinishedTypeChecking())
-    return constructor;
+/// Synthesize the body for an struct default initializer.
+static std::pair<BraceStmt *, bool>
+synthesizeStructDefaultConstructorBody(AbstractFunctionDecl *afd,
+                                       void *context) {
+  auto constructor = cast<ConstructorDecl>(afd);
+  ASTContext &ctx = constructor->getASTContext();
+  auto structDecl = static_cast<StructDecl *>(context);
 
   // Use a builtin to produce a zero initializer, and assign it to self.
 
   // Construct the left-hand reference to self.
   auto *selfDecl = constructor->getImplicitSelfDecl();
-  Expr *lhs = new (context) DeclRefExpr(selfDecl,
-                                        DeclNameLoc(), /*Implicit=*/true);
+  Expr *lhs = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(), /*Implicit=*/true);
   auto selfType = structDecl->getDeclaredInterfaceType();
   lhs->setType(LValueType::get(selfType));
 
-  auto emptyTuple = TupleType::getEmpty(context);
+  auto emptyTuple = TupleType::getEmpty(ctx);
 
   // Construct the right-hand call to Builtin.zeroInitializer.
-  Identifier zeroInitID = context.getIdentifier("zeroInitializer");
+  Identifier zeroInitID = ctx.getIdentifier("zeroInitializer");
   auto zeroInitializerFunc =
-    cast<FuncDecl>(getBuiltinValueDecl(context, zeroInitID));
+    cast<FuncDecl>(getBuiltinValueDecl(ctx, zeroInitID));
   SubstitutionMap subMap =
     SubstitutionMap::get(zeroInitializerFunc->getGenericSignature(),
                          llvm::makeArrayRef(selfType), { });
   ConcreteDeclRef concreteDeclRef(zeroInitializerFunc, subMap);
   auto zeroInitializerRef =
-    new (context) DeclRefExpr(concreteDeclRef, DeclNameLoc(),
-                              /*implicit*/ true);
+    new (ctx) DeclRefExpr(concreteDeclRef, DeclNameLoc(), /*implicit*/ true);
   zeroInitializerRef->setType(FunctionType::get({}, selfType));
 
-  auto call = CallExpr::createImplicit(context, zeroInitializerRef, {}, {});
+  auto call = CallExpr::createImplicit(ctx, zeroInitializerRef, {}, {});
   call->setType(selfType);
   call->setThrows(false);
 
-  auto assign = new (context) AssignExpr(lhs, SourceLoc(), call,
-                                         /*implicit*/ true);
+  auto assign = new (ctx) AssignExpr(lhs, SourceLoc(), call, /*implicit*/ true);
   assign->setType(emptyTuple);
 
-  auto result = TupleExpr::createEmpty(context, SourceLoc(), SourceLoc(),
+  auto result = TupleExpr::createEmpty(ctx, SourceLoc(), SourceLoc(),
                                        /*Implicit=*/true);
   result->setType(emptyTuple);
 
-  auto ret = new (context) ReturnStmt(SourceLoc(), result, /*Implicit=*/true);
+  auto ret = new (ctx) ReturnStmt(SourceLoc(), result, /*Implicit=*/true);
 
   // Create the function body.
-  auto body = BraceStmt::create(context, SourceLoc(), {assign, ret},
-                                SourceLoc());
-  constructor->setBody(body, AbstractFunctionDecl::BodyKind::TypeChecked);
+  auto body = BraceStmt::create(ctx, SourceLoc(), {assign, ret}, SourceLoc());
+  return { body, /*isTypeChecked=*/true };
+}
+
+/// Create a default constructor that initializes a struct to zero.
+static ConstructorDecl *
+createDefaultConstructor(ClangImporter::Implementation &Impl,
+                         StructDecl *structDecl) {
+  auto &context = Impl.SwiftContext;
+
+  auto emptyPL = ParameterList::createEmpty(context);
+
+  // Create the constructor.
+  DeclName name(context, DeclBaseName::createConstructor(), emptyPL);
+  auto constructor = new (context) ConstructorDecl(
+      name, structDecl->getLoc(), OTK_None, /*FailabilityLoc=*/SourceLoc(),
+      /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(), emptyPL,
+      /*GenericParams=*/nullptr, structDecl);
+
+  // Set the constructor's type.
+  constructor->computeType();
+  constructor->setValidationToChecked();
+
+  constructor->setAccess(AccessLevel::Public);
+
+  // Mark the constructor transparent so that we inline it away completely.
+  constructor->getAttrs().add(new (context) TransparentAttr(/*implicit*/ true));
+
+  constructor->setBodySynthesizer(synthesizeStructDefaultConstructorBody,
+                                  structDecl);
 
   // We're done.
   return constructor;