[AST] Add bit to VarDecl for isPlaceholderVar

This allows the query to be consistent both during type-checking and
after.

Author: hamishknight

include/swift/AST/Decl.h

@@ -493,7 +493,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     IsStatic : 1
   );
 
-  SWIFT_INLINE_BITFIELD(VarDecl, AbstractStorageDecl, 2+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(VarDecl, AbstractStorageDecl, 2+1+1+1+1+1+1+1+1,
     /// Encodes whether this is a 'let' binding.
     Introducer : 2,
 
@@ -517,7 +517,11 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     NoAttachedPropertyWrappers : 1,
 
     /// Whether this variable has no property wrapper auxiliary variables.
-    NoPropertyWrapperAuxiliaryVariables : 1
+    NoPropertyWrapperAuxiliaryVariables : 1,
+
+    /// Whether this variable is a placeholder that is introducing during
+    /// type-checking that has its type inferred from its use.
+    IsPlaceholderVar : 1
   );
 
   SWIFT_INLINE_BITFIELD(ParamDecl, VarDecl, 1+2+NumDefaultArgumentKindBits,
@@ -6767,6 +6771,15 @@ class VarDecl : public AbstractStorageDecl {
     Bits.VarDecl.IsLazyStorageProperty = IsLazyStorage;
   }
 
+  /// Whether this variable is a placeholder that is introducing during
+  /// type-checking that has its type inferred from its use.
+  bool isPlaceholderVar() const {
+    return Bits.VarDecl.IsPlaceholderVar;
+  }
+  void setIsPlaceholderVar() {
+    Bits.VarDecl.IsPlaceholderVar = true;
+  }
+
   /// Retrieve the backing storage property for a lazy property.
   VarDecl *getLazyStorageProperty() const;
 

lib/AST/Decl.cpp

@@ -8044,6 +8044,7 @@ VarDecl::VarDecl(DeclKind kind, bool isStatic, VarDecl::Introducer introducer,
   Bits.VarDecl.IsTopLevelGlobal = false;
   Bits.VarDecl.NoAttachedPropertyWrappers = false;
   Bits.VarDecl.NoPropertyWrapperAuxiliaryVariables = false;
+  Bits.VarDecl.IsPlaceholderVar = false;
 }
 
 Type VarDecl::getTypeInContext() const {

lib/Sema/BuilderTransform.cpp

@@ -124,6 +124,7 @@ class ResultBuilderTransform
                                SmallVectorImpl<ASTNode> &container,
                                Type type = Type(), Expr *initExpr = nullptr) {
     auto *var = builder.buildVar(loc);
+    var->setIsPlaceholderVar();
     Pattern *placeholder = TypedPattern::createImplicit(
         ctx, NamedPattern::createImplicit(ctx, var),
         type ? type : PlaceholderType::get(ctx, var));

lib/Sema/CSSyntacticElement.cpp

@@ -2783,20 +2783,13 @@ void ConjunctionElement::findReferencedVariables(
 
 Type constraints::isPlaceholderVar(PatternBindingDecl *PB) {
   auto *var = PB->getSingleVar();
-  if (!var)
-    return Type();
-
-  if (!var->getName().hasDollarPrefix())
+  if (!var || !var->isPlaceholderVar())
     return Type();
 
   auto *pattern = PB->getPattern(0);
   auto *typedPattern = dyn_cast<TypedPattern>(pattern);
   if (!typedPattern || !typedPattern->hasType())
     return Type();
 
-  auto type = typedPattern->getType();
-  if (!type->hasPlaceholder())
-    return Type();
-
-  return type;
+  return typedPattern->getType();
 }

lib/Sema/PreCheckTarget.cpp

@@ -393,29 +393,28 @@ static bool isMemberChainTail(Expr *expr, Expr *parent, MemberChainKind kind) {
 }
 
 static bool isValidForwardReference(ValueDecl *D, DeclContext *DC,
-                                    ValueDecl **localDeclAfterUse) {
-  *localDeclAfterUse = nullptr;
-
-  // References to variables injected by lldb are always valid.
-  if (isa<VarDecl>(D) && cast<VarDecl>(D)->isDebuggerVar())
+                                    ValueDecl *&localDeclAfterUse) {
+  // Only VarDecls require declaration before use.
+  auto *VD = dyn_cast<VarDecl>(D);
+  if (!VD)
     return true;
 
-  // If we find something in the current context, it must be a forward
-  // reference, because otherwise if it was in scope, it would have
-  // been returned by the call to ASTScope::lookupLocalDecls() above.
-  if (D->getDeclContext()->isLocalContext()) {
-    do {
-      if (D->getDeclContext() == DC) {
-        *localDeclAfterUse = D;
-        return false;
-      }
+  // Non-local and variables injected by lldb are always valid.
+  auto *varDC = VD->getDeclContext();
+  if (!varDC->isLocalContext() || VD->isDebuggerVar())
+    return true;
 
-      // If we're inside of a 'defer' context, walk up to the parent
-      // and check again. We don't want 'defer' bodies to forward
-      // reference bindings in the immediate outer scope.
-    } while (isa<FuncDecl>(DC) &&
-             cast<FuncDecl>(DC)->isDeferBody() &&
-             (DC = DC->getParent()));
+  while (true) {
+    if (varDC == DC) {
+      localDeclAfterUse = VD;
+      return false;
+    }
+    if (isa<AbstractClosureExpr>(DC) ||
+        (isa<FuncDecl>(DC) && cast<FuncDecl>(DC)->isDeferBody())) {
+      DC = DC->getParent();
+      continue;
+    }
+    break;
   }
   return true;
 }
@@ -587,12 +586,11 @@ static Expr *resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC,
     Lookup = TypeChecker::lookupUnqualified(DC, LookupName, Loc, lookupOptions);
 
     ValueDecl *localDeclAfterUse = nullptr;
-    AllDeclRefs =
-        findNonMembers(Lookup.innerResults(), UDRE->getRefKind(),
-                       /*breakOnMember=*/true, ResultValues,
-                       [&](ValueDecl *D) {
-                         return isValidForwardReference(D, DC, &localDeclAfterUse);
-                       });
+    AllDeclRefs = findNonMembers(
+        Lookup.innerResults(), UDRE->getRefKind(),
+        /*breakOnMember=*/true, ResultValues, [&](ValueDecl *D) {
+          return isValidForwardReference(D, DC, localDeclAfterUse);
+        });
 
     // If local declaration after use is found, check outer results for
     // better matching candidates.
@@ -609,12 +607,11 @@ static Expr *resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC,
         Lookup.shiftDownResults();
         ResultValues.clear();
         localDeclAfterUse = nullptr;
-        AllDeclRefs =
-            findNonMembers(Lookup.innerResults(), UDRE->getRefKind(),
-                           /*breakOnMember=*/true, ResultValues,
-                           [&](ValueDecl *D) {
-                             return isValidForwardReference(D, DC, &localDeclAfterUse);
-                           });
+        AllDeclRefs = findNonMembers(
+            Lookup.innerResults(), UDRE->getRefKind(),
+            /*breakOnMember=*/true, ResultValues, [&](ValueDecl *D) {
+              return isValidForwardReference(D, DC, localDeclAfterUse);
+            });
       }
     }
   }

test/NameLookup/name_lookup.swift

@@ -643,8 +643,8 @@ struct PatternBindingWithTwoVars3 { var x = y, y = x }
 
 // https://github.com/apple/swift/issues/51518
 do {
-  let closure1 = { closure2() } // expected-error {{circular reference}} expected-note {{through reference here}}
-  let closure2 = { closure1() } // expected-note {{through reference here}} expected-note {{through reference here}}
+  let closure1 = { closure2() } // expected-error {{use of local variable 'closure2' before its declaration}}
+  let closure2 = { closure1() } // expected-note {{'closure2' declared here}}
 }
 
 func color(with value: Int) -> Int {

test/NameLookup/use_before_declaration_shadowing.swift

@@ -0,0 +1,76 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -parse-as-library
+
+func testLocal() {
+  // The first `y` here is considered the inner result.
+  do {
+    let y = ""
+    do {
+      let _: String = y
+      let y = 0
+      _ = y
+    }
+  }
+  do {
+    let y = ""
+    do {
+      _ = {
+        let _: String = y
+      }
+      let y = 0
+      _ = y
+    }
+  }
+  do {
+    let y = ""
+    _ = {
+      _ = {
+        let _: String = y
+      }
+      let y = 0
+      _ = y
+    }
+  }
+  do {
+    let y = ""
+    func bar() {
+      _ = {
+        let _: String = y
+      }
+      let y = 0
+      _ = y
+    }
+  }
+}
+
+let topLevelString = ""
+
+func testTopLevel() {
+  // Here 'topLevelString' is now an outer result.
+  do {
+    let _: String = topLevelString
+    let topLevelString = 0
+    _ = topLevelString
+  }
+  do {
+    _ = {
+      let _: String = topLevelString
+    }
+    let topLevelString = 0
+    _ = topLevelString
+  }
+  _ = {
+    _ = {
+      let _: String = topLevelString
+    }
+    let topLevelString = 0
+    _ = topLevelString
+  }
+  func bar() {
+    _ = {
+      let _: String = topLevelString
+    }
+    let topLevelString = 0
+    _ = topLevelString
+  }
+}