---

yaml
---
r: 326575
b: refs/heads/tensorflow
c: 253abad
h: refs/heads/master
i:
  326573: 4799d03
  326571: abb8130
  326567: 7c083d6
  326559: 08d38cb

Author: xedin

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 1ecd209e3b8c36766ec3f04805d42f298a7bb55b
+refs/heads/tensorflow: 253abad78995af39c42263894ed8f3617a2e41e9
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/lib/Sema/CSDiag.cpp

@@ -1636,15 +1636,6 @@ bool FailureDiagnosis::diagnoseCalleeResultContextualConversionError() {
   }
 }
 
-/// Return true if the conversion from fromType to toType is an invalid string
-/// index operation.
-static bool isIntegerToStringIndexConversion(Type fromType, Type toType,
-                                             ConstraintSystem &CS) {
-  auto kind = KnownProtocolKind::ExpressibleByIntegerLiteral;
-  return (conformsToKnownProtocol(CS, fromType, kind) &&
-          toType->getCanonicalType().getString() == "String.CharacterView.Index");
-}
-
 bool FailureDiagnosis::diagnoseContextualConversionError(
     Expr *expr, Type contextualType, ContextualTypePurpose CTP,
     Type suggestedType) {
@@ -1689,7 +1680,6 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
   // Try to find the contextual type in a variety of ways.  If the constraint
   // system had a contextual type specified, we use it - it will have a purpose
   // indicator which allows us to give a very "to the point" diagnostic.
-  Diag<Type, Type> diagID;
   Diag<Type> nilDiag;
   std::function<void(void)> nilFollowup;
 
@@ -1705,7 +1695,6 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
     llvm_unreachable("CTP_CalleeResult does not actually install a "
                      "contextual type");
   case CTP_Initialization:
-    diagID = diag::cannot_convert_initializer_value;
     nilDiag = diag::cannot_convert_initializer_value_nil;
     nilFollowup = [this] {
       TypeRepr *patternTR = CS.getContextualTypeLoc().getTypeRepr();
@@ -1730,7 +1719,6 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
       return true;
     }
 
-    diagID = diag::cannot_convert_to_return_type;
     nilDiag = diag::cannot_convert_to_return_type_nil;
     break;
   case CTP_ThrowStmt: {
@@ -1777,11 +1765,9 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
   }
 
   case CTP_EnumCaseRawValue:
-    diagID = diag::cannot_convert_raw_initializer_value;
     nilDiag = diag::cannot_convert_raw_initializer_value_nil;
     break;
   case CTP_DefaultParameter:
-    diagID = diag::cannot_convert_default_arg_value;
     nilDiag = diag::cannot_convert_default_arg_value_nil;
     break;
 
@@ -1800,39 +1786,30 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
     }
     return true;
   case CTP_YieldByValue:
-    diagID = diag::cannot_convert_yield_value;
     nilDiag = diag::cannot_convert_yield_value_nil;
     break;
   case CTP_CallArgument:
-    diagID = diag::cannot_convert_argument_value;
     nilDiag = diag::cannot_convert_argument_value_nil;
     break;
   case CTP_ClosureResult:
-    diagID = diag::cannot_convert_closure_result;
     nilDiag = diag::cannot_convert_closure_result_nil;
     break;
   case CTP_ArrayElement:
-    diagID = diag::cannot_convert_array_element;
     nilDiag = diag::cannot_convert_array_element_nil;
     break;
   case CTP_DictionaryKey:
-    diagID = diag::cannot_convert_dict_key;
     nilDiag = diag::cannot_convert_dict_key_nil;
     break;
   case CTP_DictionaryValue:
-    diagID = diag::cannot_convert_dict_value;
     nilDiag = diag::cannot_convert_dict_value_nil;
     break;
   case CTP_CoerceOperand:
-    diagID = diag::cannot_convert_coerce;
     nilDiag = diag::cannot_convert_coerce_nil;
     break;
   case CTP_AssignSource:
-    diagID = diag::cannot_convert_assign;
     nilDiag = diag::cannot_convert_assign_nil;
     break;
   case CTP_SubscriptAssignSource:
-    diagID = diag::cannot_convert_subscript_assign;
     nilDiag = diag::cannot_convert_subscript_assign_nil;
     break;
   }
@@ -1858,69 +1835,18 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
     return false;
   }
 
