Reapply Simplify resolveLocatorToDecl to return a ConcreteDeclRef instead of

   having it return a ResolvedLocator, allowing us to remove ResolvedLocator

The previous commit accidentally dropped the hunk in CSApply.cpp.  NFC.

Author: lattner

lib/Sema/CSApply.cpp

@@ -3393,7 +3393,7 @@ findDefaultArgsOwner(ConstraintSystem &cs, const Solution &solution,
 
               return decl;
             })) {
-    return resolved.getDecl();
+    return resolved;
   }
 
   return nullptr;

lib/Sema/CSDiag.cpp

@@ -303,7 +303,7 @@ static ParameterList *getParameterList(ValueDecl *decl) {
   return nullptr;
 }
 
-ResolvedLocator constraints::resolveLocatorToDecl(
+ConcreteDeclRef constraints::resolveLocatorToDecl(
    ConstraintSystem &cs,
    ConstraintLocator *locator,
    std::function<Optional<SelectedOverload>(ConstraintLocator *)> findOvlChoice,
@@ -312,7 +312,7 @@ ResolvedLocator constraints::resolveLocatorToDecl(
 {
   assert(locator && "Null locator");
   if (!locator->getAnchor())
-    return ResolvedLocator();
+    return ConcreteDeclRef();
 
   ConcreteDeclRef declRef;
   auto anchor = locator->getAnchor();
@@ -391,7 +391,7 @@ ResolvedLocator constraints::resolveLocatorToDecl(
 
   // If we didn't find the declaration, we're out of luck.
   if (!declRef)
-    return ResolvedLocator();
+    return ConcreteDeclRef();
 
   // Use the declaration and the path to produce a more specific result.
   // FIXME: This is an egregious hack. We'd be far better off
@@ -416,10 +416,8 @@ ResolvedLocator constraints::resolveLocatorToDecl(
       if (!parameterList) break;
 
       unsigned index = path[0].getValue2();
-      if (index < parameterList->size()) {
-        auto param = parameterList->get(index);
-        return ResolvedLocator(ResolvedLocator::ForVar, param);
-      }
+      if (index < parameterList->size())
+        return parameterList->get(index);
       break;
     }
 
@@ -431,14 +429,13 @@ ResolvedLocator constraints::resolveLocatorToDecl(
   }
 
   // Otherwise, do the best we can with the declaration we found.
-  if (isa<FuncDecl>(declRef.getDecl()))
-    return ResolvedLocator(ResolvedLocator::ForFunction, declRef);
-  if (isa<ConstructorDecl>(declRef.getDecl()))
-    return ResolvedLocator(ResolvedLocator::ForConstructor, declRef);
-
   // FIXME: Deal with the other interesting cases here, e.g.,
   // subscript declarations.
-  return ResolvedLocator();
+  if (isa<FuncDecl>(declRef.getDecl()) ||
+      isa<ConstructorDecl>(declRef.getDecl()))
+    return declRef;
+
+  return ConcreteDeclRef();
 }
 
 /// Emit a note referring to the target of a diagnostic, e.g., the function
@@ -463,32 +460,29 @@ static void noteTargetOfDiagnostic(ConstraintSystem &cs,
   if (!resolved)
     return;
 
-  switch (resolved.getKind()) {
-  case ResolvedLocatorKind::Unresolved:
-    // Can't emit any diagnostic here.
-    return;
-
-  case ResolvedLocatorKind::Function: {
-    auto name = resolved.getDecl().getDecl()->getName();
-    cs.getTypeChecker().diagnose(resolved.getDecl().getDecl(),
+  auto decl = resolved.getDecl();
+  if (isa<FuncDecl>(decl)) {
+    auto name = decl->getName();
+    cs.getTypeChecker().diagnose(decl,
                                  name.isOperator()? diag::note_call_to_operator
                                                   : diag::note_call_to_func,
-                                 resolved.getDecl().getDecl()->getName());
+                                 name);
     return;
   }
 
-  case ResolvedLocatorKind::Constructor:
+  if (isa<ConstructorDecl>(decl)) {
     // FIXME: Specialize for implicitly-generated constructors.
-    cs.getTypeChecker().diagnose(resolved.getDecl().getDecl(),
-                                 diag::note_call_to_initializer);
+    cs.getTypeChecker().diagnose(decl, diag::note_call_to_initializer);
     return;
+  }
 
-  case ResolvedLocatorKind::Parameter:
-    cs.getTypeChecker().diagnose(resolved.getDecl().getDecl(),
-                                 diag::note_init_parameter,
-                                 resolved.getDecl().getDecl()->getName());
+  if (isa<ParamDecl>(decl)) {
+    cs.getTypeChecker().diagnose(decl, diag::note_init_parameter,
+                                 decl->getName());
     return;
   }
+
+  // FIXME: Other decl types too.
 }
 
 /// \brief Determine the number of distinct overload choices in the

lib/Sema/ConstraintSystem.h

@@ -2232,59 +2232,6 @@ void simplifyLocator(Expr *&anchor,
                      SmallVectorImpl<LocatorPathElt> &targetPath,
                      SourceRange &range);
 
-/// Describes the kind of entity to which a locator was resolved.
-enum class ResolvedLocatorKind : uint8_t {
-  /// The locator could not be resolved.
-  Unresolved,
-  /// The locator refers to a function.
-  Function,
-  /// The locator refers to a constructor.
-  Constructor,
-  /// The locator refers to a parameter of a function.
-  Parameter
-};
-
-/// The entity to which a locator resolved.
-class ResolvedLocator {
-  ResolvedLocatorKind kind;
-  ConcreteDeclRef decl;
-
-public:
-  ResolvedLocator() : kind(ResolvedLocatorKind::Unresolved) { }
-
-  enum ForFunction_t { ForFunction };
-  enum ForConstructor_t { ForConstructor };
-  enum ForVar_t { ForVar };
-  
-  ResolvedLocator(ForFunction_t, ConcreteDeclRef decl)
-    : kind(ResolvedLocatorKind::Function), decl(decl)
-  {
-    assert(isa<FuncDecl>(decl.getDecl()));
-  }
-
-  ResolvedLocator(ForConstructor_t, ConcreteDeclRef decl)
-    : kind(ResolvedLocatorKind::Constructor), decl(decl)
-  {
-    assert(isa<ConstructorDecl>(decl.getDecl()));
-  }
-
-  ResolvedLocator(ForVar_t, ConcreteDeclRef decl)
-    : kind(ResolvedLocatorKind::Parameter), decl(decl)
-  {
-    assert(isa<VarDecl>(decl.getDecl()));
-  }
-  
-  /// Determine the kind of entity to which the locator resolved.
-  ResolvedLocatorKind getKind() const { return kind; }
-
-  /// Retrieve the declaration to which the locator resolved.
-  ConcreteDeclRef getDecl() const { return decl; }
-
-  explicit operator bool() const {
-    return getKind() != ResolvedLocatorKind::Unresolved;
-  }
-};
-
 /// Resolve a locator to the specific declaration it references, if possible.
 ///
 /// \param cs The constraint system in which the locator will be resolved.
@@ -2298,7 +2245,7 @@ class ResolvedLocator {
 /// \returns the entity to which the locator resolved.
 ///
 /// FIXME: It would be more natural to express the result as a locator.
-ResolvedLocator resolveLocatorToDecl(
+ConcreteDeclRef resolveLocatorToDecl(
                   ConstraintSystem &cs,
                   ConstraintLocator *locator,
                   std::function<Optional<SelectedOverload>(ConstraintLocator *)>