Rework computation of local discriminators for named entities.

Local discriminators for named entities are currently being set by the
parser, so entities not created by the parser (e.g., that come from
synthesized code) don't get local discriminators. Moreover, there is
no checking to ensure that every named local entity gets a local
discriminator, so some entities would incorrectly get a local
discriminator of 0.

Assign local discriminators as part of setting closure discriminators,
in response to a request asking for the local discriminator, so the
parser does not need to track this information, and all local
declarations---including synthesized ones---get local discriminators.
And add checking to make sure that every entity that needs a local
discriminator gets assigned one.

There are a few interesting cases in here:
* There was a potential mangling collision with local property
wrappers because their generated variables weren't getting local
discriminators
* $interpolation variables introduced for string interpolation weren't
getting local discriminators, they were just wrong.
* "Local rename" when dealing with captures like `[x]` was dependent on
the new delcaration of `x` *not* getting a local discriminator. There
are funny cases involving nesting where it would do the wrong thing.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2292,10 +2292,14 @@ class GenericParameterReferenceInfo final {
 /// ValueDecl - All named decls that are values in the language.  These can
 /// have a type, etc.
 class ValueDecl : public Decl {
+public:
+  enum : unsigned { InvalidDiscriminator = 0xFFFF };
+
+private:
   DeclName Name;
   SourceLoc NameLoc;
   llvm::PointerIntPair<Type, 3, OptionalEnum<AccessLevel>> TypeAndAccess;
-  unsigned LocalDiscriminator = 0;
+  unsigned LocalDiscriminator = InvalidDiscriminator;
 
   struct {
     /// Whether the "IsObjC" bit has been computed yet.
@@ -2582,6 +2586,12 @@ class ValueDecl : public Decl {
   unsigned getLocalDiscriminator() const;
   void setLocalDiscriminator(unsigned index);
 
+  /// Whether this declaration has a local discriminator.
+  bool hasLocalDiscriminator() const;
+
+  /// Return the "raw" local discriminator, without computing it.
+  unsigned getRawLocalDiscriminator() const { return LocalDiscriminator; }
+
   /// Retrieve the declaration that this declaration overrides, if any.
   ValueDecl *getOverriddenDecl() const;
 

include/swift/AST/TypeCheckRequests.h

@@ -3850,7 +3850,7 @@ class SynthesizeRuntimeMetadataAttrGeneratorBody
 /// Compute the local discriminators for the given declaration context.
 ///
 /// This is a state-changing operation for closures within the context, which
-/// produces the number of assigned discriminators.
+/// produces the discriminator value that any subsequent requests should use.
 class LocalDiscriminatorsRequest
     : public SimpleRequest<LocalDiscriminatorsRequest,
                            unsigned(DeclContext *),

include/swift/Parse/LocalContext.h

@@ -27,24 +27,11 @@ namespace swift {
 
 /// Information associated with parsing a local context.
 class LocalContext {
-  /// A map holding the next discriminator for declarations with
-  /// various identifiers.
-  llvm::DenseMap<Identifier, unsigned> LocalDiscriminators;
-
   LocalContext(const LocalContext &) = delete;
   LocalContext &operator=(const LocalContext &) = delete;
 
 public:
   LocalContext() = default;
-
-  /// Return a number that'll be unique in this context across all
-  /// declarations with the given name.
-  unsigned claimNextNamedDiscriminator(Identifier name) {
-    assert(!name.empty() &&
-           "setting a local discriminator on an anonymous decl; "
-           "maybe the name hasn't been set yet?");
-    return LocalDiscriminators[name]++;
-  }
 };
 
 /// Information associated with parsing the top-level context.

lib/AST/Decl.cpp

@@ -2696,13 +2696,49 @@ bool ValueDecl::isInstanceMember() const {
   llvm_unreachable("bad DeclKind");
 }
 
+bool ValueDecl::hasLocalDiscriminator() const {
+  // Generic parameters and unnamed parameters never have local discriminators.
+  if (isa<GenericTypeParamDecl>(this) ||
+      (isa<ParamDecl>(this) && !hasName()))
+    return false;
+
+  // Implicit and unnamed declarations never have local discriminators.
+  if (getBaseName().isSpecial())
+    return false;
+
+  // If we are not in a local context, there's nothing to do.
+  if (!getDeclContext()->isLocalContext())
+    return false;
+
+  return true;
+}
+
 unsigned ValueDecl::getLocalDiscriminator() const {
+  // If we have already assigned a local discriminator, we're done.
+  if (LocalDiscriminator != InvalidDiscriminator)
+    return LocalDiscriminator;
+
+  // If this declaration does not have a local discriminator, use 0 as a
+  // stand-in.
+  if (!hasLocalDiscriminator())
+    return 0;
+
+  // Assign local discriminators in this context.
+  evaluateOrDefault(
+      getASTContext().evaluator,
+      LocalDiscriminatorsRequest{getDeclContext()}, InvalidDiscriminator);
+  if (LocalDiscriminator == InvalidDiscriminator)
+    dump();
+
+  assert(LocalDiscriminator != InvalidDiscriminator);
+
   return LocalDiscriminator;
 }
 
 void ValueDecl::setLocalDiscriminator(unsigned index) {
-  assert(getDeclContext()->isLocalContext());
-  assert(LocalDiscriminator == 0 && "LocalDiscriminator is set multiple times");
+  assert(hasLocalDiscriminator());
+  assert(LocalDiscriminator == InvalidDiscriminator &&
+         "LocalDiscriminator is set multiple times");
   LocalDiscriminator = index;
 }
 

lib/Index/Index.cpp

@@ -448,6 +448,10 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
   StringScratchSpace stringStorage;
   ContainerTracker Containers;
 
+  // Contains a mapping for captures of the form [x], from the declared "x"
+  // to the captured "x" in the enclosing scope.
+  llvm::DenseMap<VarDecl *, VarDecl *> sameNamedCaptures;
+
   bool getNameAndUSR(ValueDecl *D, ExtensionDecl *ExtD,
                      StringRef &name, StringRef &USR) {
     auto &result = nameAndUSRCache[ExtD ? (Decl*)ExtD : D];
@@ -701,6 +705,26 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
   bool walkToExprPre(Expr *E) override {
     if (Cancelled)
       return false;
+
+    // Record any captures of the form [x], herso we can treat
+    if (auto captureList = dyn_cast<CaptureListExpr>(E)) {
+      for (const auto &capture : captureList->getCaptureList()) {
+        auto declaredVar = capture.getVar();
+        if (capture.PBD->getEqualLoc(0).isValid())
+          continue;
+
+        VarDecl *capturedVar = nullptr;
+        if (auto init = capture.PBD->getInit(0)) {
+          if (auto declRef = dyn_cast<DeclRefExpr>(init))
+            capturedVar = dyn_cast_or_null<VarDecl>(declRef->getDecl());
+        }
+
+        if (capturedVar) {
+          sameNamedCaptures[declaredVar] = capturedVar;
+        }
+      }
+    }
+
     ExprStack.push_back(E);
     Containers.activateContainersFor(E);
     handleMemberwiseInitRefs(E);
@@ -1611,6 +1635,15 @@ bool IndexSwiftASTWalker::initIndexSymbol(ValueDecl *D, SourceLoc Loc,
   if (auto *VD = dyn_cast<VarDecl>(D)) {
     // Always base the symbol information on the canonical VarDecl
     D = VD->getCanonicalVarDecl();
+
+    // Dig back to the original captured variable.
+    while (true) {
+      auto captured = sameNamedCaptures.find(cast<VarDecl>(D));
+      if (captured == sameNamedCaptures.end())
+        break;
+
+      D = captured->second;
+    }
   }
 
   Info.decl = D;

lib/Parse/ParseDecl.cpp

@@ -4620,10 +4620,6 @@ void Parser::setLocalDiscriminator(ValueDecl *D) {
   if (auto TD = dyn_cast<TypeDecl>(D))
     if (!InInactiveClauseEnvironment)
       SF.LocalTypeDecls.insert(TD);
-
-  const Identifier name = D->getBaseIdentifier();
-  unsigned discriminator = CurLocalContext->claimNextNamedDiscriminator(name);
-  D->setLocalDiscriminator(discriminator);
 }
 
 void Parser::setLocalDiscriminatorToParamList(ParameterList *PL) {

lib/Parse/Parser.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/ParseRequests.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/SourceFile.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Parse/Lexer.h"
@@ -149,6 +150,10 @@ void Parser::performIDEInspectionSecondPassImpl(
 
   DeclContext *DC = info.ParentContext;
 
+  // Forget about the fact that we may have already computed local
+  // discriminators.
+  Context.evaluator.clearCachedOutput(LocalDiscriminatorsRequest{DC});
+
   switch (info.Kind) {
   case IDEInspectionDelayedDeclKind::TopLevelCodeDecl: {
     // Re-enter the top-level code decl context.