[Sema] Add c++2a designated initializer warnings

[rsmith]

Summary

Basic designated initializers are allowed in c++2a, so only
issue warnings for the extended ones that aren't allowed:

• out of order
• nested
• arrays
• mixed

[xbolva00]

clang/lib/Sema/SemaInit.cpp

2002 ↗

(On Diff #192048)

typo

[hintonda]

• Fix variable typo/spellings, and add missing flag assignment and additional test to catch it.

[Rakete1111]

clang/lib/Sema/SemaInit.cpp

2017 ↗

(On Diff #192049)

Can Field ever be FieldEnd at this point?

2044 ↗

(On Diff #192049)

!VerifyOnly and braces please.

2065 ↗

(On Diff #192049)

Same here. It should be !VerifyOnly. Also braces for the if statement.

3087 ↗

(On Diff #192049)

Missing dot.

3089 ↗

(On Diff #192049)

Braces.

clang/test/SemaCXX/cxx2a-initializer-aggregates.cpp

30 ↗

(On Diff #192049)

Those warnings are misleading, since C++20 does have designated initializers; they just don't support some stuff that C99 does. It would be better IMO if you could separate them. As in, the above should give you: out-of-order designated initializers are a C99 feature or something like that.

[hintonda]

Thanks for the review.

clang/lib/Sema/SemaInit.cpp

2017 ↗

(On Diff #192049)

Yes. If the last trip through the loop was a designated initializer, and it happened to be the last field in the RecordDecl, Field will be equal FieldEnd. At this point, the loop will exit below unless there's another designated initializer that's out of order.

clang/test/SemaCXX/cxx2a-initializer-aggregates.cpp

30 ↗

(On Diff #192049)

I think that would be a good idea as well, but wanted to get advise first.

[lebedev.ri]

clang/test/SemaCXX/cxx2a-initializer-aggregates.cpp

30 ↗

(On Diff #192049)

As in, the above should give you: out-of-order designated initializers are a C99 feature or something like that.

I suppose also the question is, whether to error-out, or support them as an extension?

[hintonda]

clang/test/SemaCXX/cxx2a-initializer-aggregates.cpp

30 ↗

(On Diff #192049)

Although most of them seem fine, the nested ones can be problematic. Please see https://reviews.llvm.org/D17407 for a proposal on how to fix them.

[Rakete1111]

clang/test/SemaCXX/cxx2a-initializer-aggregates.cpp

30 ↗

(On Diff #192049)

I suppose also the question is, whether to error-out, or support them as an extension?

Yes that's true. gcc doesn't support them at all in C++, and it seems like we accept it as well, but only for C classes (constructors make clang crash).

But making it an error now breaks backwards compatibility. So I think the best solution is to accept it for now, as an extension.

[hintonda]

clang/test/SemaCXX/cxx2a-initializer-aggregates.cpp

30 ↗

(On Diff #192049)

Btw, several cpp tests use nested designated initializers. Here's a quick list I got by temporarily making it an error:

CodeGenCXX/mangle-exprs.cpp
SemaCXX/cxx2a-initializer-aggregates.cpp
SemaCXX/decltype.cpp
SemaTemplate/instantiate-init.cpp

I believe there are a several out of order ones as well, but those might have been unintentional.

[hintonda]

clang/lib/Sema/SemaInit.cpp

2044 ↗

(On Diff #192049)

Will commit this change as soon as check-clang finishes, but not sure I grok the VerityOnly/!VerifyOnly criteria. Could you help me out?

[hintonda]

• Address comments.

[hintonda]

• Missed one set of braces.

[Rakete1111]

clang/lib/Sema/SemaInit.cpp

2044 ↗

(On Diff #192049)

VerifyOnly is used if you only want to verify and not actually generate any diagnostics or actually do anything that would commit to that change. So only generate the warning if !VerifyOnly.

[hintonda]

ping, and should we add new warning messages as suggested by @Rakete1111 ?

[rsmith]

clang/lib/Sema/SemaInit.cpp

2017 ↗

(On Diff #192233)

Please use an actual type rather than auto here and below.

2046 ↗

(On Diff #192233)

This should use a distinct diagnostic that says what part is an extension.

3096 ↗

(On Diff #192233)

Likewise here, we should say what specifically is an extension.

[hintonda]

• Removed auto and added specific warnings.

[hintonda]

• Fix typo.

[rsmith]

I think you're missing the enforcement of the rule that the same field name cannot be designated multiple times in a single designated-initializer-list. I'm fine with that being done separately (not as part of this patch), though.

clang/include/clang/Basic/DiagnosticSemaKinds.td

158 ↗

(On Diff #195611)

See http://clang.llvm.org/docs/InternalsManual.html#the-format-string -- do not pass English text as arguments to diagnostics as this interferes with localization. Use %select instead, or use different diagnostics for the different kinds of problem.

I think use of multiple diagnostics would be preferable anyway, as it'd give you room to explain the nature of the problem better (for instance, rather than "mixed designated initializers", you could say "mixing designated and non-designated initializers in the same initializer list is a C99 feature not permitted in C++" or something like that).

Also, we use "X is a C++20 extension" to mean "this is a C++20 feature but you don't have C++20 enabled", which is very different from what you're using it to mean here. "ISO C++20 does not support X" is how we'd usually phrase "X is not a feature of C++20 but we know what you mean".

159–160 ↗

(On Diff #195611)

In C++ <=17 mode, if we see a designated initializer that would be valid in C++20, we should diagnose that designated initializers are a C++20 feature, not that they're a C99 feature.

clang/lib/Sema/SemaInit.cpp

2069–2072 ↗

(On Diff #195611)

I think it would be preferable to diagnose the "mixed" case in the parser rather than here (it's a grammatical restriction in C++, after all). I'm worried that handling it here will get some cases wrong, such as perhaps:

struct A {
  union { int x, y; };
  int z;
};
A a = { .x = 123, 456 }; // should be rejected, but I think this patch might accept

... and it might also get template instantiation cases wrong for a case like:

struct Q { Q(); };
struct A { Q x, y; };
template<typename T> void f() {
  A a = {.y = Q()};
}
void g() { f<int>(); }

... where we might possibly end up passing an InitListExpr representing {Q(), .y = Q()} into InitListChecker.

I think the only C++20 restriction that it makes sense to check in InitListChecker is that the field names are in the right order; everything else should be checked earlier. This would also match the semantics of overload resolution, for which the "fields are in the right order" check is deferred until after a function is selected, whereas all the other checks are performed eagerly.

[hintonda]

clang/lib/Sema/SemaInit.cpp

2069–2072 ↗

(On Diff #195611)

Will work on moving these to the parser.

Btw, the first one is diagnosed correctly, but doesn't complain about the second. Not sure I grok the problem there either since Q has a default ctor.

[hintonda]

clang/lib/Sema/SemaInit.cpp

2069–2072 ↗

(On Diff #195611)

Woke up this morning and realized what you meant about the union. I'll take care of it in the next patch.

thanks again...

[sokolovd]

This looks like exactly what we need for my project. We're using Clang and Designated Initializers but would like to make sure that we use those in C++20 compatible manner. Is this blocked on something? Any way I can help?

[hintonda]

In D59754#1543949, @sokolovd wrote:

This looks like exactly what we need for my project. We're using Clang and Designated Initializers but would like to make sure that we use those in C++20 compatible manner. Is this blocked on something? Any way I can help?

The basic logic is here modulo @rsmith's comments. I just haven't had time to address them, and unfortunately, it might be another few weeks before I can get back to it.

If you'd like to work on it and finish it up, that would be great.

[rsmith]

I'm taking this over to finish it off and submit.

[hintonda]

In D59754#1651894, @rsmith wrote:

I'm taking this over to finish it off and submit.

Thanks Richard...

[xbolva00]

cfe/trunk/lib/Sema/SemaInit.cpp

3112

warning: variable ‘HasArrayDesignator’ set but not used [-Wunused-but-set-variable]

bool HasArrayDesignator = false;

[leonardchan]

Hi! We've noticed that for our arm bots, we're getting some flaky builds that sometimes fail with error: array designators are a C99 extension [-Werror,-Wc99-designator] and sometimes don't fail. 2 questions:

1. I can't see it off the patch immediately, but do you know why for arm specifically we can only get this warning sometimes?
2. I noticed that for the test/SemaCXX/c99.cpp test, this warning is also diagnosed for the -std=c++17 case. Are C-style designated initializers only invalid in c++20, or are they also invalid in 17?

Thanks.

[phosek]

In D59754#1656217, @leonardchan wrote:

Hi! We've noticed that for our arm bots, we're getting some flaky builds that sometimes fail with error: array designators are a C99 extension [-Werror,-Wc99-designator] and sometimes don't fail. 2 questions:

1. I can't see it off the patch immediately, but do you know why for arm specifically we can only get this warning sometimes?
2. I noticed that for the test/SemaCXX/c99.cpp test, this warning is also diagnosed for the -std=c++17 case. Are C-style designated initializers only invalid in c++20, or are they also invalid in 17?

Thanks.

@rsmith ping? We're still hitting this issue in our build. Should this warning be diagnosed even when using -std=c++17?

[rsmith]

In D59754#1656217, @leonardchan wrote:

Hi! We've noticed that for our arm bots, we're getting some flaky builds that sometimes fail with error: array designators are a C99 extension [-Werror,-Wc99-designator] and sometimes don't fail. 2 questions:

1. I can't see it off the patch immediately, but do you know why for arm specifically we can only get this warning sometimes?

That is strange; can you provide me with buildbot links for a pass and a failure?

2. I noticed that for the test/SemaCXX/c99.cpp test, this warning is also diagnosed for the -std=c++17 case. Are C-style designated initializers only invalid in c++20, or are they also invalid in 17?

C-style designated initializers are invalid in all C++ standards before C++20, and some of the features are still invalid in C++20. We allow those features as an extension, but as of this change we produce a warning by default when that extension is used. We really should have been doing that for years, but it matters a lot more now, because people are going to look at Clang's diagnostics to understand which parts of C designator syntax are valid in C++ and which parts are not.

[thakis]

Another question about this, sorry. Do you know _why_ C++20 is more restrictive than C99 wrt "mixture of designated and non-designated initializers in the same initializer list is a C99 extension"? Is there some interaction with other C++ features that makes the C99 behavior difficult in C++20?

[rsmith]

In D59754#1665601, @thakis wrote:

Another question about this, sorry. Do you know _why_ C++20 is more restrictive than C99 wrt "mixture of designated and non-designated initializers in the same initializer list is a C99 extension"? Is there some interaction with other C++ features that makes the C99 behavior difficult in C++20?

The design paper P0329R0 describes this behavior but doesn't give much rationale. According to the minutes and my recollections, this was part of the design as presented and didn't really receive any pushback at any stage of the feature design and discussion. I think generally the feeling was that there was insufficient motivation for adding that level of complexity (much like with the restriction to single-level designators and lack of support for array designators).

cfe/trunk/include/clang/Basic/DiagnosticGroups.td

 def CastAlign : DiagGroup<"cast-align">;
 def CastQual : DiagGroup<"cast-qual">;
 def : DiagGroup<"char-align">;
 def Comment : DiagGroup<"comment">;
 def GNUComplexInteger : DiagGroup<"gnu-complex-integer">;
 def GNUConditionalOmittedOperand : DiagGroup<"gnu-conditional-omitted-operand">;
 def ConfigMacros : DiagGroup<"config-macros">;
 def : DiagGroup<"ctor-dtor-privacy">;
-def GNUDesignator : DiagGroup<"gnu-designator">;
 def GNUStringLiteralOperatorTemplate :
   DiagGroup<"gnu-string-literal-operator-template">;
 def UndefinedVarTemplate : DiagGroup<"undefined-var-template">;
 def UndefinedFuncTemplate : DiagGroup<"undefined-func-template">;
 def MissingNoEscape : DiagGroup<"missing-noescape">;
 
 def DeleteIncomplete : DiagGroup<"delete-incomplete">;
 def DeleteNonAbstractNonVirtualDtor : DiagGroup<"delete-non-abstract-non-virtual-dtor">;
def Deprecated : DiagGroup<"deprecated", [DeprecatedAttributes,
                                           DeprecatedDeclarations,
                                           DeprecatedDynamicExceptionSpec,
                                           DeprecatedIncrementBool,
                                           DeprecatedRegister,
                                           DeprecatedThisCapture,
                                           DeprecatedWritableStr]>,
                  DiagCategory<"Deprecations">;
 
+def CXX2aDesignator : DiagGroup<"c++20-designator">;
+// Allow -Wno-c99-designator to be used to turn off all warnings on valid C99
+// designators (including the warning controlled by -Wc++20-designator).
+def C99Designator : DiagGroup<"c99-designator", [CXX2aDesignator]>;
+def GNUDesignator : DiagGroup<"gnu-designator">;
+
 def DynamicExceptionSpec
     : DiagGroup<"dynamic-exception-spec", [DeprecatedDynamicExceptionSpec]>;
 
 def LibLTO : DiagGroup<"liblto">;
 def : DiagGroup<"disabled-optimization">;
 def : DiagGroup<"discard-qual">;
 def DivZero : DiagGroup<"division-by-zero">;
 def : DiagGroup<"div-by-zero", [DivZero]>;

 def CXX14 : DiagGroup<"c++14-extensions", [CXX14BinaryLiteral]>;
 
 // A warning group for warnings about using C++17 features as extensions in
 // earlier C++ versions.
 def CXX17 : DiagGroup<"c++17-extensions">;
 
 // A warning group for warnings about using C++2a features as extensions in
 // earlier C++ versions.
-def CXX2a : DiagGroup<"c++2a-extensions">;
+def CXX2a : DiagGroup<"c++2a-extensions", [CXX2aDesignator]>;
 
 def : DiagGroup<"c++0x-extensions", [CXX11]>;
 def : DiagGroup<"c++1y-extensions", [CXX14]>;
 def : DiagGroup<"c++1z-extensions", [CXX17]>;
 
 def DelegatingCtorCycles :
   DiagGroup<"delegating-ctor-cycles">;
 
 // A warning group for warnings about using C11 features as extensions.
 def C11 : DiagGroup<"c11-extensions">;
 
 // A warning group for warnings about using C99 features as extensions.
-def C99 : DiagGroup<"c99-extensions">;
+def C99 : DiagGroup<"c99-extensions", [C99Designator]>;
 
 // A warning group for warnings about GCC extensions.
 def GNU : DiagGroup<"gnu", [GNUAlignofExpression, GNUAnonymousStruct,
                             GNUAutoType,
                             GNUBinaryLiteral, GNUCaseRange,
                             GNUComplexInteger, GNUCompoundLiteralInitializer,
                             GNUConditionalOmittedOperand, GNUDesignator,
                             GNUEmptyInitializer, GNUEmptyStruct,

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def err_variably_modified_template_arg : Error<
   "variably modified type %0 cannot be used as a template argument">;
 def err_variably_modified_nontype_template_param : Error<
   "non-type template parameter of variably modified type %0">;
 def err_variably_modified_new_type : Error<
   "'new' cannot allocate object of variably modified type %0">;
 
 // C99 Designated Initializers
 def ext_designated_init : Extension<
-  "designated initializers are a C99 feature">, InGroup<C99>;
+  "designated initializers are a C99 feature">, InGroup<C99Designator>;
 def err_array_designator_negative : Error<
   "array designator value '%0' is negative">;
 def err_array_designator_empty_range : Error<
   "array designator range [%0, %1] is empty">;
 def err_array_designator_non_array : Error<
   "array designator cannot initialize non-array type %0">;
 def err_array_designator_too_large : Error<
   "array designator index (%0) exceeds array bounds (%1)">;
 def err_field_designator_non_aggr : Error<
   "field designator cannot initialize a "
   "%select{non-struct, non-union|non-class}0 type %1">;
 def err_field_designator_unknown : Error<
   "field designator %0 does not refer to any field in type %1">;
 def err_field_designator_nonfield : Error<
   "field designator %0 does not refer to a non-static data member">;
 def note_field_designator_found : Note<"field designator refers here">;
 def err_designator_for_scalar_init : Error<
   "designator in initializer for scalar type %0">;
-def warn_subobject_initializer_overrides : Warning<
-  "subobject initialization overrides initialization of other fields "
-  "within its enclosing subobject">, InGroup<InitializerOverrides>;
 def warn_initializer_overrides : Warning<
-  "initializer overrides prior initialization of this subobject">,
-  InGroup<InitializerOverrides>;
+  "initializer %select{partially |}0overrides prior initialization of "
+  "this subobject">, InGroup<InitializerOverrides>;
+def ext_initializer_overrides : ExtWarn<warn_initializer_overrides.Text>,
+  InGroup<InitializerOverrides>, SFINAEFailure;
+def err_initializer_overrides_destructed : Error<
+  "initializer would partially override prior initialization of object of "
+  "type %1 with non-trivial destruction">;
 def note_previous_initializer : Note<
   "previous initialization %select{|with side effects }0is here"
-  "%select{| (side effects may not occur at run time)}0">;
+  "%select{| (side effects will not occur at run time)}0">;
 def err_designator_into_flexible_array_member : Error<
   "designator into flexible array member subobject">;
 def note_flexible_array_member : Note<
   "initialized flexible array member %0 is here">;
 def ext_flexible_array_init : Extension<
   "flexible array initialization is a GNU extension">, InGroup<GNUFlexibleArrayInitializer>;
 
+// C++20 designated initializers
+def ext_cxx_designated_init : Extension<
+  "designated initializers are a C++20 extension">, InGroup<CXX2aDesignator>;
+def warn_cxx17_compat_designated_init : Warning<
+  "designated initializers are incompatible with C++ standards before C++20">,
+  InGroup<CXXPre2aCompatPedantic>, DefaultIgnore;
+def ext_designated_init_mixed : ExtWarn<
+  "mixture of designated and non-designated initializers in the same "
+  "initializer list is a C99 extension">, InGroup<C99Designator>;
+def note_designated_init_mixed : Note<
+  "first non-designated initializer is here">;
+def ext_designated_init_array : ExtWarn<
+  "array designators are a C99 extension">, InGroup<C99Designator>;
+def ext_designated_init_nested : ExtWarn<
+  "nested designators are a C99 extension">, InGroup<C99Designator>;
+def ext_designated_init_reordered : ExtWarn<
+  "ISO C++ requires field designators to be specified in declaration order; "
+  "field %1 will be initialized after field %0">, InGroup<Reorder>,
+  SFINAEFailure;
+def note_previous_field_init : Note<
+  "previous initialization for field %0 is here">;
+
 // Declarations.
 def ext_plain_complex : ExtWarn<
   "plain '_Complex' requires a type specifier; assuming '_Complex double'">;
 def ext_imaginary_constant : Extension<
   "imaginary constants are a GNU extension">, InGroup<GNUImaginaryConstant>;
 def ext_integer_complex : Extension<
   "complex integer types are a GNU extension">, InGroup<GNUComplexInteger>;
 

cfe/trunk/include/clang/Sema/Sema.h

public:
   bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
 
   ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
                                              const VarDecl *NRVOCandidate,
                                              QualType ResultType,
                                              Expr *Value,
                                              bool AllowNRVO = true);
 
+  bool CanPerformAggregateInitializationForOverloadResolution(
+      const InitializedEntity &Entity, InitListExpr *From);
+
   bool CanPerformCopyInitialization(const InitializedEntity &Entity,
                                     ExprResult Init);
   ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
                                        SourceLocation EqualLoc,
                                        ExprResult Init,
                                        bool TopLevelOfInitList = false,
                                        bool AllowExplicit = false);
   ExprResult PerformObjectArgumentInitialization(Expr *From,
ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
                                       TypeSourceInfo *TInfo,
                                       SourceLocation RParenLoc,
                                       Expr *LiteralExpr);
 
   ExprResult ActOnInitList(SourceLocation LBraceLoc,
                            MultiExprArg InitArgList,
                            SourceLocation RBraceLoc);
 
+  ExprResult BuildInitList(SourceLocation LBraceLoc,
+                           MultiExprArg InitArgList,
+                           SourceLocation RBraceLoc);
+
   ExprResult ActOnDesignatedInitializer(Designation &Desig,
                                         SourceLocation Loc,
                                         bool GNUSyntax,
                                         ExprResult Init);
 
 private:
   static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
 

cfe/trunk/lib/Sema/SemaExpr.cpp

Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
   }
 
   return MaybeBindToTemporary(E);
 }
 
 ExprResult
 Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
                     SourceLocation RBraceLoc) {
+  // Only produce each kind of designated initialization diagnostic once.
+  SourceLocation FirstDesignator;
+  bool DiagnosedArrayDesignator = false;
+  bool DiagnosedNestedDesignator = false;
+  bool DiagnosedMixedDesignator = false;
+
+  // Check that any designated initializers are syntactically valid in the
+  // current language mode.
+  for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
+    if (auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
+      if (FirstDesignator.isInvalid())
+        FirstDesignator = DIE->getBeginLoc();
+
+      if (!getLangOpts().CPlusPlus)
+        break;
+
+      if (!DiagnosedNestedDesignator && DIE->size() > 1) {
+        DiagnosedNestedDesignator = true;
+        Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
+          << DIE->getDesignatorsSourceRange();
+      }
+
+      for (auto &Desig : DIE->designators()) {
+        if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
+          DiagnosedArrayDesignator = true;
+          Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
+            << Desig.getSourceRange();
+        }
+      }
+
+      if (!DiagnosedMixedDesignator &&
+          !isa<DesignatedInitExpr>(InitArgList[0])) {
+        DiagnosedMixedDesignator = true;
+        Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
+          << DIE->getSourceRange();
+        Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
+          << InitArgList[0]->getSourceRange();
+      }
+    } else if (getLangOpts().CPlusPlus && !DiagnosedMixedDesignator &&
+               isa<DesignatedInitExpr>(InitArgList[0])) {
+      DiagnosedMixedDesignator = true;
+      auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
+      Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
+        << DIE->getSourceRange();
+      Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
+        << InitArgList[I]->getSourceRange();
+    }
+  }
+
+  if (FirstDesignator.isValid()) {
+    // Only diagnose designated initiaization as a C++20 extension if we didn't
+    // already diagnose use of (non-C++20) C99 designator syntax.
+    if (getLangOpts().CPlusPlus && !DiagnosedArrayDesignator &&
+        !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
+      Diag(FirstDesignator, getLangOpts().CPlusPlus2a
+                                ? diag::warn_cxx17_compat_designated_init
+                                : diag::ext_cxx_designated_init);
+    } else if (!getLangOpts().CPlusPlus && !getLangOpts().C99) {
+      Diag(FirstDesignator, diag::ext_designated_init);
+    }
+  }
+
+  return BuildInitList(LBraceLoc, InitArgList, RBraceLoc);
+}
+
+ExprResult
+Sema::BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
+                    SourceLocation RBraceLoc) {
+  // Semantic analysis for initializers is done by ActOnDeclarator() and
+  // CheckInitializer() - it requires knowledge of the object being initialized.
+
   // Immediately handle non-overload placeholders.  Overloads can be
   // resolved contextually, but everything else here can't.
   for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
     if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
       ExprResult result = CheckPlaceholderExpr(InitArgList[I]);
 
       // Ignore failures; dropping the entire initializer list because
       // of one failure would be terrible for indexing/etc.
       if (result.isInvalid()) continue;
 
       InitArgList[I] = result.get();
     }
   }
 
-  // Semantic analysis for initializers is done by ActOnDeclarator() and
-  // CheckInitializer() - it requires knowledge of the object being initialized.
-
   InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
                                                RBraceLoc);
   E->setType(Context.VoidTy); // FIXME: just a place holder for now.
   return E;
 }
 
 /// Do an explicit extend of the given block pointer if we're in ARC.
 void Sema::maybeExtendBlockObject(ExprResult &E) {

cfe/trunk/lib/Sema/SemaInit.cpp

 /// If an initializer list contains any designators, we build a placeholder
 /// structured list even in 'verify only' mode, so that we can track which
 /// elements need 'empty' initializtion.
 class InitListChecker {
   Sema &SemaRef;
   bool hadError = false;
   bool VerifyOnly; // No diagnostics.
   bool TreatUnavailableAsInvalid; // Used only in VerifyOnly mode.
+  bool InOverloadResolution;
   InitListExpr *FullyStructuredList = nullptr;
   NoInitExpr *DummyExpr = nullptr;
 
   NoInitExpr *getDummyInit() {
     if (!DummyExpr)
       DummyExpr = new (SemaRef.Context) NoInitExpr(SemaRef.Context.VoidTy);
     return DummyExpr;
   }
InitListExpr *createInitListExpr(QualType CurrentObjectType,
                                    SourceRange InitRange,
                                    unsigned ExpectedNumInits);
   int numArrayElements(QualType DeclType);
   int numStructUnionElements(QualType DeclType);
 
   ExprResult PerformEmptyInit(SourceLocation Loc,
                               const InitializedEntity &Entity);
 
+  /// Diagnose that OldInit (or part thereof) has been overridden by NewInit.
+  void diagnoseInitOverride(Expr *OldInit, SourceRange NewInitRange,
+                            bool FullyOverwritten = true) {
+    // Overriding an initializer via a designator is valid with C99 designated
+    // initializers, but ill-formed with C++20 designated initializers.
+    unsigned DiagID = SemaRef.getLangOpts().CPlusPlus
+                          ? diag::ext_initializer_overrides
+                          : diag::warn_initializer_overrides;
+
+    if (InOverloadResolution && SemaRef.getLangOpts().CPlusPlus) {
+      // In overload resolution, we have to strictly enforce the rules, and so
+      // don't allow any overriding of prior initializers. This matters for a
+      // case such as:
+      //
+      //   union U { int a, b; };
+      //   struct S { int a, b; };
+      //   void f(U), f(S);
+      //
+      // Here, f({.a = 1, .b = 2}) is required to call the struct overload. For
+      // consistency, we disallow all overriding of prior initializers in
+      // overload resolution, not only overriding of union members.
+      hadError = true;
+    } else if (OldInit->getType().isDestructedType() && !FullyOverwritten) {
+      // If we'll be keeping around the old initializer but overwriting part of
+      // the object it initialized, and that object is not trivially
+      // destructible, this can leak. Don't allow that, not even as an
+      // extension.
+      //
+      // FIXME: It might be reasonable to allow this in cases where the part of
+      // the initializer that we're overriding has trivial destruction.
+      DiagID = diag::err_initializer_overrides_destructed;
+    } else if (!OldInit->getSourceRange().isValid()) {
+      // We need to check on source range validity because the previous
+      // initializer does not have to be an explicit initializer. e.g.,
+      //
+      // struct P { int a, b; };
+      // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
+      //
+      // There is an overwrite taking place because the first braced initializer
+      // list "{ .a = 2 }" already provides value for .p.b (which is zero).
+      //
+      // Such overwrites are harmless, so we don't diagnose them. (Note that in
+      // C++, this cannot be reached unless we've already seen and diagnosed a
+      // different conformance issue, such as a mixture of designated and
+      // non-designated initializers or a multi-level designator.)
+      return;
+    }
+
+    if (!VerifyOnly) {
+      SemaRef.Diag(NewInitRange.getBegin(), DiagID)
+          << NewInitRange << FullyOverwritten << OldInit->getType();
+      SemaRef.Diag(OldInit->getBeginLoc(), diag::note_previous_initializer)
+          << (OldInit->HasSideEffects(SemaRef.Context) && FullyOverwritten)
+          << OldInit->getSourceRange();
+    }
+  }
+
   // Explanation on the "FillWithNoInit" mode:
   //
   // Assume we have the following definitions (Case#1):
   // struct P { char x[6][6]; } xp = { .x[1] = "bar" };
   // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };
   //
   // l.lp.x[1][0..1] should not be filled with implicit initializers because the
   // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".
void FillInEmptyInitializations(const InitializedEntity &Entity,
                                   bool FillWithNoInit = false);
   bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
                               Expr *InitExpr, FieldDecl *Field,
                               bool TopLevelObject);
   void CheckEmptyInitializable(const InitializedEntity &Entity,
                                SourceLocation Loc);
 
 public:
-  InitListChecker(Sema &S, const InitializedEntity &Entity,
-                  InitListExpr *IL, QualType &T, bool VerifyOnly,
-                  bool TreatUnavailableAsInvalid);
+  InitListChecker(Sema &S, const InitializedEntity &Entity, InitListExpr *IL,
+                  QualType &T, bool VerifyOnly, bool TreatUnavailableAsInvalid,
+                  bool InOverloadResolution = false);
   bool HadError() { return hadError; }
 
   // Retrieves the fully-structured initializer list used for
   // semantic analysis and code generation.
   InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
 };
 
 } // end anonymous namespace
static bool hasAnyDesignatedInits(const InitListExpr *IL) {
   for (const Stmt *Init : *IL)
     if (Init && isa<DesignatedInitExpr>(Init))
       return true;
   return false;
 }
 
 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
                                  InitListExpr *IL, QualType &T, bool VerifyOnly,
-                                 bool TreatUnavailableAsInvalid)
+                                 bool TreatUnavailableAsInvalid,
+                                 bool InOverloadResolution)
     : SemaRef(S), VerifyOnly(VerifyOnly),
-      TreatUnavailableAsInvalid(TreatUnavailableAsInvalid) {
+      TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),
+      InOverloadResolution(InOverloadResolution) {
   if (!VerifyOnly || hasAnyDesignatedInits(IL)) {
     FullyStructuredList =
         createInitListExpr(T, IL->getSourceRange(), IL->getNumInits());
 
     // FIXME: Check that IL isn't already the semantic form of some other
     // InitListExpr. If it is, we'd create a broken AST.
     if (!VerifyOnly)
       FullyStructuredList->setSyntacticForm(IL);
if (!VerifyOnly)
         QualType ET = SemaRef.Context.getBaseElementType(FD->getType());
         if (checkDestructorReference(ET, IList->getEndLoc(), SemaRef)) {
           hadError = true;
           return;
         }
       }
 
     // If there's a default initializer, use it.
-    if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
+    if (isa<CXXRecordDecl>(RD) &&
+        cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
       if (!StructuredList)
         return;
       for (RecordDecl::field_iterator FieldEnd = RD->field_end();
            Field != FieldEnd; ++Field) {
         if (Field->hasInClassInitializer()) {
           StructuredList->setInitializedFieldInUnion(*Field);
           // FIXME: Actually build a CXXDefaultInitExpr?
           return;

 ///
 /// @param DesigIdx  The index of the current designator.
 ///
 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
 /// into which the designation in @p DIE should refer.
 ///
 /// @param NextField  If non-NULL and the first designator in @p DIE is
 /// a field, this will be set to the field declaration corresponding
-/// to the field named by the designator.
+/// to the field named by the designator. On input, this is expected to be
+/// the next field that would be initialized in the absence of designation,
+/// if the complete object being initialized is a struct.
 ///
 /// @param NextElementIndex  If non-NULL and the first designator in @p
 /// DIE is an array designator or GNU array-range designator, this
 /// will be set to the last index initialized by this designator.
 ///
 /// @param Index  Index into @p IList where the designated initializer
 /// @p DIE occurs.
 ///
else {
         ExistingInit = StructuredList->getArrayFiller();
 
       if (!ExistingInit)
         StructuredList = getStructuredSubobjectInit(
             IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
             SourceRange(D->getBeginLoc(), DIE->getEndLoc()));
       else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
         StructuredList = Result;
-      else if (!VerifyOnly) {
-        if (DesignatedInitUpdateExpr *E =
-                dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
-          StructuredList = E->getUpdater();
-        else {
-          DesignatedInitUpdateExpr *DIUE = new (SemaRef.Context)
-              DesignatedInitUpdateExpr(SemaRef.Context, D->getBeginLoc(),
-                                       ExistingInit, DIE->getEndLoc());
-          StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
-          StructuredList = DIUE->getUpdater();
-        }
-
-        // We need to check on source range validity because the previous
-        // initializer does not have to be an explicit initializer. e.g.,
-        //
-        // struct P { int a, b; };
-        // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
-        //
-        // There is an overwrite taking place because the first braced initializer
-        // list "{ .a = 2 }" already provides value for .p.b (which is zero).
-        if (ExistingInit->getSourceRange().isValid()) {
-          // We are creating an initializer list that initializes the
-          // subobjects of the current object, but there was already an
-          // initialization that completely initialized the current
-          // subobject, e.g., by a compound literal:
-          //
-          // struct X { int a, b; };
-          // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
-          //
-          // Here, xs[0].a == 1 and xs[0].b == 3, since the second,
-          // designated initializer re-initializes only its current object
-          // subobject [0].b.
-          SemaRef.Diag(D->getBeginLoc(),
-                       diag::warn_subobject_initializer_overrides)
-              << SourceRange(D->getBeginLoc(), DIE->getEndLoc());
-
-          SemaRef.Diag(ExistingInit->getBeginLoc(),
-                       diag::note_previous_initializer)
-              << /*FIXME:has side effects=*/0 << ExistingInit->getSourceRange();
+        diagnoseInitOverride(ExistingInit,
+                             SourceRange(D->getBeginLoc(), DIE->getEndLoc()),
+                             /*FullyOverwritten=*/false);
+
+        if (!VerifyOnly) {
+          if (DesignatedInitUpdateExpr *E =
+                  dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
+            StructuredList = E->getUpdater();
+          else {
+            DesignatedInitUpdateExpr *DIUE = new (SemaRef.Context)
+                DesignatedInitUpdateExpr(SemaRef.Context, D->getBeginLoc(),
+                                         ExistingInit, DIE->getEndLoc());
+            StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
+            StructuredList = DIUE->getUpdater();
           }
         } else {
-        // We don't need to track the structured representation of a designated
-        // init update of an already-fully-initialized object in verify-only
-        // mode. The only reason we would need the structure is to determine
-        // where the uninitialized "holes" are, and in this case, we know there
-        // aren't any and we can't introduce any.
+          // We don't need to track the structured representation of a
+          // designated init update of an already-fully-initialized object in
+          // verify-only mode. The only reason we would need the structure is
+          // to determine where the uninitialized "holes" are, and in this
+          // case, we know there aren't any and we can't introduce any.
           StructuredList = nullptr;
         }
       }
     }
+  }
 
   if (D->isFieldDesignator()) {
     // C99 6.7.8p7:
     //
     //   If a designator has the form
     //
     //      . identifier
     //
if (!KnownField) {
           SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
             << FieldName << CurrentObjectType;
           ++Index;
           return true;
         }
       }
     }
 
-    unsigned FieldIndex = 0;
-
+    unsigned NumBases = 0;
     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
-      FieldIndex = CXXRD->getNumBases();
+      NumBases = CXXRD->getNumBases();
+
+    unsigned FieldIndex = NumBases;
 
     for (auto *FI : RT->getDecl()->fields()) {
       if (FI->isUnnamedBitfield())
         continue;
       if (declaresSameEntity(KnownField, FI)) {
         KnownField = FI;
         break;
       }
if (RT->getDecl()->isUnion()) {
       FieldIndex = 0;
       if (StructuredList) {
         FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
         if (CurrentField && !declaresSameEntity(CurrentField, *Field)) {
           assert(StructuredList->getNumInits() == 1
                  && "A union should never have more than one initializer!");
 
           Expr *ExistingInit = StructuredList->getInit(0);
-          if (ExistingInit && !VerifyOnly) {
+          if (ExistingInit) {
             // We're about to throw away an initializer, emit warning.
-            SemaRef.Diag(D->getFieldLoc(),
-                         diag::warn_initializer_overrides)
-              << D->getSourceRange();
-            SemaRef.Diag(ExistingInit->getBeginLoc(),
-                         diag::note_previous_initializer)
-                << /*FIXME:has side effects=*/0
-                << ExistingInit->getSourceRange();
+            diagnoseInitOverride(
+                ExistingInit, SourceRange(D->getBeginLoc(), DIE->getEndLoc()));
           }
 
           // remove existing initializer
           StructuredList->resizeInits(SemaRef.Context, 0);
           StructuredList->setInitializedFieldInUnion(nullptr);
         }
 
         StructuredList->setInitializedFieldInUnion(*Field);
       }
     }
 
     // Make sure we can use this declaration.
     bool InvalidUse;
     if (VerifyOnly)
       InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
     else
       InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
     if (InvalidUse) {
       ++Index;
       return true;
     }
 
+    // C++20 [dcl.init.list]p3:
+    //   The ordered identifiers in the designators of the designated-
+    //   initializer-list shall form a subsequence of the ordered identifiers
+    //   in the direct non-static data members of T.
+    //
+    // Note that this is not a condition on forming the aggregate
+    // initialization, only on actually performing initialization,
+    // so it is not checked in VerifyOnly mode.
+    //
+    // FIXME: This is the only reordering diagnostic we produce, and it only
+    // catches cases where we have a top-level field designator that jumps
+    // backwards. This is the only such case that is reachable in an
+    // otherwise-valid C++20 program, so is the only case that's required for
+    // conformance, but for consistency, we should diagnose all the other
+    // cases where a designator takes us backwards too.
+    if (IsFirstDesignator && !VerifyOnly && SemaRef.getLangOpts().CPlusPlus &&
+        NextField &&
+        (*NextField == RT->getDecl()->field_end() ||
+         (*NextField)->getFieldIndex() > Field->getFieldIndex() + 1)) {
+      // Find the field that we just initialized.
+      FieldDecl *PrevField = nullptr;
+      for (auto FI = RT->getDecl()->field_begin();
+           FI != RT->getDecl()->field_end(); ++FI) {
+        if (FI->isUnnamedBitfield())
+          continue;
+        if (*NextField != RT->getDecl()->field_end() &&
+            declaresSameEntity(*FI, **NextField))
+          break;
+        PrevField = *FI;
+      }
+
+      if (PrevField &&
+          PrevField->getFieldIndex() > KnownField->getFieldIndex()) {
+        SemaRef.Diag(DIE->getBeginLoc(), diag::ext_designated_init_reordered)
+            << KnownField << PrevField << DIE->getSourceRange();
+
+        unsigned OldIndex = NumBases + PrevField->getFieldIndex();
+        if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
+          if (Expr *PrevInit = StructuredList->getInit(OldIndex)) {
+            SemaRef.Diag(PrevInit->getBeginLoc(),
+                         diag::note_previous_field_init)
+                << PrevField << PrevInit->getSourceRange();
+          }
+        }
+      }
+    }
+
+
     // Update the designator with the field declaration.
     if (!VerifyOnly)
       D->setField(*Field);
 
     // Make sure that our non-designated initializer list has space
     // for a subobject corresponding to this field.
     if (StructuredList && FieldIndex >= StructuredList->getNumInits())
       StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
     //
     // struct P { char x[6]; };
     // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } };
     //
     // The first designated initializer is ignored, and l.x is just "f".
     if (!IsFullyOverwritten)
       return Result;
 
-  if (ExistingInit && !VerifyOnly) {
+  if (ExistingInit) {
     // We are creating an initializer list that initializes the
     // subobjects of the current object, but there was already an
     // initialization that completely initialized the current
     // subobject:
     //
     // struct X { int a, b; };
     // struct X xs[] = { [0] = { 1, 2 }, [0].b = 3 };
     //
     // Here, xs[0].a == 1 and xs[0].b == 3, since the second,
     // designated initializer overwrites the [0].b initializer
     // from the prior initialization.
     //
     // When the existing initializer is an expression rather than an
     // initializer list, we cannot decompose and update it in this way.
     // For example:
     //
     // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
     //
     // This case is handled by CheckDesignatedInitializer.
-    SemaRef.Diag(InitRange.getBegin(),
-                 diag::warn_subobject_initializer_overrides)
-      << InitRange;
-    SemaRef.Diag(ExistingInit->getBeginLoc(), diag::note_previous_initializer)
-        << /*FIXME:has side effects=*/0 << ExistingInit->getSourceRange();
+    diagnoseInitOverride(ExistingInit, InitRange);
   }
 
   unsigned ExpectedNumInits = 0;
   if (Index < IList->getNumInits()) {
     if (auto *Init = dyn_cast_or_null<InitListExpr>(IList->getInit(Index)))
       ExpectedNumInits = Init->getNumInits();
     else
       ExpectedNumInits = IList->getNumInits() - Index;
void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
                                                   Expr *expr) {
   // No structured initializer list to update
   if (!StructuredList)
     return;
 
   if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
                                                   StructuredIndex, expr)) {
     // This initializer overwrites a previous initializer. Warn.
-    // We need to check on source range validity because the previous
-    // initializer does not have to be an explicit initializer.
-    // struct P { int a, b; };
-    // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
-    // There is an overwrite taking place because the first braced initializer
-    // list "{ .a = 2 }' already provides value for .p.b (which is zero).
-    if (PrevInit->getSourceRange().isValid() && !VerifyOnly) {
-      SemaRef.Diag(expr->getBeginLoc(), diag::warn_initializer_overrides)
-          << expr->getSourceRange();
-
-      SemaRef.Diag(PrevInit->getBeginLoc(), diag::note_previous_initializer)
-          << /*FIXME:has side effects=*/0 << PrevInit->getSourceRange();
-    }
+    diagnoseInitOverride(PrevInit, expr->getSourceRange());
   }
 
   ++StructuredIndex;
 }
 
+/// Determine whether we can perform aggregate initialization for the purposes
+/// of overload resolution.
+bool Sema::CanPerformAggregateInitializationForOverloadResolution(
+    const InitializedEntity &Entity, InitListExpr *From) {
+  QualType Type = Entity.getType();
+  InitListChecker Check(*this, Entity, From, Type, /*VerifyOnly=*/true,
+                        /*TreatUnavailableAsInvalid=*/false,
+                        /*InOverloadResolution=*/true);
+  return !Check.HadError();
+}
+
 /// Check that the given Index expression is a valid array designator
 /// value. This is essentially just a wrapper around
 /// VerifyIntegerConstantExpression that also checks for negative values
 /// and produces a reasonable diagnostic if there is a
 /// failure. Returns the index expression, possibly with an implicit cast
 /// added, on success.  If everything went okay, Value will receive the
 /// value of the constant expression.
 static ExprResult
ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
                                             SourceLocation Loc,
                                             bool GNUSyntax,
                                             ExprResult Init) {
   typedef DesignatedInitExpr::Designator ASTDesignator;
 
   bool Invalid = false;
   SmallVector<ASTDesignator, 32> Designators;
   SmallVector<Expr *, 32> InitExpressions;
+  bool HasArrayDesignator = false;
 
   // Build designators and check array designator expressions.
   for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
     const Designator &D = Desig.getDesignator(Idx);
     switch (D.getKind()) {
     case Designator::FieldDesignator:
       Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
                                           D.getFieldLoc()));
       break;
 
     case Designator::ArrayDesignator: {
       Expr *Index = static_cast<Expr *>(D.getArrayIndex());
       llvm::APSInt IndexValue;
       if (!Index->isTypeDependent() && !Index->isValueDependent())
         Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
       if (!Index)
         Invalid = true;
       else {
         Designators.push_back(ASTDesignator(InitExpressions.size(),
                                             D.getLBracketLoc(),
                                             D.getRBracketLoc()));
         InitExpressions.push_back(Index);
       }
+      HasArrayDesignator = true;
       break;
     }
 
     case Designator::ArrayRangeDesignator: {
       Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
       Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
       llvm::APSInt StartValue;
       llvm::APSInt EndValue;
case Designator::ArrayRangeDesignator: {
           Designators.push_back(ASTDesignator(InitExpressions.size(),
                                               D.getLBracketLoc(),
                                               D.getEllipsisLoc(),
                                               D.getRBracketLoc()));
           InitExpressions.push_back(StartIndex);
           InitExpressions.push_back(EndIndex);
         }
       }
+      HasArrayDesignator = true;
       break;
     }
     }
   }
 
   if (Invalid || Init.isInvalid())
     return ExprError();
 
   // Clear out the expressions within the designation.
   Desig.ClearExprs(*this);
 
-  DesignatedInitExpr *DIE
-    = DesignatedInitExpr::Create(Context,
-                                 Designators,
-                                 InitExpressions, Loc, GNUSyntax,
-                                 Init.getAs<Expr>());
-
-  if (!getLangOpts().C99)
-    Diag(DIE->getBeginLoc(), diag::ext_designated_init)
-        << DIE->getSourceRange();
-
-  return DIE;
+  return DesignatedInitExpr::Create(Context, Designators, InitExpressions, Loc,
+                                    GNUSyntax, Init.getAs<Expr>());
 }
 
 //===----------------------------------------------------------------------===//
 // Initialization entity
 //===----------------------------------------------------------------------===//
 
 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
                                      const InitializedEntity &Parent)

cfe/trunk/lib/Sema/SemaOverload.cpp

TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
   // C++11 [over.ics.list]p4:
   //   Otherwise, if the parameter has an aggregate type which can be
   //   initialized from the initializer list [...] the implicit conversion
   //   sequence is a user-defined conversion sequence.
   if (ToType->isAggregateType()) {
     // Type is an aggregate, argument is an init list. At this point it comes
     // down to checking whether the initialization works.
     // FIXME: Find out whether this parameter is consumed or not.
-    // FIXME: Expose SemaInit's aggregate initialization code so that we don't
-    // need to call into the initialization code here; overload resolution
-    // should not be doing that.
     InitializedEntity Entity =
         InitializedEntity::InitializeParameter(S.Context, ToType,
                                                /*Consumed=*/false);
-    if (S.CanPerformCopyInitialization(Entity, From)) {
+    if (S.CanPerformAggregateInitializationForOverloadResolution(Entity,
+                                                                 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);

cfe/trunk/lib/Sema/TreeTransform.h

 
   /// Build a new initializer list expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildInitList(SourceLocation LBraceLoc,
                              MultiExprArg Inits,
                              SourceLocation RBraceLoc) {
-    return SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
+    return SemaRef.BuildInitList(LBraceLoc, Inits, RBraceLoc);
   }
 
   /// Build a new designated initializer expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildDesignatedInitExpr(Designation &Desig,
                                              MultiExprArg ArrayExprs,

cfe/trunk/test/Analysis/globals.cpp

-// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify -std=c++2a %s
 
 
 static const unsigned long long scull = 0;
 void static_int()
 {
     *(int*)scull = 0; // expected-warning{{Dereference of null pointer}}
 }
 

cfe/trunk/test/CXX/expr/expr.const/p2-0x.cpp

namespace LValueToRValueUnion {
   union U { int a, b; } constexpr u = U();
   static_assert(u.a == 0, "");
   constexpr const int *bp = &u.b;
   constexpr int b = *bp; // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
 
   extern const U pu;
   constexpr const int *pua = &pu.a;
   constexpr const int *pub = &pu.b;
-  constexpr U pu = { .b = 1 }; // expected-warning {{C99 feature}}
+  constexpr U pu = { .b = 1 }; // expected-warning {{C++20 extension}}
   constexpr const int a2 = *pua; // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
   constexpr const int b2 = *pub; // ok
 }
 
 // - an id-expression that refers to a variable or data member of reference type
 //   unless the reference has a preceding initialization, initialized with a
 //   constant expression;
 namespace References {

cfe/trunk/test/CodeGenObjCXX/designated-initializers.mm

-// RUN: %clang_cc1 -triple arm64 %s -verify -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple arm64 %s -verify -emit-llvm -o - -Wno-c99-designator | FileCheck %s
 // expected-no-diagnostics
 
 // Make sure we don't enter an infinite loop (rdar://21942503)
 
 int vals1[] = {
   [__objc_yes] = 1,
   [__objc_no] = 2
 };

cfe/trunk/test/PCH/cxx1y-default-initializer.cpp

 
 // Instantiate the default initializer now, should create an update record.
 C<int> ci;
 
 #else
 
 static_assert(A{}.z == 3, "");
 static_assert(A{1}.z == 4, "");
-static_assert(A{.y = 5}.z == 5, ""); // expected-warning {{C99}}
-static_assert(A{3, .y = 1}.z == 4, ""); // expected-warning {{C99}}
+static_assert(A{.y = 5}.z == 5, ""); // expected-warning {{C++20}}
+static_assert(A{3, .y = 1}.z == 4, ""); // expected-warning {{C99}} expected-note {{here}}
 static_assert(make<int>().z == 3, "");
 static_assert(make<int>(12).z == 15, "");
 static_assert(C<int>().c == 0, "");
 
 #endif

cfe/trunk/test/Parser/cxx0x-lambda-expressions.cpp

-// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++11 %s
-// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++2a %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++11 -Wno-c99-designator %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++2a -Wno-c99-designator %s
 
 enum E { e };
 
 constexpr int id(int n) { return n; }
 
 class C {
 
   int f() {

cfe/trunk/test/Parser/objc-init.m

 // RUN: %clang_cc1 -fsyntax-only -fobjc-runtime=macosx-fragile -verify -pedantic -Wno-objc-root-class %s
-// RUN: %clang_cc1 -fsyntax-only -fobjc-runtime=macosx-fragile -verify -x objective-c++ -Wno-objc-root-class %s
-// RUN: %clang_cc1 -fsyntax-only -fobjc-runtime=macosx-fragile -verify -x objective-c++ -Wno-objc-root-class -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -fobjc-runtime=macosx-fragile -verify -x objective-c++ -Wno-objc-root-class -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -fobjc-runtime=macosx-fragile -verify -x objective-c++ -Wno-c99-designator -Wno-objc-root-class %s
+// RUN: %clang_cc1 -fsyntax-only -fobjc-runtime=macosx-fragile -verify -x objective-c++ -Wno-c99-designator -Wno-objc-root-class -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -fobjc-runtime=macosx-fragile -verify -x objective-c++ -Wno-c99-designator -Wno-objc-root-class -std=c++11 %s
 // rdar://5707001
 
 @interface NSNumber;
 - () METH;
 - (unsigned) METH2;
 @end
 
 struct SomeStruct {

cfe/trunk/test/Sema/designated-initializers.c

 };
 
 int counter = 0;
 int get8() { ++counter; return 8; }
 
 void test() {
   struct X xs[] = { 
     [0] = (struct X){1, 2}, // expected-note 2 {{previous initialization is here}}
-    [0].c = 3,  // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}}
+    [0].c = 3,  // expected-warning{{initializer partially overrides prior initialization of this subobject}}
     (struct X) {4, 5, 6}, // expected-note{{previous initialization is here}}
-    [1].b = get8(), // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}}
-    [0].b = 8   // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}}
+    [1].b = get8(), // expected-warning{{initializer partially overrides prior initialization of this subobject}}
+    [0].b = 8   // expected-warning{{initializer partially overrides prior initialization of this subobject}}
   };
 }
 
 union { char c; long l; } u1 = { .l = 0xFFFF };
 
 extern float global_float;
 
 struct XX { int a, *b; };
struct ds ds2 = { { {
     .b = 1 // expected-error{{field designator 'b' does not refer to any field}}
 } } };
 
 // Check initializer override warnings overriding a character in a string
 struct overwrite_string_struct {
   char L[6];
   int M;
 } overwrite_string[] = {
-  { { "foo" }, 1 }, // expected-note {{previous initialization is here}}
-  [0].L[2] = 'x' // expected-warning{{subobject initialization overrides initialization of other fields}}
+  { { "foo" }, 1 }, // expected-note{{previous initialization is here}}
+  [0].L[2] = 'x' // expected-warning{{initializer partially overrides prior initialization of this subobject}}
 };
 struct overwrite_string_struct2 {
   char L[6];
   int M;
 } overwrite_string2[] = {
     { { "foo" }, 1 }, // expected-note{{previous initialization is here}}
-    [0].L[4] = 'x' // expected-warning{{subobject initialization overrides initialization of other fields}}
+    [0].L[4] = 'x' // expected-warning{{initializer partially overrides prior initialization of this subobject}}
   };
 struct overwrite_string_struct
 overwrite_string3[] = {
   "foo", 1,           // expected-note{{previous initialization is here}}
-  [0].L[4] = 'x'  // expected-warning{{subobject initialization overrides initialization of other fields}}
+  [0].L[4] = 'x'  // expected-warning{{initializer partially overrides prior initialization of this subobject}}
 };
 struct overwrite_string_struct
 overwrite_string4[] = {
   { { 'f', 'o', 'o' }, 1 },
   [0].L[4] = 'x' // no-warning
 };
 
 struct {

cfe/trunk/test/Sema/static-assert.c

 // RUN: %clang_cc1 -std=c11 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -std=c99 -pedantic -fsyntax-only -verify=expected,ext %s
-// RUN: %clang_cc1 -xc++ -std=c++11 -pedantic -fsyntax-only -verify=expected,ext %s
+// RUN: %clang_cc1 -xc++ -std=c++11 -pedantic -fsyntax-only -verify=expected,ext,cxx %s
 
 _Static_assert("foo", "string is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
 #ifndef __cplusplus
 // expected-error@-2 {{static_assert expression is not an integral constant expression}}
 #endif
 
 _Static_assert(1, "1 is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
 _Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed "0 is nonzero"}} \
#define UNION(T1, T2) union { \
     __typeof__(T1) one; \
     __typeof__(T2) two; \
     _Static_assert(ASSERT_IS_TYPE(T1), "T1 is not a type"); \
     _Static_assert(ASSERT_IS_TYPE(T2), "T2 is not a type"); \
     _Static_assert(sizeof(T1) == sizeof(T2), "type size mismatch"); \
   }
 
 typedef UNION(unsigned, struct A) U1; // ext-warning 3 {{'_Static_assert' is a C11 extension}}
-UNION(char[2], short) u2 = { .one = { 'a', 'b' } }; // ext-warning 3 {{'_Static_assert' is a C11 extension}}
-#if defined(__cplusplus)
-// ext-warning@-2 {{designated initializers are a C99 feature}}
-#endif
+UNION(char[2], short) u2 = { .one = { 'a', 'b' } }; // ext-warning 3 {{'_Static_assert' is a C11 extension}} cxx-warning {{designated initializers are a C++20 extension}}
 typedef UNION(char, short) U3; // expected-error {{static_assert failed due to requirement 'sizeof(char) == sizeof(short)' "type size mismatch"}} \
                                // ext-warning 3 {{'_Static_assert' is a C11 extension}}
 typedef UNION(float, 0.5f) U4; // expected-error {{expected a type}} \
                                // ext-warning 3 {{'_Static_assert' is a C11 extension}}

cfe/trunk/test/SemaCXX/aggregate-initialization.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s 
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s 
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s
 
 // Verify that using an initializer list for a non-aggregate looks for
 // constructors..
 struct NonAggr1 { // expected-note 2 {{candidate constructor}}
   NonAggr1(int, int) { } // expected-note {{candidate constructor}}
 
   int m;
 };

cfe/trunk/test/SemaCXX/c99.cpp

-// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
+// RUN: %clang_cc1 -fsyntax-only -pedantic -verify=expected,cxx17 -std=c++17 %s
+// RUN: %clang_cc1 -fsyntax-only -pedantic -verify=expected,cxx20 -std=c++2a %s
+
+// cxx17-warning@* 0+{{designated initializers are a C++20 extension}}
+
 void f1(int i[static 5]) { // expected-error{{C99}}
 }
 
 struct Point { int x; int y; int z[]; }; // expected-warning{{flexible array members are a C99 feature}}
 
-Point p1 = { .x = 17, // expected-warning{{designated initializers are a C99 feature}}
-             y: 25 }; // expected-warning{{designated initializers are a C99 feature}} \
-                      // expected-warning{{use of GNU old-style field designator extension}}
+Point p1 = { .x = 17,
+             y: 25 }; // expected-warning{{use of GNU old-style field designator extension}}
+
+Point p2 = {
+  .x = 17, // expected-warning {{mixture of designated and non-designated initializers in the same initializer list is a C99 extension}}
+  25 // expected-note {{first non-designated initializer}}
+};
+
+Point p3 = {
+  .x = 17, // expected-note {{previous initialization is here}}
+  .x = 18, // expected-warning {{initializer overrides prior initialization of this subobject}}
+};
+
+Point p4 = {
+  .x = 17, // expected-warning {{mixture of designated and non-designated initializers in the same initializer list is a C99 extension}}
+  25, // expected-note {{first non-designated initializer}}
+  // expected-note@-1 {{previous initialization is here}}
+  .y = 18, // expected-warning {{initializer overrides prior initialization of this subobject}}
+};
+
+int arr[1] = {[0] = 0}; // expected-warning {{array designators are a C99 extension}}
+
+struct Pt { int x, y; };
+struct Rect { Pt tl, br; };
+Rect r = {
+  .tl.x = 0 // expected-warning {{nested designators are a C99 extension}}
+};
+
+struct NonTrivial {
+  NonTrivial();
+  ~NonTrivial();
+};
+struct S {
+  int a;
+  NonTrivial b;
+};
+struct T {
+  S s;
+};
+S f();
+
+T t1 = {
+  .s = f()
+};
+
+// It's important that we reject this; we would not destroy the existing
+// 'NonTrivial' object before overwriting it (and even calling its destructor
+// would not necessarily be correct).
+T t2 = {
+  .s = f(), // expected-note {{previous}}
+  .s.b = NonTrivial() // expected-error {{initializer would partially override prior initialization of object of type 'S' with non-trivial destruction}}
+  // expected-warning@-1 {{nested}}
+};
+
+// FIXME: It might be reasonable to accept this.
+T t3 = {
+  .s = f(), // expected-note {{previous}}
+  .s.a = 0 // expected-error {{initializer would partially override prior initialization of object of type 'S' with non-trivial destruction}}
+  // expected-warning@-1 {{nested}}
+};

cfe/trunk/test/SemaCXX/constant-expression-cxx11.cpp

-// RUN: %clang_cc1 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -fsyntax-only -fcxx-exceptions -verify -std=c++11 -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
+// RUN: %clang_cc1 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fsyntax-only -fcxx-exceptions -verify -std=c++11 -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
 
 namespace StaticAssertFoldTest {
 
 int x;
 static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
 static_assert(false, "test"); // expected-error {{test}}
 
 }

 
 constexpr int fail(const int &p) {
   return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}}
 }
 static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \
 expected-error {{static_assert expression is not an integral constant expression}} \
 expected-note {{in call to 'fail(zs[1][0][1][0])'}}
 
-constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}}
+constexpr int arr[40] = { 1, 2, 3, [8] = 4 };
 constexpr int SumNonzero(const int *p) {
   return *p + (*p ? SumNonzero(p+1) : 0);
 }
 constexpr int CountZero(const int *p, const int *q) {
   return p == q ? 0 : (*p == 0) + CountZero(p+1, q);
 }
 static_assert(SumNonzero(arr) == 6, "");
 static_assert(CountZero(arr, arr + 40) == 36, "");

 
 namespace Union {
 
 union U {
   int a;
   int b;
 };
 
-constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}}
+constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } };
 static_assert(u[0].a == 0, "");
 static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
 static_assert(u[1].b == 1, "");
 static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
 static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}}
 static_assert((&(u[1]) + 1 + 1)->b == 3, "");
 
 constexpr U v = {};

cfe/trunk/test/SemaCXX/constexpr-printing.cpp

constexpr int test_printing(int a, float b, _Complex int c, _Complex float d,
   return *e; // expected-note {{read of non-constexpr variable 'u2'}}
 }
 U u2(0); // expected-note {{here}}
 static_assert(test_printing(12, 39.762, 3 + 4i, 12.9 + 3.6i, &u2.arr[4], u2.another.arr[2], (vector_int){5, 1, 2, 3}, u1) == 0, ""); // \
 expected-error {{constant expression}} \
 expected-note {{in call to 'test_printing(12, 3.976200e+01, 3+4i, 1.290000e+01+3.600000e+00i, &u2.T::arr[4], u2.another.arr[2], {5, 1, 2, 3}, {{{}}, {{}}, &u1.T::arr[2]})'}}
 
 struct V {
-  // FIXME: when we can generate these as constexpr constructors, remove the
-  // explicit definitions.
-  constexpr V() : arr{[255] = 42} {}
-  constexpr V(const V &v) : arr{[255] = 42} {}
-  int arr[256];
+  int arr[256] = {[255] = 42}; // expected-warning {{C99}}
 };
 constexpr V v;
 constexpr int get(const int *p) { return *p; } // expected-note {{read of dereferenced one-past-the-end pointer}}
 constexpr int passLargeArray(V v) { return get(v.arr+256); } // expected-note {{in call to 'get(&v.arr[256])'}}
 static_assert(passLargeArray(v) == 0, ""); // expected-error {{constant expression}} expected-note {{in call to 'passLargeArray({{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...}})'}}
 
 union Union {
   constexpr Union(int n) : b(n) {}

cfe/trunk/test/SemaCXX/cxx0x-initializer-constructor.cpp

namespace PR11410 {
   struct C {
     C(int = 0); // expected-note 2{{candidate}}
     C(float = 0); // expected-note 2{{candidate}}
   };
   C c[3] = {
     0, 1
   }; // expected-error {{ambiguous}} expected-note {{in implicit initialization of array element 2}}
   C c2[3] = {
-    [0] = 1, [2] = 3
+    [0] = 1, [2] = 3 // expected-warning {{C99}}
   }; // expected-error {{ambiguous}} expected-note {{in implicit initialization of array element 1}}
 }

cfe/trunk/test/SemaCXX/cxx2a-initializer-aggregates.cpp

-// RUN: %clang_cc1 -std=c++2a %s -verify
+// RUN: %clang_cc1 -std=c++2a %s -verify=expected,pedantic,override,reorder -pedantic-errors
+// RUN: %clang_cc1 -std=c++2a %s -verify=expected,pedantic -Werror=c99-designator -Wno-reorder -Wno-initializer-overrides
+// RUN: %clang_cc1 -std=c++2a %s -verify=expected,reorder -Wno-c99-designator -Werror=reorder -Wno-initializer-overrides
+// RUN: %clang_cc1 -std=c++2a %s -verify=expected,override -Wno-c99-designator -Wno-reorder -Werror=initializer-overrides
+// RUN: %clang_cc1 -std=c++2a %s -verify -Wno-c99-designator -Wno-reorder -Wno-initializer-overrides
+
 
 namespace class_with_ctor {
   struct A { // expected-note 6{{candidate}}
     A() = default; // expected-note 3{{candidate}}
     int x;
     int y;
   };
   A a = {1, 2}; // expected-error {{no matching constructor}}
 
   struct B {
     int x;
     int y;
   };
   B b1 = B(); // trigger declaration of implicit ctors
   B b2 = {1, 2}; // ok
 
   struct C : A {
     A a;
   };
   C c1 = {{}, {}}; // ok, call default ctor twice
   C c2 = {{1, 2}, {3, 4}}; // expected-error 2{{no matching constructor}}
 }
+
+namespace designator {
+struct A { int x, y; };
+struct B { A a; };
+
+A a1 = {
+  .y = 1, // reorder-note {{previous initialization for field 'y' is here}}
+  .x = 2 // reorder-error {{ISO C++ requires field designators to be specified in declaration order; field 'y' will be initialized after field 'x'}}
+};
+int arr[3] = {[1] = 5}; // pedantic-error {{array designators are a C99 extension}}
+B b = {.a.x = 0}; // pedantic-error {{nested designators are a C99 extension}}
+A a2 = {
+  .x = 1, // pedantic-error {{mixture of designated and non-designated initializers in the same initializer list is a C99 extension}}
+  2 // pedantic-note {{first non-designated initializer is here}}
+};
+A a3 = {
+  1, // pedantic-note {{first non-designated initializer is here}}
+  .y = 2 // pedantic-error {{mixture of designated and non-designated initializers in the same initializer list is a C99 extension}}
+};
+A a4 = {
+  .x = 1, // override-note {{previous}}
+  .x = 1 // override-error {{overrides prior initialization}}
+};
+A a5 = {
+  .y = 1, // override-note {{previous}}
+  .y = 1 // override-error {{overrides prior initialization}}
+};
+struct C { int :0, x, :0, y, :0; };
+C c = {
+  .x = 1, // override-note {{previous}}
+  .x = 1, // override-error {{overrides prior initialization}} override-note {{previous}}
+  .y = 1, // override-note {{previous}}
+  .y = 1, // override-error {{overrides prior initialization}}
+  .x = 1, // reorder-error {{declaration order}} override-error {{overrides prior initialization}} override-note {{previous}}
+  .x = 1, // override-error {{overrides prior initialization}}
+};
+}
+
+namespace base_class {
+  struct base {
+    int x;
+  };
+  struct derived : base {
+    int y;
+  };
+  derived d = {.x = 1, .y = 2}; // expected-error {{'x' does not refer to any field}}
+}
+
+namespace union_ {
+  union U { int a, b; };
+  U u = {
+    .a = 1, // override-note {{here}}
+    .b = 2, // override-error {{overrides prior}}
+  };
+}
+
+namespace overload_resolution {
+  struct A { int x, y; };
+  union B { int x, y; };
+
+  void f(A a);
+  void f(B b) = delete;
+  void g() { f({.x = 1, .y = 2}); } // ok, calls non-union overload
+
+  // As an extension of the union case, overload resolution won't pick any
+  // candidate where a field initializer would be overridden.
+  struct A2 { int x, other, y; };
+  int f(A2);
+  void g2() { int k = f({.x = 1, 2, .y = 3}); (void)k; } // pedantic-error {{mixture of designated and non-designated}} pedantic-note {{here}}
+
+  struct C { int x; };
+  void h(A a); // expected-note {{candidate}}
+  void h(C c); // expected-note {{candidate}}
+  void i() {
+    h({.x = 1, .y = 2});
+    h({.y = 1, .x = 2}); // reorder-error {{declaration order}} reorder-note {{previous}}
+    h({.x = 1}); // expected-error {{ambiguous}}
+  }
+
+  struct D { int y, x; };
+  void j(A a); // expected-note {{candidate}}
+  void j(D d); // expected-note {{candidate}}
+  void k() {
+    j({.x = 1, .y = 2}); // expected-error {{ambiguous}}
+  }
+}
+
+namespace deduction {
+  struct A { int x, y; };
+  union B { int x, y; };
+
+  template<typename T, typename U> void f(decltype(T{.x = 1, .y = 2}) = {});
+  template<typename T, typename U> void f(decltype(U{.x = 1, .y = 2}) = {}) = delete;
+  void g() { f<A, B>(); } // ok, calls non-union overload
+
+  struct C { int y, x; };
+  template<typename T, typename U> void h(decltype(T{.y = 1, .x = 2}) = {}) = delete;
+  template<typename T, typename U> void h(decltype(U{.y = 1, .x = 2}) = {});
+  void i() {
+    h<A, C>(); // ok, selects C overload by SFINAE
+  }
+}

cfe/trunk/test/SemaCXX/decltype.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Wno-c99-designator %s
 
 // PR5290
 int const f0();
 void f0_test() {
   decltype(0, f0()) i = 0;
   i = 0;
 }
 
namespace PR18876 {
   decltype(0, A()) *d; // expected-error {{attempt to use a deleted function}}
   decltype(f(), 0) *e; // expected-error {{attempt to use a deleted function}}
 }
 
 namespace D5789 {
   struct P1 { char x[6]; } g1 = { "foo" };
   struct LP1 { struct P1 p1; };
 
-  // expected-warning@+3 {{subobject initialization overrides}}
+  // expected-warning@+3 {{initializer partially overrides}}
   // expected-note@+2 {{previous initialization}}
   // expected-note@+1 {{previous definition}}
   template<class T> void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'x' }))) {}
 
-  // expected-warning@+3 {{subobject initialization overrides}}
+  // expected-warning@+3 {{initializer partially overrides}}
   // expected-note@+2 {{previous initialization}}
   template<class T>
   void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'r' }))) {} // okay
 
