C++11: Reject string literal to non-const char * conversion

[ismailp]

Summary

Conversion of string literals to non-const char* is deprecated in C++03, and is ill-formed in C++11.

This patch also fixes PR16314.

[rsmith]

Is there any way we can continue to accept this as an extension in C++11 mode (at least in easy cases, outside of SFINAE contexts)? I'm concerned that this may break a lot of existing code.

unittests/ASTMatchers/ASTMatchersTest.cpp

2611–2612

Can you change this to take const char* instead?

[ismailp]

We decided to limit this patch to overload resolution, addressing only PR16314.

When comparing candidate functions, this conversion is considered worse than other conversions to prevent the candidate function to be the best. If this conversion happens in the best viable function, we will accept it with a warning (current behavior).

[ismailp]

Compared to the previous revision, this revision issues a new ExtWarn instead of the existing Warning.

[rsmith]

include/clang/Basic/DiagnosticSemaKinds.td

4526–4527

We spell these as ext_deprecrated_... (drop the warn_).

lib/Sema/SemaExprCXX.cpp

3067–3070

You need to issue an Error here, not just an ExtWarn, if we're in a SFINAE context.

lib/Sema/SemaOverload.cpp

1187–1189

Do you really need to check these things? I would have thought checking DeprecatedStirngLiteralToCharPtr would be enough.

3348–3352

This looks suspicious: is it not possible for two conversions involving a string-literal-to-char* conversion to have different ranks? For instance, what if one is a user-defined conversion sequence that converts string literal -> char* -> class type, and the other just converts string literal -> char*?

I think what you want is to start this function with something like:

if (getLangOpts().CPlusPlus11 && !getLangOpts().WritableStrings &&
    ICS1.DeprecatedStringLiteralToCharPtr != ICS2.DeprecatedStringLiteralToCharPtr)
  return ICS1.DeprecatedStringLiteralToCharPtr ? ICS::Worse : ICS::Better;

(That is, any ill-formed conversion is worse than any non-ill-formed conversion.)

[ismailp]

lib/Sema/SemaOverload.cpp

1187–1189

This function is removed in the new patch (coming soon). I have checked the full sequence, because the member DeprecatedStringLiteralToCharPtr was not initialized in other cases. I have fixed this in new patch. Instead of checking entire sequence, we check only DeprecatedStringLiteralToCharPtr. I thought it is better to initialize DeprecatedStringLiteralToCharPtr in all cases.

3348–3352

Thank you for the heads up. I forgot user defined conversion sequence completely. I have used your suggestion almost exactly, with minor change. A new test added for user defined conversion sequence vs. ill-formed conversion ranking.

[ismailp]

Added new test for user defined conversion sequence.
User defined conversions were handled incorrectly in previous revision.
Added DeprecatedStringLiteralToCharPtr initializations, so that we don't have to check standard conversion sequence has Array to pointer->identity->qualification conversions (previously needed for checking DeprecatedStringLiteralToCharPtr).
Added checks to ensure we pick the correct overloads.

[rsmith]

include/clang/Basic/DiagnosticSemaKinds.td

4526–4529

Since the last revision of your patch we've added a new way to do this. Add SFINAEFailure to the ext_ diagnostic and drop the err_ one:

def ext_deprecated_string_literal_conversion : ExtWarn<
  "conversion from string literal to %0 is ill-formed in C++11">,
  InGroup<DeprecatedWritableStr>, SFINAEFailure;

4527

We don't phrase warnings this way elsewhere in the compiler. For consistency, word this as:

"ISO C++11 does not allow conversion from string literal to %0"

lib/Sema/SemaExprCXX.cpp

3069

Please add a test for the case where this happens in a SFINAE context. For instance:

int f(int, char*);
template<typename T> void g(T, decltype(f(T{}, "foo")));
template<typename T> int &g(...);
int &r = g(0, 0); // ok in c++11, picks g(...) because g<int> has a substitution failure

lib/Sema/SemaOverload.cpp

