Add condition for optimizing series of binops that every possible overload is (T,T)->T, with no (T,T)->U

Author: gregomni

lib/Sema/CSGen.cpp

@@ -46,6 +46,26 @@ static bool isArithmeticOperatorDecl(ValueDecl *vd) {
    vd->getBaseName() == "%");
 }
 
+static bool hasBinOpOverloadWithSameArgTypesDifferingResult(
+    OverloadedDeclRefExpr *overloads) {
+  for (auto decl : overloads->getDecls()) {
+    auto metaFuncType = decl->getInterfaceType()->getAs<AnyFunctionType>();
+    auto funcType = metaFuncType->getResult()->getAs<FunctionType>();
+    if (!funcType)
+      continue;
+
+    auto params = funcType->getParams();
+    if (params.size() != 2)
+      continue;
+
+    if (params[0].getPlainType().getPointer() != params[1].getPlainType().getPointer())
+      continue;
+    if (funcType->getResult().getPointer() != params[0].getPlainType().getPointer())
+      return true;
+  }
+  return false;
+}
+
 static bool mergeRepresentativeEquivalenceClasses(ConstraintSystem &CS,
                                                   TypeVariableType* tyvar1,
                                                   TypeVariableType* tyvar2) {
@@ -340,6 +360,9 @@ namespace {
                 ODR2->getDecls()[0]->getBaseName())
               return;
 
+            if (hasBinOpOverloadWithSameArgTypesDifferingResult(ODR1))
+              return;
+
             // All things equal, we can merge the tyvars for the function
             // types.
             auto rep1 = CS.getRepresentative(fnTy1);

test/Constraints/sr10324.swift

@@ -0,0 +1,19 @@
+// RUN: %target-swift-frontend -typecheck -verify %s
+
+struct A {
+    static func * (lhs: A, rhs: A) -> B { return B() }
+    static func * (lhs: B, rhs: A) -> B { return B() }
+    static func * (lhs: A, rhs: B) -> B { return B() }
+}
+struct B {}
+
+let (x, y, z) = (A(), A(), A())
+
+let w = A() * A() * A()     // works
+
+// Should all work
+let a = x * y * z
+let b = x * (y * z)
+let c = (x * y) * z
+let d = x * (y * z as B)
+let e = (x * y as B) * z