Merge remote-tracking branch 'origin/master' into master-next

swift-ci · swift-ci · commit 3c874745ef34 · 2019-05-21T16:50:38.000-07:00
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
@@ -738,6 +738,17 @@ void FailureDiagnosis::diagnoseUnviableLookupResults(
     instanceTy = MTT->getInstanceType();
   
   if (sameProblem) {
+    // If the problem is the same for all of the choices, let's
+    // just pick one which has a declaration.
+    auto choice = llvm::find_if(
+        result.UnviableCandidates,
+        [&](const OverloadChoice &choice) { return choice.isDecl(); });
+
+    // This code can't currently diagnose key path application
+    // related failures.
+    if (!choice)
+      return;
+
     switch (firstProblem) {
     case MemberLookupResult::UR_LabelMismatch:
     case MemberLookupResult::UR_WritableKeyPathOnReadOnlyMember:
@@ -755,7 +766,7 @@ void FailureDiagnosis::diagnoseUnviableLookupResults(
                              ? ConstraintLocator::SubscriptMember
                              : ConstraintLocator::Member;
       AllowTypeOrInstanceMemberFailure failure(
-          nullptr, CS, baseObjTy, memberName,
+          expr, CS, baseObjTy, choice->getDecl(), memberName,
           CS.getConstraintLocator(E, locatorKind));
       auto diagnosed = failure.diagnoseAsError();
       assert(diagnosed &&
@@ -778,24 +789,27 @@ void FailureDiagnosis::diagnoseUnviableLookupResults(
     }
         
     case MemberLookupResult::UR_Inaccessible: {
-      auto decl = result.UnviableCandidates[0].getDecl();
       // FIXME: What if the unviable candidates have different levels of access?
       //
       // If we found an inaccessible member of a protocol extension, it might
       // be declared 'public'. This can only happen if the protocol is not
       // visible to us, but the conforming type is. In this case, we need to
       // clamp the formal access for diagnostics purposes to the formal access
       // of the protocol itself.
-      InaccessibleMemberFailure failure(expr, CS, decl,
+      InaccessibleMemberFailure failure(expr, CS, choice->getDecl(),
                                         CS.getConstraintLocator(E));
       auto diagnosed = failure.diagnoseAsError();
       assert(diagnosed && "failed to produce expected diagnostic");
       for (auto cand : result.UnviableCandidates) {
-        auto *choice = cand.getDecl();
+        if (!cand.isDecl())
+          continue;
+
+        auto *candidate = cand.getDecl();
         // failure is going to highlight candidate given to it,
         // we just need to handle the rest here.
-        if (choice != decl)
-          diagnose(choice, diag::decl_declared_here, choice->getFullName());
+        if (candidate != choice->getDecl())
+          diagnose(candidate, diag::decl_declared_here,
+                   candidate->getFullName());
       }
       return;
     }
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -1974,26 +1974,6 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
   Expr *expr = getParentExpr();
   SourceRange baseRange = expr ? expr->getSourceRange() : SourceRange();
 
-  auto overload = getOverloadChoiceIfAvailable(locator);
-  if (!overload)
-    return false;
-
-  ValueDecl *decl = nullptr;
-
-  if (!overload->choice.isDecl()) {
-    auto baseTy = overload->choice.getBaseType();
-    if (auto MT = baseTy->getAs<MetatypeType>()) {
-      if (auto VD = dyn_cast<ValueDecl>(
-              MT->getMetatypeInstanceType()->getAnyNominal()->getAsDecl())) {
-        decl = VD;
-      }
-    } else {
-      return true;
-    }
-  }
-
-  auto member = decl ? decl : overload->choice.getDecl();
-
   // If the base is an implicit self type reference, and we're in a
   // an initializer, then the user wrote something like:
   //
@@ -2062,7 +2042,7 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
     }
   }
 
-  if (BaseType->is<AnyMetatypeType>() && !member->isStatic()) {
+  if (BaseType->is<AnyMetatypeType>() && !Member->isStatic()) {
     auto instanceTy = BaseType;
 
     if (auto *AMT = instanceTy->getAs<AnyMetatypeType>()) {
@@ -2117,7 +2097,8 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
 
     // Check whether the instance member is declared on parent context and if so
     // provide more specialized message.
-    auto memberTypeContext = member->getDeclContext()->getInnermostTypeContext();
+    auto memberTypeContext =
+        Member->getDeclContext()->getInnermostTypeContext();
     auto currentTypeContext = cs.DC->getInnermostTypeContext();
     
     if (memberTypeContext && currentTypeContext &&
@@ -2127,7 +2108,7 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
                      currentTypeContext->getDeclaredInterfaceType(), Name,
                      memberTypeContext->getDeclaredInterfaceType(), true)
           .highlight(baseRange)
-          .highlight(member->getSourceRange());
+          .highlight(Member->getSourceRange());
       return true;
     }
 
@@ -2164,13 +2145,13 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
         // Give a customized message if we're accessing a member type
         // of a protocol -- otherwise a diagnostic talking about
         // static members doesn't make a whole lot of sense
-        if (auto TAD = dyn_cast<TypeAliasDecl>(member)) {
+        if (auto TAD = dyn_cast<TypeAliasDecl>(Member)) {
           Diag.emplace(emitDiagnostic(loc, diag::typealias_outside_of_protocol,
                                       TAD->getName()));
-        } else if (auto ATD = dyn_cast<AssociatedTypeDecl>(member)) {
+        } else if (auto ATD = dyn_cast<AssociatedTypeDecl>(Member)) {
           Diag.emplace(emitDiagnostic(loc, diag::assoc_type_outside_of_protocol,
                                       ATD->getName()));
-        } else if (isa<ConstructorDecl>(member)) {
+        } else if (isa<ConstructorDecl>(Member)) {
           Diag.emplace(emitDiagnostic(loc, diag::construct_protocol_by_name,
                                       instanceTy));
         } else {
@@ -2200,11 +2181,11 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
     // components, let's provide a tailored diagnostic and return because
     // that is unsupported so there is no fix-it.
     if (locator->isForKeyPathComponent()) {
-      InvalidStaticMemberRefInKeyPath failure(expr, cs, member, locator);
+      InvalidStaticMemberRefInKeyPath failure(expr, cs, Member, locator);
       return failure.diagnoseAsError();
     }
 
-    if (isa<EnumElementDecl>(member)) {
+    if (isa<EnumElementDecl>(Member)) {
       Diag.emplace(emitDiagnostic(
           loc, diag::could_not_use_enum_element_on_instance, Name));
     } else {
@@ -2232,13 +2213,11 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
     }
     
     // Try to provide a fix-it that only contains a '.'
-    if (contextualType) {
-      if (baseTy->isEqual(contextualType)) {
-        Diag->fixItInsert(loc, ".");
-        return true;
-      }
+    if (contextualType && baseTy->isEqual(contextualType)) {
+      Diag->fixItInsert(loc, ".");
+      return true;
     }
-    
+
     // Check if the expression is the matching operator ~=, most often used in
     // case statements. If so, try to provide a single dot fix-it
     const Expr *contextualTypeNode = nullptr;
@@ -2273,17 +2252,22 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
     }
 
     // Fall back to a fix-it with a full type qualifier
-    auto nominal = member->getDeclContext()->getSelfNominalTypeDecl();
-    SmallString<32> typeName;
-    llvm::raw_svector_ostream typeNameStream(typeName);
-    typeNameStream << nominal->getSelfInterfaceType() << ".";
-    
-    Diag->fixItInsert(loc, typeNameStream.str());
+    if (auto *NTD = Member->getDeclContext()->getSelfNominalTypeDecl()) {
+      auto typeName = NTD->getSelfInterfaceType()->getString();
+      if (auto *SE = dyn_cast<SubscriptExpr>(getRawAnchor())) {
+        auto *baseExpr = SE->getBase();
+        Diag->fixItReplace(baseExpr->getSourceRange(), typeName);
+      } else {
+        Diag->fixItInsert(loc, typeName + ".");
+      }
+    }
+
     return true;
   }
-  
+
   return false;
 }
+
 bool PartialApplicationFailure::diagnoseAsError() {
   auto &cs = getConstraintSystem();
   auto *anchor = cast<UnresolvedDotExpr>(getRawAnchor());
diff --git a/lib/Sema/CSDiagnostics.h b/lib/Sema/CSDiagnostics.h
@@ -807,17 +807,21 @@ class MissingMemberFailure final : public FailureDiagnostic {
 /// ```
 class AllowTypeOrInstanceMemberFailure final : public FailureDiagnostic {
   Type BaseType;
+  ValueDecl *Member;
   DeclName Name;
 
 public:
   AllowTypeOrInstanceMemberFailure(Expr *root, ConstraintSystem &cs,
-                                   Type baseType, DeclName memberName,
-                                   ConstraintLocator *locator)
+                                   Type baseType, ValueDecl *member,
+                                   DeclName name, ConstraintLocator *locator)
       : FailureDiagnostic(root, cs, locator),
-        BaseType(baseType->getRValueType()), Name(memberName) {}
+        BaseType(baseType->getRValueType()), Member(member), Name(name) {
+    assert(member);
+  }
 
   bool diagnoseAsError() override;
 };
+
 class PartialApplicationFailure final : public FailureDiagnostic {
   enum RefKind : unsigned {
     MutatingMethod,
diff --git a/lib/Sema/CSFix.cpp b/lib/Sema/CSFix.cpp
@@ -284,17 +284,19 @@ DefineMemberBasedOnUse::create(ConstraintSystem &cs, Type baseType,
 }
 
 bool AllowTypeOrInstanceMember::diagnose(Expr *root, bool asNote) const {
-  auto failure = AllowTypeOrInstanceMemberFailure(root, getConstraintSystem(),
-                                                  BaseType, Name, getLocator());
+  auto failure = AllowTypeOrInstanceMemberFailure(
+      root, getConstraintSystem(), BaseType, Member, UsedName, getLocator());
   return failure.diagnose(asNote);
 }
 
-AllowTypeOrInstanceMember *AllowTypeOrInstanceMember::create(ConstraintSystem &cs,
-                                                             Type baseType,
-                                                             DeclName member,
-                                                             ConstraintLocator *locator) {
-  return new (cs.getAllocator()) AllowTypeOrInstanceMember(cs, baseType, member, locator);
+AllowTypeOrInstanceMember *
+AllowTypeOrInstanceMember::create(ConstraintSystem &cs, Type baseType,
+                                  ValueDecl *member, DeclName usedName,
+                                  ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      AllowTypeOrInstanceMember(cs, baseType, member, usedName, locator);
 }
+
 bool AllowInvalidPartialApplication::diagnose(Expr *root, bool asNote) const {
   auto failure = PartialApplicationFailure(root, isWarning(),
                                            getConstraintSystem(), getLocator());
diff --git a/lib/Sema/CSFix.h b/lib/Sema/CSFix.h
@@ -595,13 +595,17 @@ class DefineMemberBasedOnUse final : public ConstraintFix {
 	
 class AllowTypeOrInstanceMember final : public ConstraintFix {
   Type BaseType;
-  DeclName Name;
+  ValueDecl *Member;
+  DeclName UsedName;
 
 public:
-  AllowTypeOrInstanceMember(ConstraintSystem &cs, Type baseType, DeclName member,
+  AllowTypeOrInstanceMember(ConstraintSystem &cs, Type baseType,
+                            ValueDecl *member, DeclName name,
                             ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::AllowTypeOrInstanceMember, locator),
-        BaseType(baseType), Name(member) {}
+        BaseType(baseType), Member(member), UsedName(name) {
+    assert(member);
+  }
 
   std::string getName() const override {
     return "allow access to instance member on type or a type member on instance";
@@ -610,7 +614,7 @@ class AllowTypeOrInstanceMember final : public ConstraintFix {
   bool diagnose(Expr *root, bool asNote = false) const override;
 
   static AllowTypeOrInstanceMember *create(ConstraintSystem &cs, Type baseType,
-                                           DeclName member,
+                                           ValueDecl *member, DeclName usedName,
                                            ConstraintLocator *locator);
 };
 
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -4530,8 +4530,12 @@ fixMemberRef(ConstraintSystem &cs, Type baseTy,
   if (reason) {
     switch (*reason) {
     case MemberLookupResult::UR_InstanceMemberOnType:
-    case MemberLookupResult::UR_TypeMemberOnInstance:
-      return AllowTypeOrInstanceMember::create(cs, baseTy, memberName, locator);
+    case MemberLookupResult::UR_TypeMemberOnInstance: {
+      return choice.isDecl()
+                 ? AllowTypeOrInstanceMember::create(
+                       cs, baseTy, choice.getDecl(), memberName, locator)
+                 : nullptr;
+    }
 
     case MemberLookupResult::UR_Inaccessible:
       assert(choice.isDecl());
diff --git a/test/Constraints/members.swift b/test/Constraints/members.swift
@@ -609,3 +609,21 @@ func rdar50679161() {
     }
   }
 }
+
+
+func rdar_50467583_and_50909555() {
+  // rdar://problem/50467583
+  let _: Set = [Int][]
+  // expected-error@-1 {{instance member 'subscript' cannot be used on type '[Int]'}}
+
+  // rdar://problem/50909555
+  struct S {
+    static subscript(x: Int, y: Int) -> Int {
+      return 1
+    }
+  }
+
+  func test(_ s: S) {
+    s[1] // expected-error {{static member 'subscript' cannot be used on instance of type 'S'}} {{5-6=S}}
+  }
+}