1152

This is redundant; StandardConversionSequence::setAsIdentityConversion already does this.

1244

Likewise.

2986

Likewise.

2989

Likewise.

3180

Likewise.

3194

Likewise.

3323

Please add a brief comment before this explaining that the deprecated conversion is ill-formed in c++11, so we rank any conversion sequence that uses it as worse than any sequence that does not.

4430

This looks wrong: if TryImplicitConversion performed a deprecated conversion to char*, we still have one in this conversion sequence. This might matter for a case like binding a 'char *const &' to a string literal.

4556

This is redundant.

4560

Likewise.

4652

Likewise.

4814

Likewise.

test/SemaCXX/overload-0x.cpp

22–24

Please use a syntax-only test for this, rather than an IR generation test. For instance:

  int &r = f("foo");
#if __cplusplus < 201103L
  // expected-warning@-2 {{deprecated}}
  // expected-error@-3 {{cannot bind}}
#endif

42

This won't work: "warning: " is not part of the string that -verify checks.

[ismailp]

Changes since last revision:

• Changed diagnostics message.
• Removed superfluous DeprecatedStringLiteralToCharPtr = false.
• Added comments in CompareImplicitConversionSequences function.
• Added test for SFINAE failure.
• Changed tests to check syntax instead of IR

[rsmith]

Sorry, forgot to Clowncopterize =(

I think this is basically ready to commit, just a couple of tiny comments.

lib/Sema/SemaOverload.cpp

3295–3304

Now DeprecatedStringLiteralToCharPtr is always initialized, do you need this complexity? Would this work:

return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
       (ICS.isUserDefined() && ICS.UserDefined.Before.DeprecatedStringLiteralToCharPtr);

test/SemaCXX/overload-0x.cpp

1–6

Do you really need all three of these and the macro? Since you're not testing the generated IR any more, I think you can drop the #ifndef and go down to two RUN: lines (one for c++11 and one for c++98).

[ismailp]

Added missing initializations for StandardConversionSequence::DeprecatedStringLiteralToCharPtr.
This enables us to check fewer members of ImplicitConversionSequence to decide whether this
use of conversion is deprecated in C++11.

[ismailp]

Sorry, this is the first time I have tried arcanist (I thought arc diff would give me the diff :) ), and it seems like patch is posted before removing macros from the test case, and responding to your last feedback.

Nevertheless, yes, the condition can be simplified, as long as DeprecatedStringLiteralToCharPtr is initialized. It turned out it wasn't always initialized. CHECK_BEST seems like irrelevant, and will be removed. If the rest seems ready, I will remove them before commit, instead of posting another patch.

[rsmith]

LGTM with the test case cleaned up to remove CHECK_BEST and the extra RUN line. Thanks!

[ismailp]

Commited in r199513, r199997 , and r199988.

include/clang/Basic/DiagnosticSemaKinds.td

def ext_array_init_copy : Extension<
   "%diff{of type $ from a compound literal of type $|"
   "from a compound literal}0,1 is a GNU extension">, InGroup<GNUCompoundLiteralInitializer>;
 // This is intentionally not disabled by -Wno-gnu.
 def ext_array_init_parens : ExtWarn<
   "parenthesized initialization of a member array is a GNU extension">,
   InGroup<DiagGroup<"gnu-array-member-paren-init">>, DefaultError;
 def warn_deprecated_string_literal_conversion : Warning<
   "conversion from string literal to %0 is deprecated">,
   InGroup<CXX11CompatDeprecatedWritableStr>;
+def ext_deprecated_string_literal_conversion : ExtWarn<
+  "ISO C++11 does not allow conversion from string literal to %0">,
+  InGroup<CXX11CompatDeprecatedWritableStr>, SFINAEFailure;
 def warn_deprecated_string_literal_conversion_c : Warning<
   "dummy warning to enable -fconst-strings">, InGroup<DeprecatedWritableStr>, DefaultIgnore;
 def err_realimag_invalid_type : Error<"invalid type %0 to %1 operator">;
 def err_typecheck_sclass_fscope : Error<
   "illegal storage class on file-scoped variable">;
 def err_unsupported_global_register : Error<
   "global register variables are not supported">;
 def warn_standalone_specifier : Warning<"'%0' ignored on this declaration">,