-  // expected-warning@+3 {{subobject initialization overrides}}
+  // expected-warning@+3 {{initializer partially overrides}}
   // expected-note@+2 {{previous initialization}}
   template<class T>
   void foo(decltype(T(LP1{ .p1 = { "foo" }, .p1.x[1] = 'x'}))) {} // okay
 
-  // expected-warning@+3 {{subobject initialization overrides}}
+  // expected-warning@+3 {{initializer partially overrides}}
   // expected-note@+2 {{previous initialization}}
   // expected-error@+1 {{redefinition of 'foo'}}
   template<class T> void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'x' }))) {}
 }
 
 template<typename>
 class conditional {
 };
 
 void foo(conditional<decltype((1),int>) {  // expected-note 2 {{to match this '('}} expected-error {{expected ')'}}
 } // expected-error {{expected function body after function declarator}} expected-error 2 {{expected '>'}} expected-error {{expected ')'}}

cfe/trunk/test/SemaCXX/designated-initializers-base-class.cpp

 // RUN: %clang_cc1 %s -std=c++1z -fsyntax-only -verify -Winitializer-overrides
-// expected-no-diagnostics
 
 struct B {
   int x;
 };
 
 struct D : B {
   int y;
 };
 
-void test() { D d = {1, .y = 2}; }
+void test() { D d = {1, .y = 2}; } // expected-warning {{C99 extension}} expected-note {{}}

cfe/trunk/test/SemaCXX/designated-initializers.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Winitializer-overrides %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Woverride-init %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Wno-reorder -Wno-c99-designator -Winitializer-overrides %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Wno-reorder -Wno-c99-designator -Woverride-init %s
 
 template <typename T> struct Foo {
   struct SubFoo {
     int bar1;
     int bar2;
   };
 
   static void Test() { SubFoo sf = {.bar1 = 10, .bar2 = 20}; } // Expected no warning

cfe/trunk/test/SemaCXX/eval-crashes.cpp

namespace pr33140_2 {
   B b = {}; // expected-warning 2{{not supported}}
 }
 
 namespace pr33140_3 {
   typedef struct Y { unsigned int c; } Y_t;
   struct X {
     Y_t a;
   };
-  struct X foo[2] = {[0 ... 1] = {.a = (Y_t){.c = 0}}};
+  struct X foo[2] = {[0 ... 1] = {.a = (Y_t){.c = 0}}}; // expected-warning {{C99 extension}}
 }
 
 namespace pr33140_6 {
   struct Y { unsigned int c; };
   struct X { struct Y *p; };
   int f() {
     // FIXME: This causes clang to crash.
     //return (struct X[2]){ [0 ... 1] = { .p = &(struct Y&)(struct Y&&)(struct Y){0} } }[0].p->c;
     return 0;
   }
 }
 
 namespace pr33140_10 {
   int a(const int &n = 0);
   bool b() { return a() == a(); }
 }

cfe/trunk/test/SemaCXX/member-init.cpp

template<typename T> void f() {
   };
 }
 void g() { f<int>(); } // expected-note {{in instantiation of function template specialization 'local_class::f<int>' requested here}}
 }
 
 namespace PR22056 {
 template <int N>
 struct S {
-  int x[3] = {[N] = 3};
+  int x[3] = {[N] = 3}; // expected-warning {{C99 extension}}
 };
 }
 
 namespace PR28060 {
 template <class T>
 void foo(T v) {
   struct s {
     T *s = 0;
   };
 }
 template void foo(int);
 }

