Revert "Don't diagnose failures to call symmetrically-typed binary operators"

This reverts commit 35ba809.

Author: tkremenek

include/swift/AST/DiagnosticsSema.def

@@ -138,11 +138,6 @@ ERROR(cannot_match_expr_pattern_with_value,none,
       "expression pattern of type %0 cannot match values of type %1",
       (Type, Type))
 
-ERROR(cannot_reference_compare_types,none,
-      "cannot check reference equality of functions; operands here have types "
-      "%1 and %2",
-      (StringRef, Type, Type))
-
 ERROR(cannot_apply_binop_to_args,none,
       "binary operator '%0' cannot be applied to operands of type "
       "%1 and %2",

lib/Sema/CSDiag.cpp

@@ -1806,8 +1806,8 @@ class FailureDiagnosis :public ASTVisitor<FailureDiagnosis, /*exprresult*/bool>{
 
   /// Diagnose common failures due to applications of an argument list to an
   /// ApplyExpr or SubscriptExpr.
-  bool diagnoseParameterErrors(CalleeCandidateInfo &CCI,
-                               Expr *fnExpr, Expr *argExpr);
+  bool diagnoseParameterErrors(CalleeCandidateInfo &CCI, Expr *fnExpr,
+                               Expr *argExpr);
 
   /// Attempt to diagnose a specific failure from the info we've collected from
   /// the failed constraint system.
@@ -2904,12 +2904,6 @@ typeCheckChildIndependently(Expr *subExpr, Type convertType,
       TCEOptions |= TypeCheckExprFlags::PreferForceUnwrapToOptional;
   }
 
-  // Ensure that the expression we're about to type-check doesn't have
-  // anything that the type-checker doesn't expect to see.  This can happen
-  // because of repeated type-checking; the removal below, while independently
-  // important, isn't itself sufficient because of AST mutation.
-  eraseOpenedExistentials(subExpr);
-
   bool hadError = CS->TC.typeCheckExpression(subExpr, CS->DC,
                                              TypeLoc::withoutLoc(convertType),
                                              convertTypePurpose, TCEOptions,
@@ -3340,28 +3334,6 @@ void ConstraintSystem::diagnoseAssignmentFailure(Expr *dest, Type destTy,
                             diag::assignment_lhs_not_lvalue);
 }
 
-static bool isSymmetricBinaryOperator(const CalleeCandidateInfo &CCI) {
-  // If we don't have at least one known candidate, don't trigger.
-  if (CCI.candidates.empty()) return false;
-
-  for (auto &candidate : CCI.candidates) {
-    // Each candidate must be a non-assignment operator function.
-    auto decl = dyn_cast_or_null<FuncDecl>(candidate.getDecl());
-    if (!decl) return false;
-    auto op = dyn_cast_or_null<InfixOperatorDecl>(decl->getOperatorDecl());
-    if (!op || op->isAssignment()) return false;
-
-    // It must have exactly two parameters.
-    auto params = decl->getParameterLists().back();
-    if (params->size() != 2) return false;
-
-    // Require the types to be the same.
-    if (!params->get(0)->getType()->isEqual(params->get(1)->getType()))
-      return false;
-  }
-
-  return true;
-}
 
 /// Special magic to handle inout exprs and tuples in argument lists.
 Expr *FailureDiagnosis::
@@ -3392,11 +3364,6 @@ typeCheckArgumentChildIndependently(Expr *argExpr, Type argType,
       if (decl->isInstanceMember() && candidates[0].level == 0 &&
           !isa<SubscriptDecl>(decl))
         argType = Type();
-
-  // Similarly, we get better results when we don't push argument types down
-  // to symmetric operators.
-  if (argType && isSymmetricBinaryOperator(candidates))
-    argType = Type();
 
 
   // FIXME: This should all just be a matter of getting the type of the
@@ -3768,17 +3735,12 @@ bool FailureDiagnosis::diagnoseParameterErrors(CalleeCandidateInfo &CCI,
   // (often because there is only one candidate in the set), then diagnose this
   // as a specific problem of passing something of the wrong type into a
   // parameter.
-  //
-  // We don't generally want to use this path to diagnose calls to
-  // symmetrically-typed binary operators because it's likely that both
-  // operands contributed to the type.
   if ((CCI.closeness == CC_OneArgumentMismatch ||
        CCI.closeness == CC_OneArgumentNearMismatch ||
        CCI.closeness == CC_OneGenericArgumentMismatch ||
        CCI.closeness == CC_OneGenericArgumentNearMismatch ||
        CCI.closeness == CC_GenericNonsubstitutableMismatch) &&
-      CCI.failedArgument.isValid() &&
-      !isSymmetricBinaryOperator(CCI)) {
+      CCI.failedArgument.isValid()) {
     // Map the argument number into an argument expression.
     TCCOptions options = TCC_ForceRecheck;
     if (CCI.failedArgument.parameterType->is<InOutType>())
@@ -4199,18 +4161,6 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
         .highlight(rhsExpr->getSourceRange());
       return true;
     }
-
-    // Diagnose attempts to compare reference equality of certain types.
-    if (overloadName == "===" || overloadName == "!==") {
-      // Functions.
-      if (lhsType->is<AnyFunctionType>() || rhsType->is<AnyFunctionType>()) {
-        diagnose(callExpr->getLoc(), diag::cannot_reference_compare_types,
-                 overloadName, lhsType, rhsType)
-          .highlight(lhsExpr->getSourceRange())
-          .highlight(rhsExpr->getSourceRange());
-        return true;
-      }
-    }
 
     // If we found an exact match, this must be a problem with a conversion from
     // the result of the call to the expected type.  Diagnose this as a

test/1_stdlib/UnicodeScalarDiagnostics.swift

@@ -23,12 +23,12 @@ func test_UnicodeScalarDoesNotImplementArithmetic(_ us: UnicodeScalar, i: Int) {
 
   let c1 = us + i // expected-error {{binary operator '+' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{overloads for '+' exist with these partially matching parameter lists:}}
   let c2 = us - i // expected-error {{binary operator '-' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{overloads for '-' exist with these partially matching parameter lists:}}
-  let c3 = us * i // expected-error {{binary operator '*' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note {{expected an argument list of type '(Int, Int)'}}
-  let c4 = us / i // expected-error {{binary operator '/' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note {{expected an argument list of type '(Int, Int)'}}
+  let c3 = us * i // expected-error {{cannot convert value of type 'UnicodeScalar' to expected argument type 'Int'}}
+  let c4 = us / i // expected-error {{cannot convert value of type 'UnicodeScalar' to expected argument type 'Int'}}
 
   let d1 = i + us // expected-error {{binary operator '+' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{overloads for '+' exist with these partially matching parameter lists:}}
-  let d2 = i - us // expected-error {{binary operator '-' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note {{expected an argument list of type '(Int, Int)'}}
-  let d3 = i * us // expected-error {{binary operator '*' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note {{expected an argument list of type '(Int, Int)'}}
-  let d4 = i / us // expected-error {{binary operator '/' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note {{expected an argument list of type '(Int, Int)'}}
+  let d2 = i - us // expected-error {{cannot convert value of type 'UnicodeScalar' to expected argument type 'Int'}}
+  let d3 = i * us // expected-error {{cannot convert value of type 'UnicodeScalar' to expected argument type 'Int'}}
+  let d4 = i / us // expected-error {{cannot convert value of type 'UnicodeScalar' to expected argument type 'Int'}}
 }
 

test/Constraints/bridging.swift

@@ -205,7 +205,7 @@ let d2: Double = 3.14159
 inferDouble2 = d2
 
 // rdar://problem/18269449
-var i1: Int = 1.5 * 3.5 // expected-error {{binary operator '*' cannot be applied to two 'Double' operands}} expected-note {{expected an argument list of type '(Int, Int)'}}
+var i1: Int = 1.5 * 3.5 // expected-error{{cannot convert value of type 'Double' to expected argument type 'Int'}}
 
 // rdar://problem/18330319
 func rdar18330319(_ s: String, d: [String : AnyObject]) {
@@ -266,12 +266,12 @@ func rdar19831919() {
 // <rdar://problem/19831698> Incorrect 'as' fixits offered for invalid literal expressions
 func rdar19831698() {
   var v70 = true + 1 // expected-error{{binary operator '+' cannot be applied to operands of type 'Bool' and 'Int'}} expected-note {{overloads for '+' exist with these partially matching parameter lists: (Int, Int), (UnsafeMutablePointer<Pointee>, Int), (UnsafePointer<Pointee>, Int)}}
-  var v71 = true + 1.0 // expected-error {{binary operator '+' cannot be applied to operands of type 'Bool' and 'Double'}} expected-note {{expected an argument list of type '(Double, Double)'}}
+  var v71 = true + 1.0 // expected-error{{cannot convert value of type 'Bool' to expected argument type 'Double'}}
   var v72 = true + true // expected-error{{binary operator '+' cannot be applied to two 'Bool' operands}}
   // expected-note @-1 {{overloads for '+' exist with these partially matching parameter lists:}}
   var v73 = true + [] // expected-error{{binary operator '+' cannot be applied to operands of type 'Bool' and '[_]'}}
   // expected-note @-1 {{overloads for '+' exist with these partially matching parameter lists:}}
-  var v75 = true + "str" // expected-error {{binary operator '+' cannot be applied to operands of type 'Bool' and 'String'}} expected-note {{expected an argument list of type '(String, String)'}}
+  var v75 = true + "str" // expected-error{{cannot convert value of type 'Bool' to expected argument type 'String'}}
 }
 
 // <rdar://problem/19836341> Incorrect fixit for NSString? to String? conversions

test/Constraints/diagnostics.swift

@@ -583,7 +583,7 @@ func r21684487() {
   var closures = Array<MyClosure>()
   let testClosure = {(list: [Int]) -> Bool in return true}
 
-  let closureIndex = closures.index{$0 === testClosure} // expected-error {{cannot check reference equality of functions; operands here have types '_' and '([Int]) -> Bool'}}
+  let closureIndex = closures.index{$0 === testClosure} // expected-error {{cannot convert value of type '([Int]) -> Bool' to expected argument type 'AnyObject?'}}
 }
 
 // <rdar://problem/18397777> QoI: special case comparisons with nil
@@ -749,8 +749,8 @@ if AssocTest.one(1) == AssocTest.one(1) {} // expected-error{{binary operator '=
 func r24251022() {
   var a = 1
   var b: UInt32 = 2
-  a += a + // expected-error {{binary operator '+' cannot be applied to operands of type 'Int' and 'UInt32'}} expected-note {{expected an argument list of type '(Int, Int)'}}
-    b
+  a += a +
+    b // expected-error {{cannot convert value of type 'UInt32' to expected argument type 'Int'}}
 }
 
 func overloadSetResultType(_ a : Int, b : Int) -> Int {

test/Constraints/patterns.swift

@@ -140,7 +140,7 @@ default: break
 
 // <rdar://problem/21995744> QoI: Binary operator '~=' cannot be applied to operands of type 'String' and 'String?'
 switch ("foo" as String?) {
-case "what": break // expected-error{{expression pattern of type 'String' cannot match values of type 'String?'}}
+case "what": break // expected-error{{value of optional type 'String?' not unwrapped; did you mean to use '!' or '?'?}}
 default: break
 }
 

test/Misc/misc_diagnostics.swift

@@ -13,7 +13,7 @@ if let realRoomName = roomName as! NSString { // expected-error {{initializer fo
 
 var pi = 3.14159265358979
 var d: CGFloat = 2.0
-var dpi:CGFloat = d*pi // expected-error{{binary operator '*' cannot be applied to operands of type 'CGFloat' and 'Double'}} // expected-note{{expected an argument list of type '(CGFloat, CGFloat)'}}
+var dpi:CGFloat = d*pi // expected-error{{cannot convert value of type 'Double' to expected argument type 'CGFloat'}}
 
 let ff: CGFloat = floorf(20.0) // expected-error{{cannot convert value of type 'Float' to specified type 'CGFloat'}}
 
@@ -30,7 +30,7 @@ var b: Int = [1, 2, 3] // expected-error{{contextual type 'Int' cannot be used w
 var f1: Float = 2.0
 var f2: Float = 3.0
 
-var dd: Double = f1 - f2 // expected-error{{binary operator '-' cannot be applied to two 'Float' operands}} // expected-note{{expected an argument list of type '(Double, Double)'}}
+var dd: Double = f1 - f2 // expected-error{{cannot convert value of type 'Float' to expected argument type 'Double'}}
 
 func f() -> Bool {
   return 1 + 1 // expected-error{{no '+' candidates produce the expected contextual result type 'Bool'}}
@@ -60,7 +60,7 @@ func retV() { return true } // expected-error {{unexpected non-void return value
 func retAI() -> Int {
     let a = [""]
     let b = [""]
-    return (a + b) // expected-error{{binary operator '+' cannot be applied to two '[String]' operands}} // expected-note{{expected an argument list of type '(Int, Int)'}}
+    return (a + b) // expected-error {{cannot convert value of type '[String]' to expected argument type 'Int'}}
 }
 
 func bad_return1() {
@@ -81,7 +81,7 @@ class MyBadReturnClass {
 }
 
 func ==(lhs:MyBadReturnClass, rhs:MyBadReturnClass) {
-  return MyBadReturnClass.intProperty == MyBadReturnClass.intProperty  // expected-error{{binary operator '==' cannot be applied to two 'Int' operands}} // expected-note{{expected an argument list of type '(MyBadReturnClass, MyBadReturnClass)'}}
+  return MyBadReturnClass.intProperty == MyBadReturnClass.intProperty  // expected-error {{cannot convert value of type 'Int' to expected argument type 'MyBadReturnClass'}}
 }
 
 

test/NameBinding/multi-file-with-main.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend -parse -enable-source-import -primary-file %s %S/Inputs/multi-file-with-main/main.swift -module-name=MultiFile -sdk "" -verify
 
 func testOperator() {
-  let x: Int = 1 +++ "abc" // expected-error {{binary operator '+++' cannot be applied to operands of type 'Int' and 'String'}} expected-note {{expected an argument list of type '(Int, Int)'}}
+  let x: Int = 1 +++ "abc" // expected-error {{cannot convert value of type 'String' to expected argument type 'Int'}}
 
   _ = x
 }

test/Parse/recovery.swift

@@ -616,7 +616,7 @@ protocol B23086402 {
 
 // <rdar://problem/23550816> QoI: Poor diagnostic in argument list of "print" (varargs related)
 func test23086402(a: A23086402) {
-  print(a.b.c + "")  // expected-error {{binary operator '+' cannot be applied to operands of type '[String]' and 'String'}} expected-note {{expected an argument list of type '(String, String)'}}
+  print(a.b.c + "")  // expected-error {{cannot convert value of type '[String]' to expected argument type 'String'}}
 }
 
 // <rdar://problem/23719432> [practicalswift] Compiler crashes on &(Int:_)

test/expr/closure/closures.swift

@@ -14,7 +14,7 @@ var closure3a : () -> () -> (Int,Int) = {{ (4, 2) }} // multi-level closing.
 var closure3b : (Int,Int) -> (Int) -> (Int,Int) = {{ (4, 2) }} // expected-error{{contextual type for closure argument list expects 2 arguments, which cannot be implicitly ignored}}  {{52-52=_,_ in }}
 var closure4 : (Int,Int) -> Int = { $0 + $1 }
 var closure5 : (Double) -> Int = {
-       $0 + 1.0 // expected-error {{binary operator '+' cannot be applied to two 'Double' operands}} expected-note {{expected an argument list of type '(Int, Int)'}}
+       $0 + 1.0  // expected-error {{cannot convert value of type 'Double' to expected argument type 'Int'}}
 }
 
 var closure6 = $0  // expected-error {{anonymous closure argument not contained in a closure}}
@@ -33,7 +33,7 @@ func funcdecl5(_ a: Int, _ y: Int) {
 
   func6(fn: {$0 + $1})       // Closure with two named anonymous arguments
   func6(fn: {($0) + $1})    // Closure with sequence expr inferred type
-  func6(fn: {($0) + $0})    // // expected-error {{binary operator '+' cannot be applied to two '(Int, Int)' operands}} expected-note {{expected an argument list of type '(Int, Int)'}}
+  func6(fn: {($0) + $0})    // expected-error{{cannot convert value of type '(Int, Int)' to expected argument type 'Int'}}
 
 
   var testfunc : ((), Int) -> Int