lib/Sema/SemaExprCXX.cpp

case ICK_Qualification: {
     // The qualification keeps the category of the inner expression, unless the
     // target type isn't a reference.
     ExprValueKind VK = ToType->isReferenceType() ?
                                   From->getValueKind() : VK_RValue;
     From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
                              CK_NoOp, VK, /*BasePath=*/0, CCK).take();
 
     if (SCS.DeprecatedStringLiteralToCharPtr &&
-        !getLangOpts().WritableStrings)
-      Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion)
+        !getLangOpts().WritableStrings) {
+      Diag(From->getLocStart(), getLangOpts().CPlusPlus11
+           ? diag::ext_deprecated_string_literal_conversion
+           : diag::warn_deprecated_string_literal_conversion)
         << ToType.getNonReferenceType();
+    }
 
     break;
   }
 
   default:
     llvm_unreachable("Improper third standard conversion");
   }
 
   // If this conversion sequence involved a scalar -> atomic conversion, perform
   // that conversion now.
   if (!ToAtomicType.isNull()) {

lib/Sema/SemaOverload.cpp

if (CXXConstructorDecl *Constructor
           (FromCanon == ToCanon || S.IsDerivedFrom(FromCanon, ToCanon))) {
         // Turn this into a "standard" conversion sequence, so that it
         // gets ranked with standard conversion sequences.
         ICS.setStandard();
         ICS.Standard.setAsIdentityConversion();
         ICS.Standard.setFromType(From->getType());
         ICS.Standard.setAllToTypes(ToType);
         ICS.Standard.CopyConstructor = Constructor;
         if (ToCanon != FromCanon)
           ICS.Standard.Second = ICK_Derived_To_Base;
       }
     }
 
     // C++ [over.best.ics]p4:
     //   However, when considering the argument of a user-defined
     //   conversion function that is a candidate by 13.3.1.3 when
     //   invoked for the copying of the temporary in the second step
TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
   return ICS;
 }
 
 /// TryImplicitConversion - Attempt to perform an implicit conversion
 /// from the given expression (Expr) to the given type (ToType). This
 /// function returns an implicit conversion sequence that can be used
 /// to perform the initialization. Given
 ///
 ///   void f(float f);
 ///   void g(int i) { f(i); }
 ///
 /// this routine would produce an implicit conversion sequence to
 /// describe the initialization of f from i, which will be a standard
 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
 //
 /// Note that this routine only determines how the conversion can be
 /// performed; it does not actually perform the conversion. As such,
 /// it will not produce any diagnostics if no conversion is available,
TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
   QualType FromType = From->getType();
   if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
       (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
        S.IsDerivedFrom(FromType, ToType))) {
     ICS.setStandard();
     ICS.Standard.setAsIdentityConversion();
     ICS.Standard.setFromType(FromType);
     ICS.Standard.setAllToTypes(ToType);
 
     // We don't actually check at this point whether there is a valid
     // copy/move constructor, since overloading just assumes that it
     // exists. When we actually perform initialization, we'll find the
     // appropriate constructor to copy the returned object, if needed.
     ICS.Standard.CopyConstructor = 0;
 
     // Determine whether this is considered a derived-to-base conversion.
     if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
                                  bool InOverloadResolution,
                                  StandardConversionSequence &SCS,
                                  bool CStyle,
                                  bool AllowObjCWritebackConversion) {
   QualType FromType = From->getType();
 
   // Standard conversions (C++ [conv])
   SCS.setAsIdentityConversion();
-  SCS.DeprecatedStringLiteralToCharPtr = false;
   SCS.IncompatibleObjC = false;
   SCS.setFromType(FromType);
   SCS.CopyConstructor = 0;
 
   // There are no standard conversions for class types in C++, so
   // abort early. When overloading in C, however, we do permit
   if (FromType->isRecordType() || ToType->isRecordType()) {
     if (S.getLangOpts().CPlusPlus)
if (argIsLValue &&
     SCS.First = ICK_Array_To_Pointer;
 
     // An lvalue or rvalue of type "array of N T" or "array of unknown
     // bound of T" can be converted to an rvalue of type "pointer to
     // T" (C++ 4.2p1).
     FromType = S.Context.getArrayDecayedType(FromType);
 
     if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
-      // This conversion is deprecated. (C++ D.4).
+      // This conversion is deprecated in C++03 (D.4)
       SCS.DeprecatedStringLiteralToCharPtr = true;
 
       // For the purpose of ranking in overload resolution
       // (13.3.3.1.1), this conversion is considered an
       // array-to-pointer conversion followed by a qualification
       // conversion (4.4). (C++ 4.2p2)
       SCS.Second = ICK_Identity;
       SCS.Third = ICK_Qualification;
case OR_Success: {
     // Record the standard conversion we used and the conversion function.
     CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
     QualType ThisType = Constructor->getThisType(S.Context);
     // Initializer lists don't have conversions as such.
     User.Before.setAsIdentityConversion();
     User.HadMultipleCandidates = HadMultipleCandidates;
     User.ConversionFunction = Constructor;
     User.FoundConversionFunction = Best->FoundDecl;
     User.After.setAsIdentityConversion();
     User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
     User.After.setAllToTypes(ToType);
     return OR_Success;
   }
 
   case OR_No_Viable_Function:
     return OR_No_Viable_Function;
   case OR_Deleted:
     return OR_Deleted;
   case OR_Ambiguous:
     return OR_Ambiguous;
if (CXXConstructorDecl *Constructor
       //   constructor (12.3.1), the initial standard conversion
       //   sequence converts the source type to the type required by
       //   the argument of the constructor.
       //
       QualType ThisType = Constructor->getThisType(S.Context);
       if (isa<InitListExpr>(From)) {
         // Initializer lists don't have conversions as such.
         User.Before.setAsIdentityConversion();
       } else {
         if (Best->Conversions[0].isEllipsis())
           User.EllipsisConversion = true;
         else {
           User.Before = Best->Conversions[0].Standard;
           User.EllipsisConversion = false;
         }
       }
       User.HadMultipleCandidates = HadMultipleCandidates;
       User.ConversionFunction = Constructor;
       User.FoundConversionFunction = Best->FoundDecl;
       User.After.setAsIdentityConversion();
       User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
       User.After.setAllToTypes(ToType);
       return OR_Success;
     }
     if (CXXConversionDecl *Conversion
                  = dyn_cast<CXXConversionDecl>(Best->Function)) {
       // C++ [over.ics.user]p1:
       //
       //   [...] If the user-defined conversion is specified by a
       //   conversion function (12.3.2), the initial standard
       //   conversion sequence converts the source type to the

 bool
 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
   ImplicitConversionSequence ICS;
   OverloadCandidateSet CandidateSet(From->getExprLoc());
   OverloadingResult OvResult =
     IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
                             CandidateSet, false, false);
   if (OvResult == OR_Ambiguous)
-    Diag(From->getLocStart(),
-         diag::err_typecheck_ambiguous_condition)
-          << From->getType() << ToType << From->getSourceRange();
+    Diag(From->getLocStart(), diag::err_typecheck_ambiguous_condition)
   else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) {
     if (!RequireCompleteType(From->getLocStart(), ToType,
                              diag::err_typecheck_nonviable_condition_incomplete,
                              From->getType(), From->getSourceRange()))
-      Diag(From->getLocStart(),
-           diag::err_typecheck_nonviable_condition)
-           << From->getType() << From->getSourceRange() << ToType;
-  }
-  else
+      Diag(From->getLocStart(), diag::err_typecheck_nonviable_condition)
+  } else
     return false;
   CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
   return true;
 }
 
 /// \brief Compare the user-defined conversion functions or constructors
 /// of two user-defined conversion sequences to determine whether any ordering
 /// is possible.
 static ImplicitConversionSequence::CompareKind