cfe/trunk/test/SemaObjCXX/message.mm

 #if __cplusplus <= 199711L
   // expected-warning@-2 {{'typename' occurs outside of a template}}
 #endif
 
   int* ip4 = {[typename identity<I2_holder>::type().get() method]};
 #if __cplusplus <= 199711L
   // expected-warning@-2 {{'typename' occurs outside of a template}}
 #endif
-  int array[5] = {[3] = 2};
+  int array[5] = {[3] = 2}; // expected-warning {{C99 extension}}
   return [super method];
 }
 @end
 
 struct String {
   String(const char *);
 };
 

cfe/trunk/test/SemaTemplate/instantiate-c99.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -Wno-c99-extensions -Wno-reorder -fsyntax-only -verify %s
+// RUN: %clang_cc1 -Wno-c99-extensions -Wno-reorder -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -Wno-c99-extensions -Wno-reorder -fsyntax-only -verify -std=c++11 %s
 
 // Test template instantiation for C99-specific features.
 
 // ---------------------------------------------------------------------
 // Designated initializers
 // ---------------------------------------------------------------------
 template<typename T, typename XType, typename YType>
 struct DesigInit0 {

cfe/trunk/test/SemaTemplate/instantiate-init.cpp

 }
 
 namespace InitListUpdate {
   struct A { int n; };
   using AA = A[1];
 
   // Check that an init list update doesn't "lose" the pack-ness of an expression.
   template <int... N> void f() {
-    g(AA{0, [0].n = N} ...); // expected-warning 3{{overrides prior init}} expected-note 3{{previous init}}
-    g(AA{N, [0].n = 0} ...); // expected-warning 3{{overrides prior init}} expected-note 3{{previous init}}
+    g(AA{0, [0].n = N} ...); // expected-warning 3{{extension}} expected-note {{here}} expected-warning 3{{overrides prior init}} expected-note 3{{previous init}}
+    g(AA{N, [0].n = 0} ...); // expected-warning 3{{extension}} expected-note {{here}} expected-warning 3{{overrides prior init}} expected-note 3{{previous init}}
   };
 
   void g(AA, AA);
   void h() { f<1, 2>(); } // expected-note {{instantiation of}}
 }