[Sema] Always consider outer alternatives when resolving a decl ref.

Currently, when a type member has the same base name as a global declaration, one cannot refer to the global member from a method context, and the current diagnostics force the user to use a fully qualified name. This is a long-standing issue with the use of top-level `min` and `max` in an extension, and is causing unnecessarily verbosity in math algorithms in extensions for `ElementaryFunctions`-conforming types.

More context:
1. [Forum thread](https://forums.swift.org/t/elementaryfunctions-and-ambiguity-in-extensions/25297): `ElementaryFunctions` and ambiguity in extensions
2. [SR-456](https://bugs.swift.org/browse/SR-456): Confusing build error when calling 'max' function within 'extension Int'.
3. [SR-1772](https://bugs.swift.org/browse/SR-1772): File-level function with the same name as instance function not picked up by compiler.

This PR makes `UnresolvedDeclRefExpr` resolution always consider alternative candidates from the outer context. The following code will no longer trigger any error or warning.

```swift
import Foundation // which exports a top-level `sin(_:)`.

extension Float {
    func foo() {
        // Refers to top-level `sin(_:)`, not static method `Float.sin(_:)`.
        _ = sin(self)
        _ = sin(_:) as (Float) -> Float
    }
}

extension Sequence {
    func foo() {
        // Refers to top-level `max(_:_:)`.
        _ = max(1, 2)
    }
}
```

Author: rxwei

lib/Sema/CSApply.cpp

@@ -2660,10 +2660,7 @@ namespace {
         //
         // The only way to get here is via an UnresolvedDotExpr with outer
         // alternatives.
-        auto UDE = cast<UnresolvedDotExpr>(expr);
-        cs.diagnoseDeprecatedConditionalConformanceOuterAccess(
-            UDE, selected.choice.getDecl());
-
+        assert(isa<UnresolvedDotExpr>(expr));
         return buildDeclRef(selected.choice, nameLoc, selected.openedFullType,
                             memberLocator, implicit,
                             selected.choice.getFunctionRefKind(),

lib/Sema/CSSimplify.cpp

@@ -4604,16 +4604,16 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
         [&](unsigned, const OverloadChoice &choice) {
           return fixMemberRef(*this, baseTy, member, choice, locator);
         });
+  }
 
-    if (!outerAlternatives.empty()) {
-      // If local scope has a single choice,
-      // it should always be preferred.
-      if (candidates.size() == 1)
-        candidates.front()->setFavored();
+  if (!outerAlternatives.empty()) {
+    // If local scope has a single choice,
+    // it should always be preferred.
+    if (candidates.size() == 1)
+      candidates.front()->setFavored();
 
-      generateConstraints(candidates, memberTy, outerAlternatives,
-                          useDC, locator);
-    }
+    generateConstraints(candidates, memberTy, outerAlternatives,
+                        useDC, locator);
   }
 
   if (!result.UnviableCandidates.empty()) {

lib/Sema/TypeCheckConstraints.cpp

@@ -449,20 +449,6 @@ static bool findNonMembers(TypeChecker &TC,
   return AllDeclRefs;
 }
 
-/// Whether we should be looking at the outer results for a function called \c
-/// name.
-///
-/// This is very restrictive because it's a source compatibility issue (see the
-/// if (AllConditionalConformances) { (void)findNonMembers(...); } below).
-static bool shouldConsiderOuterResultsFor(DeclName name) {
-  const StringRef specialNames[] = {"min", "max"};
-  for (auto specialName : specialNames)
-    if (name.isSimpleName(specialName))
-      return true;
-
-  return false;
-}
-
 /// Bind an UnresolvedDeclRefExpr by performing name lookup and
 /// returning the resultant expression. Context is the DeclContext used
 /// for the lookup.
@@ -473,11 +459,10 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
   SourceLoc Loc = UDRE->getLoc();
 
   // Perform standard value name lookup.
-  NameLookupOptions lookupOptions = defaultUnqualifiedLookupOptions;
+  NameLookupOptions lookupOptions =
+      defaultUnqualifiedLookupOptions | NameLookupFlags::IncludeOuterResults;
   if (isa<AbstractFunctionDecl>(DC))
     lookupOptions |= NameLookupFlags::KnownPrivate;
-  if (shouldConsiderOuterResultsFor(Name))
-    lookupOptions |= NameLookupFlags::IncludeOuterResults;
 
   auto Lookup = lookupUnqualified(DC, Name, Loc, lookupOptions);
 
@@ -762,22 +747,11 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
                                            /*Implicit=*/true);
     }
 
-    // We *might* include any non-members that we found in outer contexts in
-    // some special cases, for backwards compatibility: first, we have to be
-    // looking for one of the special names
-    // ('shouldConsiderOuterResultsFor(Name)'), and second, all of the inner
-    // results need to come from conditional conformances. The second condition
-    // is how the problem here was encountered: a type ('Range') was made to
-    // conditionally conform to a new protocol ('Sequence'), which introduced
-    // some extra methods ('min' and 'max') that shadowed global functions that
-    // people regularly called within extensions to that type (usually adding
-    // 'clamp').
+    // Include any non-members that we found in outer contexts.
     llvm::SmallVector<ValueDecl *, 4> outerAlternatives;
-    if (AllConditionalConformances) {
-      (void)findNonMembers(*this, Lookup.outerResults(), UDRE->getRefKind(),
-                           /*breakOnMember=*/false, outerAlternatives,
-                           /*isValid=*/[&](ValueDecl *) { return true; });
-    }
+    (void)findNonMembers(*this, Lookup.outerResults(), UDRE->getRefKind(),
+                         /*breakOnMember=*/false, outerAlternatives,
+                         /*isValid=*/[&](ValueDecl *) { return true; });
 
     // Otherwise, form an UnresolvedDotExpr and sema will resolve it based on
     // type information.