Add a convenience PatternBindingDecl::createImplicit member and mark some PBDs as implicit

include/swift/AST/Decl.h

@@ -1907,6 +1907,12 @@ class PatternBindingDecl final : public Decl,
                                     Pattern *Pat, Expr *E,
                                     DeclContext *Parent);
 
+  static PatternBindingDecl *createImplicit(ASTContext &Ctx,
+                                            StaticSpellingKind StaticSpelling,
+                                            Pattern *Pat, Expr *E,
+                                            DeclContext *Parent,
+                                            SourceLoc VarLoc = SourceLoc());
+
   static PatternBindingDecl *createDeserialized(
                                ASTContext &Ctx, SourceLoc StaticLoc,
                                StaticSpellingKind StaticSpelling,

lib/AST/Decl.cpp

@@ -1017,6 +1017,15 @@ PatternBindingDecl::create(ASTContext &Ctx, SourceLoc StaticLoc,
   return Result;
 }
 
+PatternBindingDecl *PatternBindingDecl::createImplicit(
+    ASTContext &Ctx, StaticSpellingKind StaticSpelling, Pattern *Pat, Expr *E,
+    DeclContext *Parent, SourceLoc VarLoc) {
+  auto *Result = create(Ctx, /*StaticLoc*/ SourceLoc(), StaticSpelling, VarLoc,
+                        Pat, E, Parent);
+  Result->setImplicit();
+  return Result;
+}
+
 PatternBindingDecl *
 PatternBindingDecl::create(ASTContext &Ctx, SourceLoc StaticLoc,
                            StaticSpellingKind StaticSpelling,

lib/ClangImporter/ImportDecl.cpp

@@ -146,9 +146,11 @@ createVarWithPattern(ASTContext &ctx, DeclContext *dc, Identifier name, Type ty,
 
   // Create a pattern binding to describe the variable.
   Pattern *varPattern = createTypedNamedPattern(var);
-  auto patternBinding =
-      PatternBindingDecl::create(ctx, SourceLoc(), StaticSpellingKind::None,
-                                 SourceLoc(), varPattern, nullptr, dc);
+  auto *patternBinding = PatternBindingDecl::create(
+      ctx, /*StaticLoc*/ SourceLoc(), StaticSpellingKind::None,
+      /*VarLoc*/ SourceLoc(), varPattern, /*InitExpr*/ nullptr, dc);
+  if (isImplicit)
+    patternBinding->setImplicit();
 
   return {var, patternBinding};
 }
@@ -1562,9 +1564,9 @@ static void makeStructRawValuedWithBridge(
 
   // Create a pattern binding to describe the variable.
   Pattern *computedVarPattern = createTypedNamedPattern(computedVar);
-  auto computedPatternBinding = PatternBindingDecl::create(
-      ctx, SourceLoc(), StaticSpellingKind::None, SourceLoc(),
-      computedVarPattern, nullptr, structDecl);
+  auto *computedPatternBinding = PatternBindingDecl::createImplicit(
+      ctx, StaticSpellingKind::None, computedVarPattern, /*InitExpr*/ nullptr,
+      structDecl);
 
   // Don't bother synthesizing the body if we've already finished
   // type-checking.
@@ -2728,9 +2730,9 @@ namespace {
           // Create a pattern binding to describe the variable.
           Pattern *nsErrorPattern = createTypedNamedPattern(nsErrorProp);
 
-          auto nsErrorBinding = PatternBindingDecl::create(
-                                  C, loc, StaticSpellingKind::None, loc,
-                                  nsErrorPattern, nullptr, errorWrapper);
+          auto *nsErrorBinding = PatternBindingDecl::createImplicit(
+              C, StaticSpellingKind::None, nsErrorPattern, /*InitExpr*/ nullptr,
+              /*ParentDC*/ errorWrapper, /*VarLoc*/ loc);
           errorWrapper->addMember(nsErrorProp);
           errorWrapper->addMember(nsErrorBinding);
 
@@ -2810,9 +2812,9 @@ namespace {
         // Create a pattern binding to describe the variable.
         Pattern *varPattern = createTypedNamedPattern(rawValue);
 
-        auto rawValueBinding = PatternBindingDecl::create(
-            C, SourceLoc(), StaticSpellingKind::None, SourceLoc(),
-            varPattern, nullptr, enumDecl);
+        auto *rawValueBinding = PatternBindingDecl::createImplicit(
+            C, StaticSpellingKind::None, varPattern, /*InitExpr*/ nullptr,
+            enumDecl);
 
         auto rawValueGetter = makeEnumRawValueGetter(Impl, enumDecl, rawValue);
 

lib/Sema/CodeSynthesis.cpp

@@ -1068,11 +1068,8 @@ static void synthesizeObservedSetterBody(TypeChecker &TC, AccessorDecl *Set,
                                  Ctx.getIdentifier("tmp"), Type(), Set);
     OldValue->setImplicit();
     auto *tmpPattern = new (Ctx) NamedPattern(OldValue, /*implicit*/ true);
-    auto tmpPBD = PatternBindingDecl::create(Ctx, SourceLoc(),
-                                             StaticSpellingKind::None,
-                                             SourceLoc(),
-                                             tmpPattern, OldValueExpr, Set);
-    tmpPBD->setImplicit();
+    auto *tmpPBD = PatternBindingDecl::createImplicit(
+        Ctx, StaticSpellingKind::None, tmpPattern, OldValueExpr, Set);
     SetterBody.push_back(tmpPBD);
     SetterBody.push_back(OldValue);
   }
@@ -1199,10 +1196,8 @@ static void synthesizeLazyGetterBody(TypeChecker &TC, AccessorDecl *Get,
   auto *Tmp1Init =
     createPropertyLoadOrCallSuperclassGetter(Get, Storage,
                                              TargetImpl::Storage, TC);
-  auto *Tmp1PBD = PatternBindingDecl::create(Ctx, /*StaticLoc*/SourceLoc(),
-                                             StaticSpellingKind::None,
-                                             /*VarLoc*/SourceLoc(),
-                                             Tmp1PBDPattern, Tmp1Init, Get);
+  auto *Tmp1PBD = PatternBindingDecl::createImplicit(
+      Ctx, StaticSpellingKind::None, Tmp1PBDPattern, Tmp1Init, Get);
   Body.push_back(Tmp1PBD);
   Body.push_back(Tmp1VD);
 
@@ -1264,10 +1259,9 @@ static void synthesizeLazyGetterBody(TypeChecker &TC, AccessorDecl *Get,
                                           TypeLoc::withoutLoc(VD->getType()),
                                           /*implicit*/true);
 
-  auto *Tmp2PBD = PatternBindingDecl::create(Ctx, /*StaticLoc*/SourceLoc(),
-                                             StaticSpellingKind::None,
-                                             InitValue->getStartLoc(),
-                                             Tmp2PBDPattern, InitValue, Get);
+  auto *Tmp2PBD = PatternBindingDecl::createImplicit(
+      Ctx, StaticSpellingKind::None, Tmp2PBDPattern, InitValue, Get,
+      /*VarLoc*/ InitValue->getStartLoc());
   Body.push_back(Tmp2PBD);
   Body.push_back(Tmp2VD);
 
@@ -1414,12 +1408,9 @@ void TypeChecker::completePropertyBehaviorStorage(VarDecl *VD,
   PBDPattern = new (Context) TypedPattern(PBDPattern,
                                   TypeLoc::withoutLoc(SubstStorageContextTy),
                                   /*implicit*/true);
-  auto *PBD = PatternBindingDecl::create(Context, /*staticloc*/SourceLoc(),
-                             VD->getParentPatternBinding()->getStaticSpelling(),
-                             /*varloc*/VD->getLoc(),
-                             PBDPattern, /*init*/InitStorageExpr,
-                             VD->getDeclContext());
-  PBD->setImplicit();
+  auto *PBD = PatternBindingDecl::createImplicit(
+      Context, VD->getParentPatternBinding()->getStaticSpelling(), PBDPattern,
+      InitStorageExpr, VD->getDeclContext(), /*VarLoc*/ VD->getLoc());
   PBD->setInitializerChecked(0);
   addMemberToContextIfNeeded(PBD, VD->getDeclContext(), VD);
 
@@ -1608,13 +1599,11 @@ void TypeChecker::completePropertyBehaviorAccessors(VarDecl *VD,
                                        Context.getIdentifier("tempSelf"),
                                        selfTy, fromAccessor);
       var->setInterfaceType(selfIfaceTy);
+      var->setImplicit();
 
-      auto varPat = new (Context) NamedPattern(var);
-      auto pbd = PatternBindingDecl::create(Context, SourceLoc(),
-                                            StaticSpellingKind::None,
-                                            SourceLoc(),
-                                            varPat, selfExpr,
-                                            fromAccessor);
+      auto varPat = new (Context) NamedPattern(var, /*implicit*/ true);
+      auto *pbd = PatternBindingDecl::createImplicit(
+          Context, StaticSpellingKind::None, varPat, selfExpr, fromAccessor);
       bodyStmts.push_back(var);
       bodyStmts.push_back(pbd);
       selfExpr = new (Context) DeclRefExpr(var, DeclNameLoc(),
@@ -1727,12 +1716,9 @@ void TypeChecker::completeLazyVarImplementation(VarDecl *VD) {
   PBDPattern = new (Context) TypedPattern(PBDPattern,
                                           TypeLoc::withoutLoc(StorageTy),
                                           /*implicit*/true);
-  auto *PBD = PatternBindingDecl::create(Context, /*staticloc*/SourceLoc(),
-                                         StaticSpellingKind::None,
-                                         /*varloc*/VD->getLoc(),
-                                         PBDPattern, /*init*/nullptr,
-                                         VD->getDeclContext());
-  PBD->setImplicit();
+  auto *PBD = PatternBindingDecl::createImplicit(
+      Context, StaticSpellingKind::None, PBDPattern, /*init*/ nullptr,
+      VD->getDeclContext(), /*VarLoc*/ VD->getLoc());
   addMemberToContextIfNeeded(PBD, VD->getDeclContext(), VD);
 
   // Now that we've got the storage squared away, enqueue the getter and

lib/Sema/DerivedConformanceCodable.cpp

@@ -583,11 +583,8 @@ static void deriveBodyEncodable_encode(AbstractFunctionDecl *encodeDecl) {
   // binding.
   auto *containerPattern = new (C) NamedPattern(containerDecl,
                                                 /*implicit=*/true);
-  auto *bindingDecl = PatternBindingDecl::create(C, SourceLoc(),
-                                                 StaticSpellingKind::None,
-                                                 SourceLoc(),
-                                                 containerPattern, callExpr,
-                                                 funcDC);
+  auto *bindingDecl = PatternBindingDecl::createImplicit(
+      C, StaticSpellingKind::None, containerPattern, callExpr, funcDC);
   statements.push_back(bindingDecl);
   statements.push_back(containerDecl);
 
@@ -851,11 +848,8 @@ static void deriveBodyDecodable_init(AbstractFunctionDecl *initDecl) {
     // binding.
     auto *containerPattern = new (C) NamedPattern(containerDecl,
                                                   /*implicit=*/true);
-    auto *bindingDecl = PatternBindingDecl::create(C, SourceLoc(),
-                                                   StaticSpellingKind::None,
-                                                   SourceLoc(),
-                                                   containerPattern, tryExpr,
-                                                   funcDC);
+    auto *bindingDecl = PatternBindingDecl::createImplicit(
+        C, StaticSpellingKind::None, containerPattern, tryExpr, funcDC);
     statements.push_back(bindingDecl);
     statements.push_back(containerDecl);
 

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -224,10 +224,8 @@ static DeclRefExpr *convertEnumToIndex(SmallVectorImpl<ASTNode> &stmts,
   indexPat->setType(intType);
   indexPat = new (C) TypedPattern(indexPat, TypeLoc::withoutLoc(intType));
   indexPat->setType(intType);
-  auto indexBind = PatternBindingDecl::create(C, SourceLoc(),
-                                              StaticSpellingKind::None,
-                                              SourceLoc(),
-                                              indexPat, nullptr, funcDecl);
+  auto *indexBind = PatternBindingDecl::createImplicit(
+      C, StaticSpellingKind::None, indexPat, /*InitExpr*/ nullptr, funcDecl);
 
   unsigned index = 0;
   SmallVector<ASTNode, 4> cases;
@@ -1099,12 +1097,9 @@ static ValueDecl *deriveHashable_hashValue(DerivedConformance &derived) {
                            /*implicit*/ true);
   hashValuePat->setType(intType);
 
-  auto patDecl = PatternBindingDecl::create(C, SourceLoc(),
-                                            StaticSpellingKind::None,
-                                            SourceLoc(), hashValuePat, nullptr,
-                                            parentDC);
-  patDecl->setImplicit();
-
+  auto *patDecl = PatternBindingDecl::createImplicit(
+      C, StaticSpellingKind::None, hashValuePat, /*InitExpr*/ nullptr,
+      parentDC);
   C.addSynthesizedDecl(hashValueDecl);
   C.addSynthesizedDecl(getterDecl);
 

lib/Sema/DerivedConformances.cpp

@@ -363,12 +363,8 @@ DerivedConformance::declareDerivedProperty(Identifier name,
                                  /*implicit*/ true);
   propPat->setType(propertyContextType);
 
-  auto pbDecl = PatternBindingDecl::create(C, SourceLoc(),
-                                           StaticSpellingKind::None,
-                                           SourceLoc(), propPat, nullptr,
-                                           parentDC);
-  pbDecl->setImplicit();
-
+  auto *pbDecl = PatternBindingDecl::createImplicit(
+      C, StaticSpellingKind::None, propPat, /*InitExpr*/ nullptr, parentDC);
   return {propDecl, pbDecl};
 }
 

lib/Sema/PCMacro.cpp

@@ -487,10 +487,8 @@ class Instrumenter : InstrumenterBase {
     VD->setImplicit();
 
     NamedPattern *NP = new (Context) NamedPattern(VD, /*implicit*/ true);
-    PatternBindingDecl *PBD = PatternBindingDecl::create(
-        Context, SourceLoc(), StaticSpellingKind::None, SourceLoc(), NP,
-        MaybeLoadInitExpr, TypeCheckDC);
-    PBD->setImplicit();
+    PatternBindingDecl *PBD = PatternBindingDecl::createImplicit(
+        Context, StaticSpellingKind::None, NP, MaybeLoadInitExpr, TypeCheckDC);
 
     return std::make_pair(PBD, VD);
   }

lib/Sema/PlaygroundTransform.cpp

@@ -754,10 +754,8 @@ class Instrumenter : InstrumenterBase {
     VD->setImplicit();
 
     NamedPattern *NP = new (Context) NamedPattern(VD, /*implicit*/ true);
-    PatternBindingDecl *PBD = PatternBindingDecl::create(
-        Context, SourceLoc(), StaticSpellingKind::None, SourceLoc(), NP,
-        MaybeLoadInitExpr, TypeCheckDC);
-    PBD->setImplicit();
+    PatternBindingDecl *PBD = PatternBindingDecl::createImplicit(
+        Context, StaticSpellingKind::None, NP, MaybeLoadInitExpr, TypeCheckDC);
 
     return std::make_pair(PBD, VD);
   }

lib/Sema/TypeCheckStmt.cpp

@@ -642,11 +642,9 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
       // Create a pattern binding to initialize the generator.
       auto genPat = new (TC.Context) NamedPattern(generator);
       genPat->setImplicit();
-      auto genBinding =
-          PatternBindingDecl::create(TC.Context, SourceLoc(),
-                                     StaticSpellingKind::None,
-                                     S->getForLoc(), genPat, getIterator, DC);
-      genBinding->setImplicit();
+      auto *genBinding = PatternBindingDecl::createImplicit(
+          TC.Context, StaticSpellingKind::None, genPat, getIterator, DC,
+          /*VarLoc*/ S->getForLoc());
       S->setIterator(genBinding);
     }