-compareConversionFunctions(Sema &S,
-                           FunctionDecl *Function1,
+compareConversionFunctions(Sema &S, FunctionDecl *Function1,
                            FunctionDecl *Function2) {
   if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11)
     return ImplicitConversionSequence::Indistinguishable;
-  
   // Objective-C++:
   //   If both conversion functions are implicitly-declared conversions from
-  //   a lambda closure type to a function pointer and a block pointer, 
+  //   a lambda closure type to a function pointer and a block pointer,
   //   respectively, always prefer the conversion to a function pointer,
   //   because the function pointer is more lightweight and is more likely
   //   to keep code working.
   CXXConversionDecl *Conv1 = dyn_cast<CXXConversionDecl>(Function1);
   if (!Conv1)
     return ImplicitConversionSequence::Indistinguishable;
-    
   CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
   if (!Conv2)
     return ImplicitConversionSequence::Indistinguishable;
-  
   if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
     bool Block1 = Conv1->getConversionType()->isBlockPointerType();
     bool Block2 = Conv2->getConversionType()->isBlockPointerType();
     if (Block1 != Block2)
-      return Block1? ImplicitConversionSequence::Worse 
+      return Block1 ? ImplicitConversionSequence::Worse
                     : ImplicitConversionSequence::Better;
   }
 
   return ImplicitConversionSequence::Indistinguishable;
 }
-  
+static bool hasDeprecatedStringLiteralToCharPtrConversion(
+    const ImplicitConversionSequence &ICS) {
+  return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
+         (ICS.isUserDefined() &&
+          ICS.UserDefined.Before.DeprecatedStringLiteralToCharPtr);
+}
+
 /// CompareImplicitConversionSequences - Compare two implicit
 /// conversion sequences to determine whether one is better than the
 /// other or if they are indistinguishable (C++ 13.3.3.2).
 static ImplicitConversionSequence::CompareKind
 CompareImplicitConversionSequences(Sema &S,
                                    const ImplicitConversionSequence& ICS1,
                                    const ImplicitConversionSequence& ICS2)
 {
   // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
   // conversion sequences (as defined in 13.3.3.1)
   //   -- a standard conversion sequence (13.3.3.1.1) is a better
   //      conversion sequence than a user-defined conversion sequence or
   //      an ellipsis conversion sequence, and
   //   -- a user-defined conversion sequence (13.3.3.1.2) is a better
   //      conversion sequence than an ellipsis conversion sequence
   //      (13.3.3.1.3).
   //
   // C++0x [over.best.ics]p10:
   //   For the purpose of ranking implicit conversion sequences as
   //   described in 13.3.3.2, the ambiguous conversion sequence is
   //   treated as a user-defined sequence that is indistinguishable
   //   from any other user-defined conversion sequence.
+
+  // String literal to 'char *' conversion has been deprecated in C++03. It has
+  // been removed from C++11. We still accept this conversion, if it happens at
+  // the best viable function. Otherwise, this conversion is considered worse
+  // than ellipsis conversion. Consider this as an extension; this is not in the
+  // standard. For example:
+  //
+  // int &f(...);    // #1
+  // void f(char*);  // #2
+  // void g() { int &r = f("foo"); }
+  //
+  // In C++03, we pick #2 as the best viable function.
+  // In C++11, we pick #1 as the best viable function, because ellipsis
+  // conversion is better than string-literal to char* conversion (since there
+  // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
+  // convert arguments, #2 would be the best viable function in C++11.
+  // If the best viable function has this conversion, a warning will be issued
+  // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
+
+  if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
+      hasDeprecatedStringLiteralToCharPtrConversion(ICS1) !=
+      hasDeprecatedStringLiteralToCharPtrConversion(ICS2))
+    return hasDeprecatedStringLiteralToCharPtrConversion(ICS1)
+               ? ImplicitConversionSequence::Worse
+               : ImplicitConversionSequence::Better;
+
   if (ICS1.getKindRank() < ICS2.getKindRank())
     return ImplicitConversionSequence::Better;
   if (ICS2.getKindRank() < ICS1.getKindRank())
     return ImplicitConversionSequence::Worse;
 
   // The following checks require both conversion sequences to be of
   // the same kind.
   if (ICS1.getKind() != ICS2.getKind())
     return ImplicitConversionSequence::Indistinguishable;
 
   ImplicitConversionSequence::CompareKind Result =
       ImplicitConversionSequence::Indistinguishable;
 