-  // If we're trying to convert something to Bool, check to see if it is for
-  // a known reason.
-  ContextualFailure failure(expr, CS, exprType, contextualType,
-                            CS.getConstraintLocator(expr));
-
-  if (failure.diagnoseMissingFunctionCall())
-    return true;
-
-  if (failure.diagnoseConversionToBool())
-    return true;
-
   exprType = exprType->getRValueType();
 
-  // Special case of some common conversions involving Swift.String
-  // indexes, catching cases where people attempt to index them with an integer.
-  if (isIntegerToStringIndexConversion(exprType, contextualType, CS)) {
-    diagnose(expr->getLoc(), diag::string_index_not_integer,
-             exprType->getRValueType())
-      .highlight(expr->getSourceRange());
-    diagnose(expr->getLoc(), diag::string_index_not_integer_note);
-    return true;
-  }
-
-  // When converting from T to [T] or UnsafePointer<T>, we can offer fixit to wrap
-  // the expr with brackets.
-  auto *genericType = contextualType->getAs<BoundGenericType>();
-  if (genericType) {
-    auto *contextDecl = genericType->getDecl();
-    if (contextDecl == CS.TC.Context.getArrayDecl()) {
-      for (Type arg : genericType->getGenericArgs()) {
-        if (arg->isEqual(exprType)) {
-          diagnose(expr->getLoc(), diagID, exprType, contextualType)
-              .fixItInsert(expr->getStartLoc(), "[")
-              .fixItInsert(Lexer::getLocForEndOfToken(CS.TC.Context.SourceMgr,
-                                                      expr->getEndLoc()),
-                           "]");
-          return true;
-        }
-      }
-    }
-  }
-
   // Don't attempt fixits if we have an unsolved type variable, since
   // the recovery path's recursion into the type checker via typeCheckCast()
   // will confuse matters.
   if (exprType->hasTypeVariable())
     return false;
 
-  // When complaining about conversion to a protocol type, complain about
-  // conformance instead of "conversion".
-  if (contextualType->isExistentialType()) {
-    MissingContextualConformanceFailure failure(
-        expr, CS, CTP, exprType, contextualType,
-        CS.getConstraintLocator(expr, LocatorPathElt::getContextualType()));
-    return failure.diagnoseAsError();
-  }
-
-  InFlightDiagnostic diag = diagnose(expr->getLoc(), diagID,
-                                     exprType, contextualType);
-  diag.highlight(expr->getSourceRange());
-
-  failure.tryFixIts(diag);
-  return true;
+  ContextualFailure failure(
+      expr, CS, CTP, exprType, contextualType,
+      CS.getConstraintLocator(expr, LocatorPathElt::getContextualType()));
+  return failure.diagnoseAsError();
 }
 
 //===----------------------------------------------------------------------===//

branches/tensorflow/lib/Sema/CSDiagnostics.cpp

