---

yaml
---
r: 349448
b: refs/heads/master-next
c: e2b9754
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 3869e829fa4d1762a0b4f24b9ce456eb7ed9e8bc
+refs/heads/master-next: e2b9754e5a3086e33fc4c6235afea7fc26740167
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/lib/Sema/CSDiag.cpp

@@ -1677,73 +1677,29 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
     return failure.diagnose();
   }
 
-  // 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> nilDiag;
-  std::function<void(void)> nilFollowup;
+  // If we don't have a type for the expression, then we cannot use it in
+  // conversion constraint diagnostic generation.  If the types match, then it
+  // must not be the contextual type that is the problem.
+  if (isUnresolvedOrTypeVarType(exprType) || exprType->isEqual(contextualType))
+    return false;
 
   // If this is conversion failure due to a return statement with an argument
   // that cannot be coerced to the result type of the function, emit a
   // specific error.
-  switch (CTP) {
-  case CTP_Unused:
-  case CTP_CannotFail:
-    llvm_unreachable("These contextual type purposes cannot fail with a "
-                     "conversion type specified!");
-  case CTP_CalleeResult:
-    llvm_unreachable("CTP_CalleeResult does not actually install a "
-                     "contextual type");
-  case CTP_Initialization:
-    nilDiag = diag::cannot_convert_initializer_value_nil;
-    nilFollowup = [this] {
-      TypeRepr *patternTR = CS.getContextualTypeLoc().getTypeRepr();
-      if (!patternTR)
-        return;
-      auto diag = diagnose(patternTR->getLoc(), diag::note_make_optional,
-                           OptionalType::get(CS.getContextualType()));
-      if (patternTR->isSimple()) {
-        diag.fixItInsertAfter(patternTR->getEndLoc(), "?");
-      } else {
-        diag.fixItInsert(patternTR->getStartLoc(), "(");
-        diag.fixItInsertAfter(patternTR->getEndLoc(), ")?");
-      }
-    };
-    break;
-  case CTP_ReturnSingleExpr:
-  case CTP_ReturnStmt:
-    // Special case the "conversion to void" case.
-    if (contextualType->isVoid()) {
-      diagnose(expr->getLoc(), diag::cannot_return_value_from_void_func)
-        .highlight(expr->getSourceRange());
-      return true;
-    }
-
-    nilDiag = diag::cannot_convert_to_return_type_nil;
-    break;
-  case CTP_ThrowStmt: {
-    if (isa<NilLiteralExpr>(expr->getValueProvidingExpr())) {
-      diagnose(expr->getLoc(), diag::cannot_throw_nil);
-      return true;
-    }
-
-    if (isUnresolvedOrTypeVarType(exprType) ||
-        exprType->isEqual(contextualType))
-      return false;
-
+  if (CTP == CTP_ThrowStmt) {
     // If we tried to throw the error code of an error type, suggest object
     // construction.
     auto &TC = CS.getTypeChecker();
     if (auto errorCodeProtocol =
             TC.Context.getProtocol(KnownProtocolKind::ErrorCodeProtocol)) {
-      if (auto conformance =
-            TypeChecker::conformsToProtocol(CS.getType(expr), errorCodeProtocol, CS.DC,
-                                            ConformanceCheckFlags::InExpression)) {
+      if (auto conformance = TypeChecker::conformsToProtocol(
+              CS.getType(expr), errorCodeProtocol, CS.DC,
+              ConformanceCheckFlags::InExpression)) {
         Type errorCodeType = CS.getType(expr);
         Type errorType =
-          conformance->getTypeWitnessByName(errorCodeType,
-                                            TC.Context.Id_ErrorType)
-            ->getCanonicalType();
+            conformance
+                ->getTypeWitnessByName(errorCodeType, TC.Context.Id_ErrorType)
+                ->getCanonicalType();
         if (errorType) {
           auto diag = diagnose(expr->getLoc(), diag::cannot_throw_error_code,
                                errorCodeType, errorType);
@@ -1760,18 +1716,11 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
     // if this ever expands, this should be a specific form like () is for
     // return.
     diagnose(expr->getLoc(), diag::cannot_convert_thrown_type, exprType)
-      .highlight(expr->getSourceRange());
+        .highlight(expr->getSourceRange());
     return true;
   }
 
-  case CTP_EnumCaseRawValue:
-    nilDiag = diag::cannot_convert_raw_initializer_value_nil;
-    break;
-  case CTP_DefaultParameter:
-    nilDiag = diag::cannot_convert_default_arg_value_nil;
-    break;
-
-  case CTP_YieldByReference:
+  if (CTP == CTP_YieldByReference) {
     if (auto contextualLV = contextualType->getAs<LValueType>())
       contextualType = contextualLV->getObjectType();
     if (auto exprLV = exprType->getAs<LValueType>()) {
@@ -1781,58 +1730,10 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
       diagnose(expr->getLoc(), diag::cannot_yield_rvalue_by_reference_same_type,
                exprType);
     } else {
-      diagnose(expr->getLoc(), diag::cannot_yield_rvalue_by_reference,
-               exprType, contextualType);
+      diagnose(expr->getLoc(), diag::cannot_yield_rvalue_by_reference, exprType,
+               contextualType);
     }
     return true;
-  case CTP_YieldByValue:
-    nilDiag = diag::cannot_convert_yield_value_nil;
-    break;
-  case CTP_CallArgument:
-    nilDiag = diag::cannot_convert_argument_value_nil;
-    break;
-  case CTP_ClosureResult:
-    nilDiag = diag::cannot_convert_closure_result_nil;
-    break;
-  case CTP_ArrayElement:
-    nilDiag = diag::cannot_convert_array_element_nil;
-    break;
-  case CTP_DictionaryKey:
-    nilDiag = diag::cannot_convert_dict_key_nil;
-    break;
-  case CTP_DictionaryValue:
-    nilDiag = diag::cannot_convert_dict_value_nil;
-    break;
-  case CTP_CoerceOperand:
-    nilDiag = diag::cannot_convert_coerce_nil;
-    break;
-  case CTP_AssignSource:
-    nilDiag = diag::cannot_convert_assign_nil;
-    break;
-  case CTP_SubscriptAssignSource:
-    nilDiag = diag::cannot_convert_subscript_assign_nil;
-    break;
-  }
-
-  // If we're diagnostic an issue with 'nil', produce a specific diagnostic,
-  // instead of uttering ExpressibleByNilLiteral.
-  if (isa<NilLiteralExpr>(expr->getValueProvidingExpr())) {
-    // If the source type is some kind of optional, the contextual conversion
-    // to 'nil' didn't fail, something else did.
-    if (contextualType->getOptionalObjectType())
-      return false;
-    diagnose(expr->getLoc(), nilDiag, contextualType);
-    if (nilFollowup)
-      nilFollowup();
-    return true;
-  }
-  
-  // If we don't have a type for the expression, then we cannot use it in
-  // conversion constraint diagnostic generation.  If the types match, then it
-  // must not be the contextual type that is the problem.
-  if (isUnresolvedOrTypeVarType(exprType) ||
-      exprType->isEqual(contextualType)) {
-    return false;
   }
 
   exprType = exprType->getRValueType();

branches/master-next/lib/Sema/CSDiagnostics.cpp

@@ -1841,6 +1841,18 @@ bool ContextualFailure::diagnoseAsError() {
   auto *anchor = getAnchor();
   auto path = getLocator()->getPath();
 
+  if (CTP == CTP_ReturnSingleExpr || CTP == CTP_ReturnStmt) {
+    // Special case the "conversion to void".
+    if (getToType()->isVoid()) {
+      emitDiagnostic(anchor->getLoc(), diag::cannot_return_value_from_void_func)
+          .highlight(anchor->getSourceRange());
+      return true;
+    }
+  }
+
+  if (diagnoseConversionToNil())
+    return true;
+
   assert(!path.empty());
 
   if (diagnoseMissingFunctionCall())
@@ -1889,6 +1901,159 @@ bool ContextualFailure::diagnoseAsError() {
   return true;
 }
 
+static Optional<Diag<Type>>
+getContextualNilDiagnostic(ContextualTypePurpose CTP) {
+  switch (CTP) {
+  case CTP_Unused:
+  case CTP_CannotFail:
+    llvm_unreachable("These contextual type purposes cannot fail with a "
+                     "conversion type specified!");
+  case CTP_CalleeResult:
+    llvm_unreachable("CTP_CalleeResult does not actually install a "
+                     "contextual type");
+  case CTP_Initialization:
+    return diag::cannot_convert_initializer_value_nil;
+
+  case CTP_ReturnSingleExpr:
+  case CTP_ReturnStmt:
+    return diag::cannot_convert_to_return_type_nil;
+
+  case CTP_ThrowStmt:
+  case CTP_YieldByReference:
+    return None;
+
+  case CTP_EnumCaseRawValue:
+    return diag::cannot_convert_raw_initializer_value_nil;
+  case CTP_DefaultParameter:
+    return diag::cannot_convert_default_arg_value_nil;
+  case CTP_YieldByValue:
+    return diag::cannot_convert_yield_value_nil;
+  case CTP_CallArgument:
+    return diag::cannot_convert_argument_value_nil;
+  case CTP_ClosureResult:
+    return diag::cannot_convert_closure_result_nil;
+  case CTP_ArrayElement:
+    return diag::cannot_convert_array_element_nil;
+  case CTP_DictionaryKey:
+    return diag::cannot_convert_dict_key_nil;
+  case CTP_DictionaryValue:
+    return diag::cannot_convert_dict_value_nil;
+  case CTP_CoerceOperand:
+    return diag::cannot_convert_coerce_nil;
+  case CTP_AssignSource:
+    return diag::cannot_convert_assign_nil;
+  case CTP_SubscriptAssignSource:
+    return diag::cannot_convert_subscript_assign_nil;
+  }
+}
+
+bool ContextualFailure::diagnoseConversionToNil() const {
+  auto *anchor = getAnchor();
+
+  if (!isa<NilLiteralExpr>(anchor))
+    return false;
+
+  auto &cs = getConstraintSystem();
+  auto *locator = getLocator();
+
+  Optional<ContextualTypePurpose> CTP;
+  // Easy case were failure has been identified as contextual already.
+  if (locator->isLastElement(ConstraintLocator::ContextualType)) {
+    CTP = getContextualTypePurpose();
+  } else {
+    // Here we need to figure out where where `nil` is located.
+    // It could be e.g. an argument to a subscript/call, assignment
+    // source like `s[0] = nil` or an array element like `[nil]` or
+    // `[nil: 42]` as a sub-expression to a larger one.
+    auto *parentExpr = findParentExpr(anchor);
+
+    // Looks like it's something similar to `let _ = nil`.
+    if (!parentExpr) {
+      emitDiagnostic(anchor->getLoc(), diag::unresolved_nil_literal);
+      return true;
+    }
+
+    // Two choices here - whether it's a regular assignment
+    // e.g. `let _: S = nil` or a subscript one e.g. `s[0] = nil`.
+    if (auto *AE = dyn_cast<AssignExpr>(parentExpr)) {
+      CTP = isa<SubscriptExpr>(AE->getDest()) ? CTP_SubscriptAssignSource
+                                              : CTP_AssignSource;
+    } else if (isa<ArrayExpr>(parentExpr)) {
+      CTP = CTP_ArrayElement;
+    } else if (isa<ClosureExpr>(parentExpr)) {
+      CTP = CTP_ClosureResult;
+    } else if (isa<ParenExpr>(parentExpr) || isa<TupleExpr>(parentExpr)) {
+      auto *enclosingExpr = findParentExpr(parentExpr);
+
+      if (!enclosingExpr) {
+        // If there is no enclosing expression it's something like
+        // `(nil)` or `(a: nil)` which can't be inferred without a
+        // contextual type.
+        emitDiagnostic(anchor->getLoc(), diag::unresolved_nil_literal);
+        return true;
+      }
+
+      if (auto *TE = dyn_cast<TupleExpr>(parentExpr)) {
+        // In case of dictionary e.g. `[42: nil]` we need to figure
+        // out whether nil is a "key" or a "value".
+        if (auto *DE = dyn_cast<DictionaryExpr>(enclosingExpr)) {
+          assert(TE->getNumElements() == 2);
+          CTP = TE->getElement(0) == anchor ? CTP_DictionaryKey
+                                            : CTP_DictionaryValue;
+        } else {
+          // Can't initialize one of the tuple elements with `nil`.
+          CTP = CTP_Initialization;
+        }
+      }
+
+      // `nil` is passed as an argument to a parameter which doesn't
+      // expect it e.g. `foo(a: nil)` or `s[x: nil]`.
+      if (isa<ApplyExpr>(enclosingExpr) || isa<SubscriptExpr>(enclosingExpr))
+        CTP = CTP_CallArgument;
+    } else if (auto *CE = dyn_cast<CoerceExpr>(parentExpr)) {
+      // `nil` is passed as a left-hand side of the coercion
+      // operator e.g. `nil as Foo`
+      CTP = CTP_CoerceOperand;
+    } else {
+      // Otherwise let's produce a generic `nil` conversion diagnostic.
+      emitDiagnostic(anchor->getLoc(), diag::cannot_use_nil_with_this_type,
+                     getToType());
+      return true;
+    }
+  }
+
+  if (!CTP)
+    return false;
+
+  if (CTP == CTP_ThrowStmt) {
+    emitDiagnostic(anchor->getLoc(), diag::cannot_throw_nil);
+    return true;
+  }
+
+  auto diagnostic = getContextualNilDiagnostic(*CTP);
+  if (!diagnostic)
+    return false;
+
+  emitDiagnostic(anchor->getLoc(), *diagnostic, getToType());
+
+  if (CTP == CTP_Initialization) {
+    auto *patternTR = cs.getContextualTypeLoc().getTypeRepr();
+    if (!patternTR)
+      return true;
+
+    auto diag = emitDiagnostic(patternTR->getLoc(), diag::note_make_optional,
+                               OptionalType::get(getToType()));
+    if (patternTR->isSimple()) {
+      diag.fixItInsertAfter(patternTR->getEndLoc(), "?");
+    } else {
+      diag.fixItInsert(patternTR->getStartLoc(), "(");
+      diag.fixItInsertAfter(patternTR->getEndLoc(), ")?");
+    }
+  }
+
+  return true;
+}
+
 void ContextualFailure::tryFixIts(InFlightDiagnostic &diagnostic) const {
   if (trySequenceSubsequenceFixIts(diagnostic))
     return;

branches/master-next/lib/Sema/CSDiagnostics.h

@@ -615,6 +615,9 @@ class ContextualFailure : public FailureDiagnostic {
 
   bool diagnoseAsError() override;
 
+  /// If we're trying to convert something to `nil`.
+  bool diagnoseConversionToNil() const;
+
   // If we're trying to convert something of type "() -> T" to T,
   // then we probably meant to call the value.
   bool diagnoseMissingFunctionCall() const;