if (InitCategory.isLValue() &&
       ICS.Standard.ReferenceBinding = true;
       ICS.Standard.DirectBinding = true;
       ICS.Standard.IsLvalueReference = !isRValRef;
       ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
       ICS.Standard.BindsToRvalue = false;
       ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
       ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
       ICS.Standard.CopyConstructor = 0;
+      ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
 
       // Nothing more to do: the inaccessibility/ambiguity check for
       // derived-to-base conversions is suppressed when we're
       // computing the implicit conversion sequence (C++
       // [over.best.ics]p2).
       return ICS;
     }
 
ICS.Standard.DirectBinding =
       S.getLangOpts().CPlusPlus11 ||
       (InitCategory.isPRValue() && !T2->isRecordType());
     ICS.Standard.IsLvalueReference = !isRValRef;
     ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
     ICS.Standard.BindsToRvalue = InitCategory.isRValue();
     ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
     ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
     ICS.Standard.CopyConstructor = 0;
+    ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
     return ICS;
   }
 
   //            -- has a class type (i.e., T2 is a class type), where T1 is not
   //               reference-related to T2, and can be implicitly converted to
   //               an xvalue, class prvalue, or function lvalue of type
   //               "cv3 T3", where "cv1 T1" is reference-compatible with
   //               "cv3 T3",
TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
   // Of course, that's still a reference binding.
   if (ICS.isStandard()) {
     ICS.Standard.ReferenceBinding = true;
     ICS.Standard.IsLvalueReference = !isRValRef;
     ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
     ICS.Standard.BindsToRvalue = true;
     ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
     ICS.Standard.ObjCLifetimeConversionBinding = false;
   } else if (ICS.isUserDefined()) {
     // Don't allow rvalue references to bind to lvalues.
     if (DeclType->isRValueReferenceType()) {
       if (const ReferenceType *RefType
             = ICS.UserDefined.ConversionFunction->getResultType()
                 ->getAs<LValueReferenceType>()) {
         if (!RefType->getPointeeType()->isFunctionType()) {
           ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, 
                      DeclType);
InitializedEntity Entity =
         InitializedEntity::InitializeParameter(S.Context, ToType,
                                                /*Consumed=*/false);
     if (S.CanPerformCopyInitialization(Entity, S.Owned(From))) {
       Result.setUserDefined();
       Result.UserDefined.Before.setAsIdentityConversion();
       // Initializer lists don't have a type.
       Result.UserDefined.Before.setFromType(QualType());
       Result.UserDefined.Before.setAllToTypes(QualType());
 
       Result.UserDefined.After.setAsIdentityConversion();
       Result.UserDefined.After.setFromType(ToType);
       Result.UserDefined.After.setAllToTypes(ToType);
       Result.UserDefined.ConversionFunction = 0;
     }
     return Result;
   }
 
   // C++11 [over.ics.list]p5:
   //   Otherwise, if the parameter is a reference, see 13.3.3.1.4.
   if (ToType->isReferenceType()) {
     // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
if (NumInits == 1)
                                      AllowObjCWritebackConversion);
     //    - if the initializer list has no elements, the implicit conversion
     //      sequence is the identity conversion.
     else if (NumInits == 0) {
       Result.setStandard();
       Result.Standard.setAsIdentityConversion();
       Result.Standard.setFromType(ToType);
       Result.Standard.setAllToTypes(ToType);
     }
     return Result;
   }
 
   // C++11 [over.ics.list]p7:
   //   In all cases other than those enumerated above, no conversion is possible
   return Result;
 }
 