@@ -1847,6 +1847,16 @@ bool ContextualFailure::diagnoseAsError() {
   if (diagnoseConversionToDictionary())
     return true;
 
+  // Special case of some common conversions involving Swift.String
+  // indexes, catching cases where people attempt to index them with an integer.
+  if (isIntegerToStringIndexConversion()) {
+    emitDiagnostic(anchor->getLoc(), diag::string_index_not_integer,
+                   getFromType())
+        .highlight(anchor->getSourceRange());
+    emitDiagnostic(anchor->getLoc(), diag::string_index_not_integer_note);
+    return true;
+  }
+
   Diag<Type, Type> diagnostic;
   switch (path.back().getKind()) {
   case ConstraintLocator::ClosureResult: {
@@ -1858,8 +1868,8 @@ bool ContextualFailure::diagnoseAsError() {
     if (diagnoseConversionToBool())
       return true;
 
-    if (auto msg = getDiagnosticFor(getContextualTypePurpose(),
-                                    /*forProtocol=*/false)) {
+    auto contextualType = getToType();
+    if (auto msg = getDiagnosticFor(CTP, contextualType->isExistentialType())) {
       diagnostic = *msg;
       break;
     }
@@ -2300,6 +2310,16 @@ void ContextualFailure::tryComputedPropertyFixIts(Expr *expr) const {
   }
 }
 
+bool ContextualFailure::isIntegerToStringIndexConversion() const {
+  auto &cs = getConstraintSystem();
+  auto kind = KnownProtocolKind::ExpressibleByIntegerLiteral;
+
+  auto fromType = getFromType();
+  auto toType = getToType()->getCanonicalType();
+  return (conformsToKnownProtocol(cs, fromType, kind) &&
+          toType.getString() == "String.CharacterView.Index");
+}
+
 Optional<Diag<Type, Type>>
 ContextualFailure::getDiagnosticFor(ContextualTypePurpose context,
                                     bool forProtocol) {

branches/tensorflow/lib/Sema/CSDiagnostics.h

@@ -661,13 +661,20 @@ class AssignmentFailure final : public FailureDiagnostic {
 /// Intended to diagnose any possible contextual failure
 /// e.g. argument/parameter, closure result, conversions etc.
 class ContextualFailure : public FailureDiagnostic {
+  ContextualTypePurpose CTP;
   Type FromType, ToType;
 
 public:
   ContextualFailure(Expr *root, ConstraintSystem &cs, Type lhs, Type rhs,
                     ConstraintLocator *locator)
-      : FailureDiagnostic(root, cs, locator), FromType(resolve(lhs)),
-        ToType(resolve(rhs)) {}
+      : ContextualFailure(root, cs, cs.getContextualTypePurpose(), lhs, rhs,
+                          locator) {}
+
+  ContextualFailure(Expr *root, ConstraintSystem &cs,
+                    ContextualTypePurpose purpose, Type lhs, Type rhs,
+                    ConstraintLocator *locator)
+      : FailureDiagnostic(root, cs, locator), CTP(purpose),
+        FromType(resolve(lhs)), ToType(resolve(rhs)) {}
 
   Type getFromType() const { return FromType; }
 
@@ -735,10 +742,7 @@ class ContextualFailure : public FailureDiagnostic {
                                             Type contextualType);
 
 private:
-  ContextualTypePurpose getContextualTypePurpose() const {
-    auto &cs = getConstraintSystem();
-    return cs.getContextualTypePurpose();
-  }
+  ContextualTypePurpose getContextualTypePurpose() const { return CTP; }
 
   Type resolve(Type rawType) {
     auto type = resolveType(rawType)->getWithoutSpecifierType();
@@ -759,6 +763,10 @@ class ContextualFailure : public FailureDiagnostic {
         KnownProtocolKind::ExpressibleByIntegerLiteral);
   }
 
+  /// Return true if the conversion from fromType to toType is
+  /// an invalid string index operation.
+  bool isIntegerToStringIndexConversion() const;
+
 protected:
   static Optional<Diag<Type, Type>>
   getDiagnosticFor(ContextualTypePurpose context, bool forProtocol);

branches/tensorflow/test/Constraints/diagnostics.swift

@@ -773,7 +773,7 @@ func testImplConversion(a : Float?) -> Bool {}
 func testImplConversion(a : Int?) -> Bool {
   let someInt = 42
   let a : Int = testImplConversion(someInt) // expected-error {{missing argument label 'a:' in call}} {{36-36=a: }}
-  // expected-error@-2 {{cannot convert value of type 'Bool' to specified type 'Int'}}
+  // expected-error@-1 {{cannot convert value of type 'Bool' to specified type 'Int'}}
 }
 
 // <rdar://problem/23752537> QoI: Bogus error message: Binary operator '&&' cannot be applied to two 'Bool' operands
@@ -1225,7 +1225,7 @@ func rdar43525641(_ a: Int, _ b: Int = 0, c: Int = 0, _ d: Int) {}
 rdar43525641(1, c: 2, 3) // Ok
 
 struct Array {}
-let foo: Swift.Array = Array() // expected-error {{cannot convert value of type 'diagnostics.Array' to specified type 'Swift.Array'}}
+let foo: Swift.Array = Array() // expected-error {{cannot convert value of type 'Array' to specified type 'Array<Any>'}}
 
 struct Error {}
 let bar: Swift.Error = Error() //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
@@ -1235,21 +1235,23 @@ let baz3: (Swift.Error) = (Error()) //expected-error {{value of type 'diagnostic
 let baz4: ((Swift.Error)) = (Error()) //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
 
 // SyntaxSugarTypes with unresolved types
+// TODO(diagnostics): It should be easy to improve messages here e.g. infer type of `Element` with a fix which would
+// add as many brackets as required by parameter type. It's a bit harder for dictionaries but should be doable.
 func takesGenericArray<T>(_ x: [T]) {}
 takesGenericArray(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Array<Element>'}}
 func takesNestedGenericArray<T>(_ x: [[T]]) {}
-takesNestedGenericArray(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Array<Array<_>>'}}
+takesNestedGenericArray(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Array<Element>'}}
 func takesSetOfGenericArrays<T>(_ x: Set<[T]>) {}
-takesSetOfGenericArrays(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Set<Array<_>>'}}
+takesSetOfGenericArrays(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Set<Element>'}}
 func takesArrayOfSetOfGenericArrays<T>(_ x: [Set<[T]>]) {}
-takesArrayOfSetOfGenericArrays(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Array<Set<Array<_>>>'}}
+takesArrayOfSetOfGenericArrays(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Array<Element>'}}
 func takesArrayOfGenericOptionals<T>(_ x: [T?]) {}
-takesArrayOfGenericOptionals(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Array<Optional<_>>'}}
+takesArrayOfGenericOptionals(1) // expected-error {{cannot convert value of type 'Int' to expected argument type 'Array<Element>'}}
 func takesGenericDictionary<T, U>(_ x: [T : U]) {}
-takesGenericDictionary(true) // expected-error {{cannot convert value of type 'Bool' to expected argument type 'Dictionary<_, _>'}}
+takesGenericDictionary(true) // expected-error {{cannot convert value of type 'Bool' to expected argument type 'Dictionary<Key, Value>'}}
 typealias Z = Int
 func takesGenericDictionaryWithTypealias<T>(_ x: [T : Z]) {}
-takesGenericDictionaryWithTypealias(true) // expected-error {{cannot convert value of type 'Bool' to expected argument type 'Dictionary<_, Z>'}}
+takesGenericDictionaryWithTypealias(true) // expected-error {{cannot convert value of type 'Bool' to expected argument type 'Dictionary<Key, Value>'}}
 func takesGenericFunction<T>(_ x: ([T]) -> Void) {}
 takesGenericFunction(true) // expected-error {{cannot convert value of type 'Bool' to expected argument type '(Array<_>) -> Void'}}
 func takesTuple<T>(_ x: ([T], [T])) {}

branches/tensorflow/test/TypeCoercion/overload_noncall.swift

@@ -4,9 +4,9 @@ struct X { }
 struct Y { }
 struct Z { }
 
-func f0(_ x1: X, x2: X) -> X {} // expected-note{{found this candidate}}
-func f0(_ y1: Y, y2: Y) -> Y {} // expected-note{{found this candidate}}
-var f0 : X // expected-note {{found this candidate}} expected-note {{'f0' previously declared here}}
+func f0(_ x1: X, x2: X) -> X {}
+func f0(_ y1: Y, y2: Y) -> Y {}
+var f0 : X // expected-note {{'f0' previously declared here}}
 func f0_init(_ x: X, y: Y) -> X {}
 var f0 : (_ x : X, _ y : Y) -> X = f0_init // expected-error{{invalid redeclaration}}
 func f1(_ x: X) -> X {}
@@ -16,7 +16,7 @@ func f2(_ g: (_ x: X) -> X) -> ((_ y: Y) -> Y) { }
 func test_conv() {
   var _ : (_ x1 : X, _ x2 : X) -> X = f0
   var _ : (X, X) -> X = f0
-  var _ : (Y, X) -> X = f0 // expected-error{{ambiguous reference to member 'f0(_:x2:)'}}
+  var _ : (Y, X) -> X = f0 // expected-error{{cannot convert value of type 'X' to specified type '(Y, X) -> X'}}
   var _ : (X) -> X = f1
   var a7 : (X) -> (X) = f1
   var a8 : (_ x2 : X) -> (X) = f1

branches/tensorflow/test/decl/protocol/req/recursion.swift

@@ -48,7 +48,7 @@ public struct S<A: P> where A.T == S<A> {
 // expected-error@-2 {{generic struct 'S' references itself}}
   func f(a: A.T) {
     g(a: id(t: a))
-    // expected-error@-1 {{cannot convert value of type 'A.T' to expected argument type 'S<_>'}}
+    // expected-error@-1 {{cannot convert value of type 'A.T' to expected argument type 'S<A>'}}
     _ = A.T.self
   }
 

branches/tensorflow/test/expr/closure/anonymous.swift

@@ -35,7 +35,7 @@ func variadic() {
   // expected-error@-1 {{cannot convert value of type '([Int]) -> ()' to specified type '(Int...) -> ()'}}
 
   takesVariadicGeneric({takesIntArray($0)})
-  // expected-error@-1 {{cannot convert value of type 'Array<_>' to expected argument type '[Int]'}}
+  // expected-error@-1 {{cannot convert value of type 'Array<Element>' to expected argument type '[Int]'}}
 
   takesVariadicGeneric({let _: [Int] = $0})
   // expected-error@-1 {{cannot convert value of type '(_) -> ()' to expected argument type '(_...) -> ()'}}