TryObjectArgumentInitialization(Sema &S, QualType FromType,
   ICS.Standard.setAllToTypes(ImplicitParamType);
   ICS.Standard.ReferenceBinding = true;
   ICS.Standard.DirectBinding = true;
   ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue;
   ICS.Standard.BindsToFunctionLvalue = false;
   ICS.Standard.BindsToRvalue = FromClassification.isRValue();
   ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier
     = (Method->getRefQualifier() == RQ_None);
   return ICS;
 }
 
 /// PerformObjectArgumentInitialization - Perform initialization of
 /// the implicit object parameter for the given Method with the given
 /// expression.
 ExprResult
 Sema::PerformObjectArgumentInitialization(Expr *From,
                                           NestedNameSpecifier *Qualifier,

test/SemaCXX/cxx0x-type-convert-construct.cpp

 // RUN: %clang_cc1 -std=gnu++11 -fsyntax-only -verify %s 
 
 void f() {
   char *u8str;
   u8str = u8"a UTF-8 string"; // expected-error {{assigning to 'char *' from incompatible type 'const char [15]'}}
   char16_t *ustr;
   ustr = u"a UTF-16 string"; // expected-error {{assigning to 'char16_t *' from incompatible type 'const char16_t [16]'}}
   char32_t *Ustr;
   Ustr = U"a UTF-32 string"; // expected-error {{assigning to 'char32_t *' from incompatible type 'const char32_t [16]'}}
 
   char *Rstr;
-  Rstr = R"foo(a raw string)foo"; // expected-warning{{conversion from string literal to 'char *' is deprecated}}
+  Rstr = R"foo(a raw string)foo"; // expected-warning{{ISO C++11 does not allow conversion from string literal to 'char *'}}
   wchar_t *LRstr;
-  LRstr = LR"foo(a wide raw string)foo"; // expected-warning{{conversion from string literal to 'wchar_t *' is deprecated}}
+  LRstr = LR"foo(a wide raw string)foo"; // expected-warning{{ISO C++11 does not allow conversion from string literal to 'wchar_t *'}}
   char *u8Rstr;
   u8Rstr = u8R"foo(a UTF-8 raw string)foo"; // expected-error {{assigning to 'char *' from incompatible type 'const char [19]'}}
   char16_t *uRstr;
   uRstr = uR"foo(a UTF-16 raw string)foo"; // expected-error {{assigning to 'char16_t *' from incompatible type 'const char16_t [20]'}}
   char32_t *URstr;
   URstr = UR"foo(a UTF-32 raw string)foo"; // expected-error {{assigning to 'char32_t *' from incompatible type 'const char32_t [20]'}}
 }

test/SemaCXX/deprecated.cpp

void stuff() {
   register int n;
 #if __cplusplus >= 201103L && !defined(NO_DEPRECATED_FLAGS)
   // expected-warning@-2 {{'register' storage class specifier is deprecated}}
 #endif
 
   register int m asm("rbx"); // no-warning
 
   int k = to_int(n); // no-warning
-
   bool b;
   ++b; // expected-warning {{incrementing expression of type bool is deprecated}}
 
-  // FIXME: This is ill-formed in C++11.
-  char *p = "foo"; // expected-warning {{conversion from string literal to 'char *' is deprecated}}
+  char *p = "foo";
+#if __cplusplus < 201103L
+  // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+#else
+  // expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'char *'}}
+#endif
 }
 
 struct S { int n; };
 struct T : private S {
   S::n;
 #if __cplusplus < 201103L
   // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
 #else

test/SemaCXX/overload-0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s 
+// RUN: %clang_cc1 -DCHECK_BEST -std=c++11 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -DCHECK_BEST -fsyntax-only -verify %s
 
+#ifndef CHECK_BEST
 namespace test0 {
   struct A { // expected-note {{candidate function (the implicit copy assignment operator) not viable: 'this' argument has type 'const test0::A', but method is not marked const}} expected-note {{candidate function (the implicit move assignment operator) not viable: 'this' argument has type 'const test0::A', but method is not marked const}}
     A &operator=(void*); // expected-note {{candidate function not viable: 'this' argument has type 'const test0::A', but method is not marked const}}
   };
 
   void test(const A &a) {
     a = "help"; // expected-error {{no viable overloaded '='}}
   }
 }
+#endif
+
+namespace PR16314 {
+  void f(char*);
+  int &f(...);
+  void x()
+  {
+    int &n = f("foo");
+#if __cplusplus < 201103L
+    // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+    // expected-error@-3 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'void'}}
+#endif
+  }
+}
+
+namespace warn_if_best {
+  int f(char *);
+  void f(double);
+  void x()
+  {
+    int n = f("foo");
+#if __cplusplus < 201103L
+    // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+#else
+    // expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'char *'}}
+#endif
+  }
+}
+
+namespace userdefined_vs_illformed {
+  struct X { X(const char *); };
+
+  void *f(char *p); // best for C++03
+  double f(X x);  // best for C++11
+  void g()
+  {
+    double d = f("foo");
+#if __cplusplus < 201103L
+    // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+    // expected-error@-3 {{cannot initialize a variable of type 'double' with an rvalue of type 'void *'}}
+#endif
+  }
+}
+
+namespace sfinae_test {
+  int f(int, char*);
+
+  template<int T>
+  struct S { typedef int type; };
+
+  template<>
+  struct S<sizeof(int)> { typedef void type; };
+
+  // C++11: SFINAE failure
+  // C++03: ok
+  template<typename T> int cxx11_ignored(T, typename S<sizeof(f(T(), "foo"))>::type *);
+#if __cplusplus < 201103L
+  // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+#else
+  // expected-note@-4 {{candidate template ignored: substitution failure}}
+#endif
+
+  // C++11: better than latter
+  // C++03: worse than latter
+  template<typename T> void g(T, ...);
+  template<typename T> int g(T, typename S<sizeof(f(T(), "foo"))>::type *);
+#if __cplusplus < 201103L
+  // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+#endif
+
+  int a = cxx11_ignored(0, 0);
+  int b = g(0, 0);
+#if __cplusplus >= 201103L
+  // expected-error@-3 {{no matching function for call to 'cxx11_ignored'}}
+  // expected-error@-3 {{cannot initialize a variable of type 'int' with an rvalue of type 'void'}}
+#endif
+}

unittests/ASTMatchers/ASTMatchersTest.cpp

EXPECT_TRUE(notMatches("void* p = static_cast<void*>(&p);",
                          reinterpretCastExpr()));
   EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
                          "B b;"
                          "D* p = dynamic_cast<D*>(&b);",
                          reinterpretCastExpr()));
 }
 
 TEST(FunctionalCast, MatchesSimpleCase) {
-  std::string foo_class = "class Foo { public: Foo(char*); };";
+  std::string foo_class = "class Foo { public: Foo(const char*); };";
   EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }",
                       functionalCastExpr()));
 }
 
 TEST(FunctionalCast, DoesNotMatchOtherCasts) {
-  std::string FooClass = "class Foo { public: Foo(char*); };";
+  std::string FooClass = "class Foo { public: Foo(const char*); };";
   EXPECT_TRUE(
       notMatches(FooClass + "void r() { Foo f = (Foo) \"hello world\"; }",
                  functionalCastExpr()));
   EXPECT_TRUE(
       notMatches(FooClass + "void r() { Foo f = \"hello world\"; }",
                  functionalCastExpr()));
 }