[Lldb-commits] [lldb] aee4925 - Recommit: Compress formatting of array type names (int [4] -> int[4])
David Blaikie via cfe-commits
cfe-commits at lists.llvm.org
Tue Oct 26 12:45:01 PDT 2021
On Tue, Oct 26, 2021 at 12:15 PM Raphael Isemann <teemperor at gmail.com>
wrote:
> Not sure how many LLDB users would (or can) write AST matchers though. And
> (lldb) type summary add "foo[4]" ...
> is arguably easier on the eyes than
> type summary add
>
> constantArrayType(allOf(hasSize(4),hasDeclaration(namedDecl(hasName("foo")))))`
>
Though presumably (& the example I think Jim was giving) more often the
desire would be to write a matcher for arrays of any dimension, where it's:
"foo[\d+]" or similar (maybe having to escape the "[]"
compared to
arrayType(hasElementType(hasDeclaration(cxxRecordDecl(hasName("foo")))))
Which is, admittedly, still pretty verbose. But more type checked (for
better and worse - annoying to get right (took me ages to figure out I
needed "hasDeclaration" in there) but more robust once it is right)
(that's my best shot at a good AST matcher, not sure if we could make
> this shorter, but that's probably what a user ends up with).
>
> In this case it seems just comparing tokens instead of direct strings
> is enough to make most users happy. And it doesn't require building
> clang ASTs (which is always expensive).
>
Yeah, as much as I like the abstract purity of structural comparison, token
comparison is probably close enough. (guess that has to involve LLDB
walking through typedefs incrementally, etc - if typedefs can be used in
pretty printer matching/searching, otherwise got to go strip out all the
typedefs (from the users regex (if they are allowed there) and from the
type of the thing being printed) and other sugar before comparison - guess
that's done today somewhere)
>
> Am Di., 26. Okt. 2021 um 20:04 Uhr schrieb David Blaikie <
> dblaikie at gmail.com>:
> >
> > On Tue, Oct 26, 2021 at 10:57 AM Jim Ingham <jingham at apple.com> wrote:
> >>
> >>
> >>
> >> > On Oct 26, 2021, at 10:43 AM, David Blaikie <dblaikie at gmail.com>
> wrote:
> >> >
> >> > On Tue, Oct 26, 2021 at 10:16 AM Jim Ingham <jingham at apple.com>
> wrote:
> >> >
> >> >
> >> > > On Oct 25, 2021, at 10:20 AM, David Blaikie via lldb-commits <
> lldb-commits at lists.llvm.org> wrote:
> >> > >
> >> > > On Fri, Oct 22, 2021 at 1:52 AM Raphael Isemann <
> teemperor at gmail.com> wrote:
> >> > > I think this is actually breaking some user-defined formatters for
> >> > > LLDB. The 'strong dependence' on type names comes from some parts of
> >> > > LLDB (such as formatters) that allow users to identify types by name
> >> > > and then associate some formater/summary/script with them. E.g.
> `type
> >> > > summary add "myfloat [4]" -s "vec quad"` will associate `myfloat
> [4]`
> >> > > with the provided summary. By changing the type name we also need to
> >> > > have all users update their lldb formatters and remove the space in
> >> > > their array type names. I don't think that's a deal breaker for this
> >> > > change, but it probably will save people some time if we put this
> into
> >> > > the release notes.
> >> > >
> >> > > Just the LLVM release notes (I don't see an lldb release notes
> doc)? Added some words here: 68cac47c26853ac7c7f3b4b12577779b75786000 (open
> to suggestions/rephrasing)
> >> > >
> >> > >
> >> > > FWIW, to allow type name readability improvements such as this one
> we
> >> > > have two names in LLDB: 'CompilerType::GetTypeName' and
> >> > > 'CompilerType::GetDisplayTypeName' (which in this case call into the
> >> > > `TypeSystemClang` implementations). The GetDisplayTypeName can be
> >> > > freely changed and is used to show types to users, the `GetTypeName`
> >> > > should stay fixed as it's the one that is primarily used for the
> >> > > formatter selection logic.
> >> > >
> >> > > It seemed like my change modified both of these - it caused
> failures in both gdb output printing types, and in pretty printer matching.
> Is that your understanding too? I guess we could add a PrintingPolicy to
> make the formatter selection name request a bug-for-bug naming preservation
> (have a "LLDBCanonicalNameStyle" attribute or something) as much as
> possible to reduce these sort of breakages?
> >> >
> >> > Another way to handle this would be to make a comparison operator
> that's smart enough to detect trivial differences in type name strings.
> That would also be useful for doing things like specifying breakpoints in
> overloaded methods, where you pretty much have to disassemble the mangled
> name and break on that exact resultant string because we don't have a smart
> equals operator. Seems like a compiler would have to be able to do this
> anyway, so there might be something in clang we can tap for this?
> >> >
> >> > I think Clang would do this by parsing the type names into structural
> descriptions (QualType, etc) then comparing those - not by fuzzy matching
> string to string more directly. So rather than a pretty printer specifying
> a regex, it could specify a type name in a string - that could get parsed
> into whatever lldb and/or clang internal representation is desired, then
> compared with parsed types from other places (parsed straight from DWARF
> without needing to convert it back into a string perhaps, etc).
> >> >
> >> >
> >>
> >> How much actual type knowledge does Clang have to have to do this? We
> do do comparisons on type names we get from runtime info, so we don't
> always have "real" type info.
> >
> >
> > Yeah, I don't think there would be any part of Clang setup to handle
> that situation.
> >
> >>
> >> OTOH, some of our regex matchers are used to express things like "an
> array of any number of char's".
> >
> >
> > That starts to sound more like a job for Clang's AST matchers:
> https://clang.llvm.org/docs/LibASTMatchersReference.html
> >
> >>
> >> It seems like we could instead do this with a smarter comparison and be
> clearer & hopefully more efficient...
> >>
> >> Jim
> >>
> >>
> >> > Jim
> >> >
> >> >
> >> > >
> >> > > Am Do., 21. Okt. 2021 um 23:38 Uhr schrieb David Blaikie <
> dblaikie at gmail.com>:
> >> > > >
> >> > > > On Thu, Oct 21, 2021 at 2:11 PM Raphael Isemann <
> teemperor at gmail.com> wrote:
> >> > > >>
> >> > > >> Both failures are unrelated to your patch from what I can see but
> >> > > >> instead caused by https://reviews.llvm.org/D111686
> >> > > >
> >> > > >
> >> > > > Ah, fair enough!
> >> > > >
> >> > > >>
> >> > > >>
> >> > > >>
> >> > > >> Am Do., 21. Okt. 2021 um 23:05 Uhr schrieb David Blaikie via
> >> > > >> lldb-commits <lldb-commits at lists.llvm.org>:
> >> > > >> >
> >> > > >> > On Thu, Oct 21, 2021 at 1:52 PM Nico Weber <
> thakis at chromium.org> wrote:
> >> > > >> >>
> >> > > >> >> The last such change broke Windows debuggers and we had to
> roll it back on Windows (https://reviews.llvm.org/D79274). Does this
> already not do this when targeting Windows?
> >> > > >> >
> >> > > >> >
> >> > > >> > No, this doesn't have a special case for Windows at the
> moment. I'd be a bit surprised if MSVC/Windows emitted and depended on
> being emitted, the space between "int" and "[N]", though it's possible. The
> template one is a bit more likely (I mean, even if we didn't know for sure,
> which we do now), I think.
> >> > > >> >
> >> > > >> > Is there any info on whether this has broken Windows debugging
> in some way?
> >> > > >> >
> >> > > >> > I think most of lldb's PDB testing is passing, though there
> are some failures I'm finding fairly inscrutable, in case folks have any
> extra details on what's going on here:
> https://lab.llvm.org/buildbot/#/builders/83/builds/11259/steps/7/logs/stdio
> >> > > >> >
> >> > > >> >>
> >> > > >> >>
> >> > > >> >> On Thu, Oct 21, 2021 at 2:35 PM David Blaikie via
> lldb-commits <lldb-commits at lists.llvm.org> wrote:
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> Author: David Blaikie
> >> > > >> >>> Date: 2021-10-21T11:34:43-07:00
> >> > > >> >>> New Revision: aee49255074fd4ef38d97e6e70cbfbf2f9fd0fa7
> >> > > >> >>>
> >> > > >> >>> URL:
> https://github.com/llvm/llvm-project/commit/aee49255074fd4ef38d97e6e70cbfbf2f9fd0fa7
> >> > > >> >>> DIFF:
> https://github.com/llvm/llvm-project/commit/aee49255074fd4ef38d97e6e70cbfbf2f9fd0fa7.diff
> >> > > >> >>>
> >> > > >> >>> LOG: Recommit: Compress formatting of array type names (int
> [4] -> int[4])
> >> > > >> >>>
> >> > > >> >>> Based on post-commit review discussion on
> >> > > >> >>> 2bd84938470bf2e337801faafb8a67710f46429d with Richard Smith.
> >> > > >> >>>
> >> > > >> >>> Other uses of forcing HasEmptyPlaceHolder to false seem OK
> to me -
> >> > > >> >>> they're all around pointer/reference types where the
> pointer/reference
> >> > > >> >>> token will appear at the rightmost side of the left side of
> the type
> >> > > >> >>> name, so they make nested types (eg: the "int" in "int *")
> behave as
> >> > > >> >>> though there is a non-empty placeholder (because the "*" is
> essentially
> >> > > >> >>> the placeholder as far as the "int" is concerned).
> >> > > >> >>>
> >> > > >> >>> This was originally committed in
> 277623f4d5a672d707390e2c3eaf30a9eb4b075c
> >> > > >> >>>
> >> > > >> >>> Reverted in f9ad1d1c775a8e264bebc15d75e0c6e5c20eefc7 due to
> breakages
> >> > > >> >>> outside of clang - lldb seems to have some strange/strong
> dependence on
> >> > > >> >>> "char [N]" versus "char[N]" when printing strings (not due
> to that name
> >> > > >> >>> appearing in DWARF, but probably due to using clang to
> stringify type
> >> > > >> >>> names) that'll need to be addressed, plus a few other odds
> and ends in
> >> > > >> >>> other subprojects (clang-tools-extra, compiler-rt, etc).
> >> > > >> >>>
> >> > > >> >>> Added:
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> Modified:
> >> > > >> >>>
> clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
> >> > > >> >>> clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
> >> > > >> >>> clang-tools-extra/clangd/unittests/HoverTests.cpp
> >> > > >> >>> clang/bindings/python/tests/cindex/test_type.py
> >> > > >> >>> clang/lib/AST/TypePrinter.cpp
> >> > > >> >>> clang/test/ARCMT/cxx-checking.mm
> >> > > >> >>> clang/test/AST/ast-dump-APValue-arithmetic.cpp
> >> > > >> >>> clang/test/AST/ast-dump-APValue-array.cpp
> >> > > >> >>> clang/test/AST/ast-dump-array.cpp
> >> > > >> >>> clang/test/AST/ast-dump-color.cpp
> >> > > >> >>> clang/test/AST/ast-dump-expr-json.c
> >> > > >> >>> clang/test/AST/ast-dump-expr-json.cpp
> >> > > >> >>> clang/test/AST/ast-dump-expr-json.m
> >> > > >> >>> clang/test/AST/ast-dump-expr.c
> >> > > >> >>> clang/test/AST/ast-dump-expr.cpp
> >> > > >> >>> clang/test/AST/ast-dump-file-line-json.c
> >> > > >> >>> clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
> >> > > >> >>> clang/test/AST/ast-dump-records-json.cpp
> >> > > >> >>> clang/test/AST/ast-dump-records.c
> >> > > >> >>> clang/test/AST/ast-dump-records.cpp
> >> > > >> >>> clang/test/AST/ast-dump-stmt-json.cpp
> >> > > >> >>> clang/test/AST/ast-dump-stmt.cpp
> >> > > >> >>> clang/test/AST/ast-dump-template-decls-json.cpp
> >> > > >> >>> clang/test/AST/ast-dump-templates.cpp
> >> > > >> >>> clang/test/AST/ast-dump-types-errors-json.cpp
> >> > > >> >>> clang/test/AST/atomic-expr.cpp
> >> > > >> >>> clang/test/AST/float16.cpp
> >> > > >> >>> clang/test/AST/pr47636.cpp
> >> > > >> >>> clang/test/AST/sourceranges.cpp
> >> > > >> >>> clang/test/ASTMerge/var/test.c
> >> > > >> >>> clang/test/Analysis/auto-obj-dtors-cfg-output.cpp
> >> > > >> >>> clang/test/Analysis/cfg.cpp
> >> > > >> >>> clang/test/Analysis/explain-svals.cpp
> >> > > >> >>> clang/test/Analysis/lifetime-cfg-output.cpp
> >> > > >> >>> clang/test/Analysis/malloc-sizeof.c
> >> > > >> >>> clang/test/Analysis/more-dtors-cfg-output.cpp
> >> > > >> >>> clang/test/Analysis/scopes-cfg-output.cpp
> >> > > >> >>> clang/test/CXX/basic/basic.types/p10.cpp
> >> > > >> >>> clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p7.cpp
> >> > > >> >>> clang/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp
> >> > > >> >>> clang/test/CXX/dcl.decl/dcl.decomp/p2.cpp
> >> > > >> >>> clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3.cpp
> >> > > >> >>> clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p3.cpp
> >> > > >> >>> clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp
> >> > > >> >>> clang/test/CXX/drs/dr177x.cpp
> >> > > >> >>> clang/test/CXX/expr/expr.prim/
> expr.prim.id/mixed-constraints.cpp
> >> > > >> >>> clang/test/CXX/expr/expr.prim/expr.prim.id/p4.cpp
> >> > > >> >>> clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp
> >> > > >> >>> clang/test/CXX/special/class.copy/p23-cxx11.cpp
> >> > > >> >>> clang/test/CXX/special/class.ctor/p5-0x.cpp
> >> > > >> >>> clang/test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp
> >> > > >> >>> clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
> >> > > >> >>>
> clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp
> >> > > >> >>> clang/test/CXX/temp/temp.decls/temp.variadic/p2.cpp
> >> > > >> >>> clang/test/CXX/temp/temp.explicit/p8.cpp
> >> > > >> >>> clang/test/CXX/temp/temp.param/p10-2a.cpp
> >> > > >> >>> clang/test/CodeGen/const-init.c
> >> > > >> >>> clang/test/CodeGen/dump-struct-builtin.c
> >> > > >> >>> clang/test/Import/array-init-loop-expr/test.cpp
> >> > > >> >>> clang/test/Index/print-type-size.cpp
> >> > > >> >>> clang/test/Index/print-type.c
> >> > > >> >>> clang/test/Index/print-type.cpp
> >> > > >> >>> clang/test/Layout/aix-Wpacked-expecting-diagnostics.cpp
> >> > > >> >>> clang/test/Layout/aix-double-struct-member.cpp
> >> > > >> >>> clang/test/Layout/aix-no-unique-address-with-double.cpp
> >> > > >> >>> clang/test/Layout/aix-power-alignment-typedef.cpp
> >> > > >> >>> clang/test/Layout/ms-aligned-array.c
> >> > > >> >>> clang/test/Layout/ms-x86-basic-layout.cpp
> >> > > >> >>> clang/test/Layout/ms-x86-empty-layout.c
> >> > > >> >>> clang/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
> >> > > >> >>> clang/test/Layout/ms-x86-empty-virtual-base.cpp
> >> > > >> >>> clang/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
> >> > > >> >>> clang/test/Layout/ms-x86-misalignedarray.cpp
> >> > > >> >>> clang/test/Layout/ms-x86-pack-and-align.cpp
> >> > > >> >>> clang/test/Layout/no-unique-address.cpp
> >> > > >> >>> clang/test/Layout/watchos-standard-layout.cpp
> >> > > >> >>> clang/test/Misc/diag-macro-backtrace2.c
> >> > > >> >>> clang/test/Misc/integer-literal-printing.cpp
> >> > > >> >>> clang/test/Modules/cxx-templates.cpp
> >> > > >> >>> clang/test/Modules/odr_hash.cpp
> >> > > >> >>> clang/test/OpenMP/distribute_firstprivate_messages.cpp
> >> > > >> >>>
> clang/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
> >> > > >> >>>
> clang/test/OpenMP/distribute_parallel_for_lastprivate_messages.cpp
> >> > > >> >>>
> clang/test/OpenMP/distribute_parallel_for_reduction_messages.cpp
> >> > > >> >>>
> clang/test/OpenMP/distribute_parallel_for_simd_shared_messages.cpp
> >> > > >> >>>
> clang/test/OpenMP/distribute_simd_firstprivate_messages.cpp
> >> > > >> >>>
> clang/test/OpenMP/distribute_simd_lastprivate_messages.cpp
> >> > > >> >>> clang/test/OpenMP/distribute_simd_reduction_messages.cpp
> >> > > >> >>> clang/test/OpenMP/parallel_reduction_messages.c
> >> > > >> >>>
> clang/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
> >> > > >> >>> clang/test/PCH/objc_exprs.m
> >> > > >> >>> clang/test/Parser/atomic.c
> >> > > >> >>> clang/test/Sema/array-constraint.c
> >> > > >> >>> clang/test/Sema/array-init.c
> >> > > >> >>> clang/test/Sema/assign.c
> >> > > >> >>> clang/test/Sema/builtin-expect-with-probability-avr.cpp
> >> > > >> >>> clang/test/Sema/builtin-expect-with-probability.cpp
> >> > > >> >>> clang/test/Sema/c11-typedef-redef.c
> >> > > >> >>> clang/test/Sema/compound-literal.c
> >> > > >> >>> clang/test/Sema/crash-invalid-array.c
> >> > > >> >>> clang/test/Sema/empty1.c
> >> > > >> >>> clang/test/Sema/extern-redecl.c
> >> > > >> >>> clang/test/Sema/generic-selection.c
> >> > > >> >>> clang/test/Sema/gnu-flags.c
> >> > > >> >>> clang/test/Sema/incomplete-decl.c
> >> > > >> >>> clang/test/Sema/matrix-type-builtins.c
> >> > > >> >>> clang/test/Sema/merge-decls.c
> >> > > >> >>> clang/test/Sema/nullability.c
> >> > > >> >>> clang/test/Sema/predef.c
> >> > > >> >>> clang/test/Sema/typedef-retain.c
> >> > > >> >>> clang/test/Sema/types.c
> >> > > >> >>> clang/test/Sema/var-redecl.c
> >> > > >> >>> clang/test/Sema/vla.cpp
> >> > > >> >>> clang/test/Sema/warn-sizeof-array-decay.c
> >> > > >> >>> clang/test/Sema/warn-sizeof-arrayarg.c
> >> > > >> >>> clang/test/Sema/warn-write-strings.c
> >> > > >> >>> clang/test/SemaCXX/MicrosoftExtensions.cpp
> >> > > >> >>> clang/test/SemaCXX/address-space-initialize.cpp
> >> > > >> >>> clang/test/SemaCXX/alias-template.cpp
> >> > > >> >>> clang/test/SemaCXX/array-bound-merge.cpp
> >> > > >> >>> clang/test/SemaCXX/attr-gnu.cpp
> >> > > >> >>> clang/test/SemaCXX/c99-variable-length-array-cxx11.cpp
> >> > > >> >>> clang/test/SemaCXX/c99-variable-length-array.cpp
> >> > > >> >>> clang/test/SemaCXX/compare-cxx2a.cpp
> >> > > >> >>> clang/test/SemaCXX/constant-expression-cxx11.cpp
> >> > > >> >>> clang/test/SemaCXX/constant-expression-cxx2a.cpp
> >> > > >> >>> clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
> >> > > >> >>> clang/test/SemaCXX/constexpr-string.cpp
> >> > > >> >>> clang/test/SemaCXX/coroutines.cpp
> >> > > >> >>> clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp
> >> > > >> >>> clang/test/SemaCXX/cxx0x-type-convert-construct.cpp
> >> > > >> >>> clang/test/SemaCXX/cxx1z-decomposition.cpp
> >> > > >> >>> clang/test/SemaCXX/cxx2a-compat.cpp
> >> > > >> >>> clang/test/SemaCXX/dcl_init_aggr.cpp
> >> > > >> >>> clang/test/SemaCXX/decl-init-ref.cpp
> >> > > >> >>> clang/test/SemaCXX/exceptions.cpp
> >> > > >> >>> clang/test/SemaCXX/flexible-array-test.cpp
> >> > > >> >>> clang/test/SemaCXX/for-range-examples.cpp
> >> > > >> >>> clang/test/SemaCXX/new-delete.cpp
> >> > > >> >>> clang/test/SemaCXX/no-wchar.cpp
> >> > > >> >>> clang/test/SemaCXX/nullability.cpp
> >> > > >> >>> clang/test/SemaCXX/overload-call.cpp
> >> > > >> >>> clang/test/SemaCXX/overload-member-call.cpp
> >> > > >> >>> clang/test/SemaCXX/static-assert-cxx17.cpp
> >> > > >> >>> clang/test/SemaCXX/typedef-redecl.cpp
> >> > > >> >>> clang/test/SemaCXX/typeid.cpp
> >> > > >> >>> clang/test/SemaCXX/warn-string-conversion.cpp
> >> > > >> >>> clang/test/SemaObjC/argument-checking.m
> >> > > >> >>> clang/test/SemaObjC/flexible-array.m
> >> > > >> >>> clang/test/SemaObjC/ivar-sem-check-1.m
> >> > > >> >>> clang/test/SemaObjC/method-bad-param.m
> >> > > >> >>> clang/test/SemaObjC/nullability.m
> >> > > >> >>> clang/test/SemaObjC/rdr-6211479-array-property.m
> >> > > >> >>> clang/test/SemaObjC/warn-write-strings.m
> >> > > >> >>> clang/test/SemaObjCXX/message.mm
> >> > > >> >>> clang/test/SemaOpenCL/half.cl
> >> > > >> >>> clang/test/SemaOpenCL/invalid-kernel-parameters.cl
> >> > > >> >>> clang/test/SemaOpenCL/predefined-expr.cl
> >> > > >> >>> clang/test/SemaOpenCLCXX/address-space-deduction.clcpp
> >> > > >> >>> clang/test/SemaTemplate/deduction-guide.cpp
> >> > > >> >>> clang/test/SemaTemplate/instantiate-init.cpp
> >> > > >> >>> clang/test/SemaTemplate/instantiate-local-class.cpp
> >> > > >> >>> clang/test/SemaTemplate/instantiate-static-var.cpp
> >> > > >> >>> clang/test/SemaTemplate/pack-deduction.cpp
> >> > > >> >>> clang/test/SemaTemplate/temp_arg_nontype.cpp
> >> > > >> >>> clang/unittests/AST/ASTImporterTest.cpp
> >> > > >> >>> clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> >> > > >> >>> clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
> >> > > >> >>> compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp
> >> > > >> >>>
> libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
> >> > > >> >>>
> libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
> >> > > >> >>>
> libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
> >> > > >> >>> lldb/source/Commands/CommandObjectType.cpp
> >> > > >> >>> lldb/source/DataFormatters/FormatManager.cpp
> >> > > >> >>>
> lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
> >> > > >> >>>
> lldb/test/API/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py
> >> > > >> >>>
> lldb/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
> >> > > >> >>>
> lldb/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py
> >> > > >> >>>
> lldb/test/API/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
> >> > > >> >>>
> lldb/test/API/functionalities/data-formatter/typedef_array/main.cpp
> >> > > >> >>> lldb/test/API/lang/c/array_types/TestArrayTypes.py
> >> > > >> >>> lldb/test/API/lang/c/vla/TestVLA.py
> >> > > >> >>> lldb/test/API/lang/cpp/bitfields/TestCppBitfields.py
> >> > > >> >>> lldb/test/API/lang/cpp/char1632_t/TestChar1632T.py
> >> > > >> >>> lldb/test/API/lang/cpp/char8_t/TestCxxChar8_t.py
> >> > > >> >>>
> lldb/test/API/lang/cpp/class_static/TestStaticVariables.py
> >> > > >> >>>
> lldb/test/API/lang/cpp/non-type-template-param/TestCppNonTypeTemplateParam.py
> >> > > >> >>>
> lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py
> >> > > >> >>> lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_const_value.s
> >> > > >> >>> lldb/test/Shell/SymbolFile/DWARF/x86/array-sizes.s
> >> > > >> >>> lldb/test/Shell/SymbolFile/NativePDB/global-classes.cpp
> >> > > >> >>>
> >> > > >> >>> Removed:
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>>
> ################################################################################
> >> > > >> >>> diff --git
> a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
> b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
> >> > > >> >>> index 6955fa0caa250..b3eaae69c7518 100644
> >> > > >> >>> ---
> a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
> >> > > >> >>> +++
> b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
> >> > > >> >>> @@ -131,7 +131,7 @@ TEST_F(LSPTest, Diagnostics) {
> >> > > >> >>> EXPECT_THAT(Client.diagnostics("foo.cpp"),
> >> > > >> >>> llvm::ValueIs(testing::ElementsAre(
> >> > > >> >>> DiagMessage("Cannot initialize a variable
> of type 'int' with "
> >> > > >> >>> - "an lvalue of type 'const
> char [3]'"))));
> >> > > >> >>> + "an lvalue of type 'const
> char[3]'"))));
> >> > > >> >>>
> >> > > >> >>> Client.didClose("foo.cpp");
> >> > > >> >>> EXPECT_THAT(Client.diagnostics("foo.cpp"),
> llvm::ValueIs(testing::IsEmpty()));
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
> b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
> >> > > >> >>> index d4450b31e5f38..45e55585ad5d0 100644
> >> > > >> >>> --- a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
> >> > > >> >>> +++ b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
> >> > > >> >>> @@ -181,7 +181,7 @@ o]]();
> >> > > >> >>> Diag(Test.range("unk"), "use of undeclared
> identifier 'unknown'"),
> >> > > >> >>> Diag(Test.range("type"),
> >> > > >> >>> "cannot initialize a variable of type
> 'double' with an lvalue "
> >> > > >> >>> - "of type 'const char [4]'"),
> >> > > >> >>> + "of type 'const char[4]'"),
> >> > > >> >>> Diag(Test.range("nomember"), "no member named 'y'
> in 'Foo'"),
> >> > > >> >>> Diag(Test.range("nomembernamespace"),
> >> > > >> >>> "no member named 'test' in namespace
> 'test'"),
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang-tools-extra/clangd/unittests/HoverTests.cpp
> b/clang-tools-extra/clangd/unittests/HoverTests.cpp
> >> > > >> >>> index 72efe5ab6ad87..6395da91463ae 100644
> >> > > >> >>> --- a/clang-tools-extra/clangd/unittests/HoverTests.cpp
> >> > > >> >>> +++ b/clang-tools-extra/clangd/unittests/HoverTests.cpp
> >> > > >> >>> @@ -899,7 +899,7 @@ class Foo {})cpp";
> >> > > >> >>> [](HoverInfo &HI) {
> >> > > >> >>> HI.Name = "expression";
> >> > > >> >>> HI.Kind = index::SymbolKind::Unknown;
> >> > > >> >>> - HI.Type = "int [10]";
> >> > > >> >>> + HI.Type = "int[10]";
> >> > > >> >>> HI.Value = "{1}";
> >> > > >> >>> }}};
> >> > > >> >>> for (const auto &Case : Cases) {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/bindings/python/tests/cindex/test_type.py
> b/clang/bindings/python/tests/cindex/test_type.py
> >> > > >> >>> index bcdbeff9d99c4..0ef98e9555be2 100644
> >> > > >> >>> --- a/clang/bindings/python/tests/cindex/test_type.py
> >> > > >> >>> +++ b/clang/bindings/python/tests/cindex/test_type.py
> >> > > >> >>> @@ -175,10 +175,10 @@ def test_type_spelling(self):
> >> > > >> >>> self.assertIsNotNone(i)
> >> > > >> >>> self.assertIsNotNone(x)
> >> > > >> >>> self.assertIsNotNone(v)
> >> > > >> >>> - self.assertEqual(c.type.spelling, "int [5]")
> >> > > >> >>> - self.assertEqual(i.type.spelling, "int []")
> >> > > >> >>> + self.assertEqual(c.type.spelling, "int[5]")
> >> > > >> >>> + self.assertEqual(i.type.spelling, "int[]")
> >> > > >> >>> self.assertEqual(x.type.spelling, "int")
> >> > > >> >>> - self.assertEqual(v.type.spelling, "int [x]")
> >> > > >> >>> + self.assertEqual(v.type.spelling, "int[x]")
> >> > > >> >>>
> >> > > >> >>> def test_typekind_spelling(self):
> >> > > >> >>> """Ensure TypeKind.spelling works."""
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/lib/AST/TypePrinter.cpp
> b/clang/lib/AST/TypePrinter.cpp
> >> > > >> >>> index e573037db10e5..cceed1ca26f33 100644
> >> > > >> >>> --- a/clang/lib/AST/TypePrinter.cpp
> >> > > >> >>> +++ b/clang/lib/AST/TypePrinter.cpp
> >> > > >> >>> @@ -503,7 +503,6 @@ void
> TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
> >> > > >> >>> void TypePrinter::printConstantArrayBefore(const
> ConstantArrayType *T,
> >> > > >> >>> raw_ostream &OS)
> {
> >> > > >> >>> IncludeStrongLifetimeRAII Strong(Policy);
> >> > > >> >>> - SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder,
> false);
> >> > > >> >>> printBefore(T->getElementType(), OS);
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -526,7 +525,6 @@ void
> TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
> >> > > >> >>> void TypePrinter::printIncompleteArrayBefore(const
> IncompleteArrayType *T,
> >> > > >> >>> raw_ostream
> &OS) {
> >> > > >> >>> IncludeStrongLifetimeRAII Strong(Policy);
> >> > > >> >>> - SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder,
> false);
> >> > > >> >>> printBefore(T->getElementType(), OS);
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -539,7 +537,6 @@ void
> TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
> >> > > >> >>> void TypePrinter::printVariableArrayBefore(const
> VariableArrayType *T,
> >> > > >> >>> raw_ostream &OS)
> {
> >> > > >> >>> IncludeStrongLifetimeRAII Strong(Policy);
> >> > > >> >>> - SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder,
> false);
> >> > > >> >>> printBefore(T->getElementType(), OS);
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -586,7 +583,6 @@ void
> TypePrinter::printDependentSizedArrayBefore(
> >> > > >> >>> const
> DependentSizedArrayType *T,
> >> > > >> >>> raw_ostream
> &OS) {
> >> > > >> >>> IncludeStrongLifetimeRAII Strong(Policy);
> >> > > >> >>> - SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder,
> false);
> >> > > >> >>> printBefore(T->getElementType(), OS);
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/ARCMT/cxx-checking.mm
> b/clang/test/ARCMT/cxx-checking.mm
> >> > > >> >>> index d6441def09b40..f8836d9d7cd8d 100644
> >> > > >> >>> --- a/clang/test/ARCMT/cxx-checking.mm
> >> > > >> >>> +++ b/clang/test/ARCMT/cxx-checking.mm
> >> > > >> >>> @@ -80,7 +80,7 @@
> >> > > >> >>>
> >> > > >> >>> struct FlexibleArrayMember0 {
> >> > > >> >>> int length;
> >> > > >> >>> - id array[]; // expected-error{{flexible array member
> 'array' of type '__strong id []' with non-trivial destruction}}
> >> > > >> >>> + id array[]; // expected-error{{flexible array member
> 'array' of type '__strong id[]' with non-trivial destruction}}
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> struct FlexibleArrayMember1 {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-APValue-arithmetic.cpp
> b/clang/test/AST/ast-dump-APValue-arithmetic.cpp
> >> > > >> >>> index e51c1cee04cfe..c474e4be0e8c7 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-APValue-arithmetic.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-APValue-arithmetic.cpp
> >> > > >> >>> @@ -36,13 +36,13 @@ void Test() {
> >> > > >> >>> // CHECK-NEXT: | |-value: ComplexFloat 3.141500e+00 +
> 4.200000e+01i
> >> > > >> >>>
> >> > > >> >>> constexpr _Complex int ArrayOfComplexInt[10] =
> {ComplexInt, ComplexInt, ComplexInt, ComplexInt};
> >> > > >> >>> - // CHECK: | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} ArrayOfComplexInt 'const _Complex int [10]' constexpr cinit
> >> > > >> >>> + // CHECK: | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} ArrayOfComplexInt 'const _Complex int[10]' constexpr cinit
> >> > > >> >>> // CHECK-NEXT: | |-value: Array size=10
> >> > > >> >>> // CHECK-NEXT: | | |-elements: ComplexInt 42 + 24i,
> ComplexInt 42 + 24i, ComplexInt 42 + 24i, ComplexInt 42 + 24i
> >> > > >> >>> // CHECK-NEXT: | | `-filler: 6 x ComplexInt 0 + 0i
> >> > > >> >>>
> >> > > >> >>> constexpr _Complex float ArrayOfComplexFloat[10] =
> {ComplexFloat, ComplexFloat, ComplexInt, ComplexInt};
> >> > > >> >>> - // CHECK: `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} ArrayOfComplexFloat 'const _Complex float [10]' constexpr cinit
> >> > > >> >>> + // CHECK: `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} ArrayOfComplexFloat 'const _Complex float[10]' constexpr cinit
> >> > > >> >>> // CHECK-NEXT: |-value: Array size=10
> >> > > >> >>> // CHECK-NEXT: | |-elements: ComplexFloat
> 3.141500e+00 + 4.200000e+01i, ComplexFloat 3.141500e+00 + 4.200000e+01i,
> ComplexFloat 4.200000e+01 + 2.400000e+01i, ComplexFloat 4.200000e+01 +
> 2.400000e+01i
> >> > > >> >>> // CHECK-NEXT: | `-filler: 6 x ComplexFloat
> 0.000000e+00 + 0.000000e+00i
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-APValue-array.cpp
> b/clang/test/AST/ast-dump-APValue-array.cpp
> >> > > >> >>> index 72e519208ac56..d5fc521da448e 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-APValue-array.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-APValue-array.cpp
> >> > > >> >>> @@ -43,7 +43,7 @@ void Test() {
> >> > > >> >>> constexpr float arr_f[3][5] = {
> >> > > >> >>> {1, 2, 3, 4, 5},
> >> > > >> >>> };
> >> > > >> >>> - // CHECK: | `-VarDecl {{.*}} <line:{{.*}}, line:{{.*}}>
> line:{{.*}} arr_f 'const float [3][5]' constexpr cinit
> >> > > >> >>> + // CHECK: | `-VarDecl {{.*}} <line:{{.*}}, line:{{.*}}>
> line:{{.*}} arr_f 'const float[3][5]' constexpr cinit
> >> > > >> >>> // CHECK-NEXT: | |-value: Array size=3
> >> > > >> >>> // CHECK-NEXT: | | |-element: Array size=5
> >> > > >> >>> // CHECK-NEXT: | | | |-elements: Float 1.000000e+00,
> Float 2.000000e+00, Float 3.000000e+00, Float 4.000000e+00
> >> > > >> >>> @@ -52,7 +52,7 @@ void Test() {
> >> > > >> >>> // CHECK-NEXT: | | `-filler: 5 x Float 0.000000e+00
> >> > > >> >>>
> >> > > >> >>> constexpr S0 arr_s0[2] = {{1, 2}, {3, 4}};
> >> > > >> >>> - // CHECK: | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} arr_s0 'const S0 [2]' constexpr cinit
> >> > > >> >>> + // CHECK: | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} arr_s0 'const S0[2]' constexpr cinit
> >> > > >> >>> // CHECK-NEXT: | |-value: Array size=2
> >> > > >> >>> // CHECK-NEXT: | | |-element: Struct
> >> > > >> >>> // CHECK-NEXT: | | | `-field: Array size=2
> >> > > >> >>> @@ -62,12 +62,12 @@ void Test() {
> >> > > >> >>> // CHECK-NEXT: | | `-elements: Int 3, Int 4
> >> > > >> >>>
> >> > > >> >>> constexpr U0 arr_u0[2] = {{.i = 42}, {.f = 3.1415f}};
> >> > > >> >>> - // CHECK: | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} arr_u0 'const U0 [2]' constexpr cinit
> >> > > >> >>> + // CHECK: | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} arr_u0 'const U0[2]' constexpr cinit
> >> > > >> >>> // CHECK-NEXT: | |-value: Array size=2
> >> > > >> >>> // CHECK-NEXT: | | `-elements: Union .i Int 42, Union
> .f Float 3.141500e+00
> >> > > >> >>>
> >> > > >> >>> constexpr S1 arr_s1[2] = {};
> >> > > >> >>> - // CHECK: `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} arr_s1 'const S1 [2]' constexpr cinit
> >> > > >> >>> + // CHECK: `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}>
> col:{{.*}} arr_s1 'const S1[2]' constexpr cinit
> >> > > >> >>> // CHECK-NEXT: |-value: Array size=2
> >> > > >> >>> // CHECK-NEXT: | |-element: Struct
> >> > > >> >>> // CHECK-NEXT: | | |-field: Struct
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-array.cpp
> b/clang/test/AST/ast-dump-array.cpp
> >> > > >> >>> index 2e94f7769e0bd..609ad31a0e420 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-array.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-array.cpp
> >> > > >> >>> @@ -13,7 +13,7 @@ void testArrayInitExpr()
> >> > > >> >>> int a[10];
> >> > > >> >>> auto l = [a]{
> >> > > >> >>> };
> >> > > >> >>> - // CHECK: |-ArrayInitLoopExpr 0x{{[^ ]*}} <col:15> 'int
> [10]'
> >> > > >> >>> + // CHECK: |-ArrayInitLoopExpr 0x{{[^ ]*}} <col:15>
> 'int[10]'
> >> > > >> >>> // CHECK: | `-ArrayInitIndexExpr 0x{{[^ ]*}}
> <<invalid sloc>> 'unsigned long'
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -22,7 +22,7 @@ class array {
> >> > > >> >>> T data[Size];
> >> > > >> >>>
> >> > > >> >>> using array_T_size = T[Size];
> >> > > >> >>> - // CHECK: `-DependentSizedArrayType 0x{{[^ ]*}} 'T
> [Size]' dependent <col:25, col:30>
> >> > > >> >>> + // CHECK: `-DependentSizedArrayType 0x{{[^ ]*}} 'T[Size]'
> dependent <col:25, col:30>
> >> > > >> >>> using const_array_T_size = const T[Size];
> >> > > >> >>> - // CHECK: `-DependentSizedArrayType 0x{{[^ ]*}} 'const T
> [Size]' dependent <col:37, col:42>
> >> > > >> >>> + // CHECK: `-DependentSizedArrayType 0x{{[^ ]*}} 'const
> T[Size]' dependent <col:37, col:42>
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-color.cpp
> b/clang/test/AST/ast-dump-color.cpp
> >> > > >> >>> index baaf9729c7ce7..87797f6bffc5b 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-color.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-color.cpp
> >> > > >> >>> @@ -32,7 +32,7 @@ struct Invalid {
> >> > > >> >>> //CHECK:
> {{^}}[[GREEN:.\[0;1;32m]]TranslationUnitDecl[[RESET:.\[0m]][[Yellow:.\[0;33m]]
> 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]>
> [[Yellow]]<invalid sloc>[[RESET]]{{$}}
> >> > > >> >>> //CHECK:
> {{^}}[[Blue:.\[0;34m]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]]
> 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]>
> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN:.\[0;1;36m]]
> __int128_t[[RESET]] [[Green:.\[0;32m]]'__int128'[[RESET]]{{$}}
> >> > > >> >>> //CHECK:
> {{^}}[[Blue]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]]
> 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]>
> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN]] __uint128_t[[RESET]]
> [[Green]]'unsigned __int128'[[RESET]]{{$}}
> >> > > >> >>> -//CHECK:
> {{^}}[[Blue]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]]
> 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]>
> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN]]
> __builtin_va_list[[RESET]] [[Green]]'__va_list_tag [1]'[[RESET]]{{$}}
> >> > > >> >>> +//CHECK:
> {{^}}[[Blue]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]]
> 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]>
> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN]]
> __builtin_va_list[[RESET]] [[Green]]'__va_list_tag[1]'[[RESET]]{{$}}
> >> > > >> >>> //CHECK:
> {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]]
> 0x{{[0-9a-fA-F]*}}[[RESET]]
> <[[Yellow]]{{.*}}ast-dump-color.cpp:6:1[[RESET]], [[Yellow]]col:5[[RESET]]>
> [[Yellow]]col:5[[RESET]][[CYAN]] Test[[RESET]] [[Green]]'int'[[RESET]]
> >> > > >> >>> //CHECK: {{^}}[[Blue]]|
> |-[[RESET]][[BLUE:.\[0;1;34m]]UnusedAttr[[RESET]][[Yellow]]
> 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:25[[RESET]]> unused{{$}}
> >> > > >> >>> //CHECK: {{^}}[[Blue]]|
> `-[[RESET]][[Blue]]FullComment[[RESET]][[Yellow]]
> 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:4:4[[RESET]],
> [[Yellow]]line:5:8[[RESET]]>{{$}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-expr-json.c
> b/clang/test/AST/ast-dump-expr-json.c
> >> > > >> >>> index 3e288b9f0e706..c322625cb2b2a 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-expr-json.c
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-expr-json.c
> >> > > >> >>> @@ -4689,7 +4689,7 @@ void PrimaryExpressions(int a) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>> @@ -4709,7 +4709,7 @@ void PrimaryExpressions(int a) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "prvalue",
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>> @@ -5106,7 +5106,7 @@ void PrimaryExpressions(int a) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [2]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[2]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "\"a\""
> >> > > >> >>> @@ -5151,7 +5151,7 @@ void PrimaryExpressions(int a) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [2]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[2]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "L\"a\""
> >> > > >> >>> @@ -5196,7 +5196,7 @@ void PrimaryExpressions(int a) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [2]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[2]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "u8\"a\""
> >> > > >> >>> @@ -5241,7 +5241,7 @@ void PrimaryExpressions(int a) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "unsigned int [2]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "unsigned int[2]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "U\"a\""
> >> > > >> >>> @@ -5286,7 +5286,7 @@ void PrimaryExpressions(int a) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "unsigned short [2]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "unsigned short[2]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "u\"a\""
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-expr-json.cpp
> b/clang/test/AST/ast-dump-expr-json.cpp
> >> > > >> >>> index b9c66b0fc90ec..3ef2f78551b67 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-expr-json.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-expr-json.cpp
> >> > > >> >>> @@ -2003,7 +2003,7 @@ void TestNonADLCall3() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [2]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[2]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "prvalue",
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-expr-json.m
> b/clang/test/AST/ast-dump-expr-json.m
> >> > > >> >>> index 9b30c5957e3b3..062f6c06d1aa7 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-expr-json.m
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-expr-json.m
> >> > > >> >>> @@ -181,7 +181,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [2]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[2]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "encodedType": {
> >> > > >> >>> @@ -228,7 +228,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [3]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[3]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "encodedType": {
> >> > > >> >>> @@ -3490,7 +3490,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "\"key\""
> >> > > >> >>> @@ -3698,7 +3698,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "\"key\""
> >> > > >> >>> @@ -4177,7 +4177,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "\"key\""
> >> > > >> >>> @@ -4420,7 +4420,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "\"key\""
> >> > > >> >>> @@ -4560,7 +4560,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "\"key\""
> >> > > >> >>> @@ -4745,7 +4745,7 @@ void TestObjCBoolLiteral() {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "char [4]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "char[4]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "value": "\"key\""
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-expr.c
> b/clang/test/AST/ast-dump-expr.c
> >> > > >> >>> index 1cb8ceaafbd0f..8605cd4bbaa16 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-expr.c
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-expr.c
> >> > > >> >>> @@ -271,8 +271,8 @@ void PostfixOperators(int *a, struct S
> b, struct S *c) {
> >> > > >> >>>
> >> > > >> >>> (int [4]){1, 2, 3, 4, };
> >> > > >> >>> // CHECK: ImplicitCastExpr
> >> > > >> >>> - // CHECK-NEXT: CompoundLiteralExpr 0x{{[^ ]*}} <col:3,
> col:25> 'int [4]' lvalue
> >> > > >> >>> - // CHECK-NEXT: InitListExpr 0x{{[^ ]*}} <col:12, col:25>
> 'int [4]'
> >> > > >> >>> + // CHECK-NEXT: CompoundLiteralExpr 0x{{[^ ]*}} <col:3,
> col:25> 'int[4]' lvalue
> >> > > >> >>> + // CHECK-NEXT: InitListExpr 0x{{[^ ]*}} <col:12, col:25>
> 'int[4]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:13> 'int' 1
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:16> 'int' 2
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:19> 'int' 3
> >> > > >> >>> @@ -300,23 +300,23 @@ void PrimaryExpressions(int a) {
> >> > > >> >>>
> >> > > >> >>> "a";
> >> > > >> >>> // ImplicitCastExpr
> >> > > >> >>> - // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'char [2]'
> lvalue "a"
> >> > > >> >>> + // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'char[2]'
> lvalue "a"
> >> > > >> >>>
> >> > > >> >>> L"a";
> >> > > >> >>> // ImplicitCastExpr
> >> > > >> >>> - // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'int [2]'
> lvalue L"a"
> >> > > >> >>> + // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'int[2]'
> lvalue L"a"
> >> > > >> >>>
> >> > > >> >>> u8"a";
> >> > > >> >>> // ImplicitCastExpr
> >> > > >> >>> - // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'char [2]'
> lvalue u8"a"
> >> > > >> >>> + // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'char[2]'
> lvalue u8"a"
> >> > > >> >>>
> >> > > >> >>> U"a";
> >> > > >> >>> // ImplicitCastExpr
> >> > > >> >>> - // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'unsigned int
> [2]' lvalue U"a"
> >> > > >> >>> + // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'unsigned
> int[2]' lvalue U"a"
> >> > > >> >>>
> >> > > >> >>> u"a";
> >> > > >> >>> // ImplicitCastExpr
> >> > > >> >>> - // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'unsigned
> short [2]' lvalue u"a"
> >> > > >> >>> + // CHECK: StringLiteral 0x{{[^ ]*}} <col:3> 'unsigned
> short[2]' lvalue u"a"
> >> > > >> >>>
> >> > > >> >>> 1;
> >> > > >> >>> // CHECK: IntegerLiteral 0x{{[^ ]*}} <line:[[@LINE-1]]:3>
> 'int' 1
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-expr.cpp
> b/clang/test/AST/ast-dump-expr.cpp
> >> > > >> >>> index 747a6a5cd539b..8b890860e2e32 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-expr.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-expr.cpp
> >> > > >> >>> @@ -147,7 +147,7 @@ void UnaryExpressions(int *p) {
> >> > > >> >>> // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:18> 'int *' array Function 0x{{[^ ]*}} 'operator new[]' 'void
> *(unsigned long)'
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 2
> >> > > >> >>> - // CHECK-NEXT: InitListExpr 0x{{[^ ]*}} <col:13, col:18>
> 'int [2]'
> >> > > >> >>> + // CHECK-NEXT: InitListExpr 0x{{[^ ]*}} <col:13, col:18>
> 'int[2]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:14> 'int' 1
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:17> 'int' 2
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-file-line-json.c
> b/clang/test/AST/ast-dump-file-line-json.c
> >> > > >> >>> index e2bc038b462e7..d4899d8fbbe96 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-file-line-json.c
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-file-line-json.c
> >> > > >> >>> @@ -137,14 +137,14 @@ int e;
> >> > > >> >>> // CHECK-NEXT: "isImplicit": true,
> >> > > >> >>> // CHECK-NEXT: "name": "__builtin_va_list",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "struct __va_list_tag [1]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "struct __va_list_tag[1]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>> // CHECK-NEXT: {
> >> > > >> >>> // CHECK-NEXT: "id": "0x{{.*}}",
> >> > > >> >>> // CHECK-NEXT: "kind": "ConstantArrayType",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "struct __va_list_tag [1]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "struct __va_list_tag[1]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "size": 1,
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
> b/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
> >> > > >> >>> index b2ab2fac86604..41b70edaf0c80 100644
> >> > > >> >>> ---
> a/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
> >> > > >> >>> +++
> b/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
> >> > > >> >>> @@ -67,18 +67,18 @@ int main() {
> >> > > >> >>> // C-NEXT: `-FunctionDecl [[ADDR_28:0x[a-z0-9]*]]
> <line:24:1, line:32:1> line:24:5 main 'int ({{.*}})'
> >> > > >> >>> // C-NEXT: `-CompoundStmt [[ADDR_29:0x[a-z0-9]*]]
> <col:12, line:32:1>
> >> > > >> >>> // C-NEXT: |-DeclStmt [[ADDR_30:0x[a-z0-9]*]]
> <line:26:3, col:12>
> >> > > >> >>> -// C-NEXT: | `-VarDecl [[ADDR_31:0x[a-z0-9]*]] <col:3,
> col:11> col:6 used fns 'fd [2]'
> >> > > >> >>> +// C-NEXT: | `-VarDecl [[ADDR_31:0x[a-z0-9]*]] <col:3,
> col:11> col:6 used fns 'fd[2]'
> >> > > >> >>> // C-NEXT: |-BinaryOperator [[ADDR_32:0x[a-z0-9]*]]
> <line:27:3, col:13> 'fd':'int (*)({{.*}})' '='
> >> > > >> >>> // C-NEXT: | |-ArraySubscriptExpr
> [[ADDR_33:0x[a-z0-9]*]] <col:3, col:8> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // C-NEXT: | | |-ImplicitCastExpr
> [[ADDR_34:0x[a-z0-9]*]] <col:3> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// C-NEXT: | | | `-DeclRefExpr [[ADDR_35:0x[a-z0-9]*]]
> <col:3> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd [2]'
> >> > > >> >>> +// C-NEXT: | | | `-DeclRefExpr [[ADDR_35:0x[a-z0-9]*]]
> <col:3> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>> // C-NEXT: | | `-IntegerLiteral [[ADDR_36:0x[a-z0-9]*]]
> <col:7> 'int' 0
> >> > > >> >>> // C-NEXT: | `-UnaryOperator [[ADDR_37:0x[a-z0-9]*]]
> <col:12, col:13> 'int (*)({{.*}})' prefix '&' cannot overflow
> >> > > >> >>> // C-NEXT: | `-DeclRefExpr [[ADDR_38:0x[a-z0-9]*]]
> <col:13> 'int ({{.*}})' Function [[ADDR_0]] 'also_before' 'int ({{.*}})'
> >> > > >> >>> // C-NEXT: |-BinaryOperator [[ADDR_39:0x[a-z0-9]*]]
> <line:28:3, col:12> 'fd':'int (*)({{.*}})' '='
> >> > > >> >>> // C-NEXT: | |-ArraySubscriptExpr
> [[ADDR_40:0x[a-z0-9]*]] <col:3, col:8> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // C-NEXT: | | |-ImplicitCastExpr
> [[ADDR_41:0x[a-z0-9]*]] <col:3> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// C-NEXT: | | | `-DeclRefExpr [[ADDR_42:0x[a-z0-9]*]]
> <col:3> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd [2]'
> >> > > >> >>> +// C-NEXT: | | | `-DeclRefExpr [[ADDR_42:0x[a-z0-9]*]]
> <col:3> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>> // C-NEXT: | | `-IntegerLiteral [[ADDR_43:0x[a-z0-9]*]]
> <col:7> 'int' 1
> >> > > >> >>> // C-NEXT: | `-ImplicitCastExpr [[ADDR_44:0x[a-z0-9]*]]
> <col:12> 'int (*)({{.*}})' <FunctionToPointerDecay>
> >> > > >> >>> // C-NEXT: | `-DeclRefExpr [[ADDR_45:0x[a-z0-9]*]]
> <col:12> 'int ({{.*}})' Function [[ADDR_17]] 'also_after' 'int ({{.*}})'
> >> > > >> >>> @@ -98,7 +98,7 @@ int main() {
> >> > > >> >>> // C-NEXT: | `-ParenExpr
> [[ADDR_59:0x[a-z0-9]*]] <col:10, col:17> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // C-NEXT: | `-ArraySubscriptExpr
> [[ADDR_60:0x[a-z0-9]*]] <col:11, col:16> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // C-NEXT: | |-ImplicitCastExpr
> [[ADDR_61:0x[a-z0-9]*]] <col:11> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// C-NEXT: | | `-DeclRefExpr
> [[ADDR_62:0x[a-z0-9]*]] <col:11> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd
> [2]'
> >> > > >> >>> +// C-NEXT: | | `-DeclRefExpr
> [[ADDR_62:0x[a-z0-9]*]] <col:11> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>> // C-NEXT: | `-IntegerLiteral
> [[ADDR_63:0x[a-z0-9]*]] <col:15> 'int' 0
> >> > > >> >>> // C-NEXT: `-CallExpr [[ADDR_64:0x[a-z0-9]*]]
> <line:31:10, col:19> 'int'
> >> > > >> >>> // C-NEXT: `-ImplicitCastExpr
> [[ADDR_65:0x[a-z0-9]*]] <col:10, col:17> 'fd':'int (*)({{.*}})'
> <LValueToRValue>
> >> > > >> >>> @@ -106,7 +106,7 @@ int main() {
> >> > > >> >>> // C-NEXT: `-ArraySubscriptExpr
> [[ADDR_67:0x[a-z0-9]*]] <col:11, col:16> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // C-NEXT: |-IntegerLiteral
> [[ADDR_68:0x[a-z0-9]*]] <col:11> 'int' 1
> >> > > >> >>> // C-NEXT: `-ImplicitCastExpr
> [[ADDR_69:0x[a-z0-9]*]] <col:13> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// C-NEXT: `-DeclRefExpr
> [[ADDR_70:0x[a-z0-9]*]] <col:13> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd
> [2]'
> >> > > >> >>> +// C-NEXT: `-DeclRefExpr
> [[ADDR_70:0x[a-z0-9]*]] <col:13> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>>
> >> > > >> >>> // CXX: |-FunctionDecl [[ADDR_0:0x[a-z0-9]*]] <{{.*}},
> line:7:1> line:5:5 used also_before 'int ({{.*}})'
> >> > > >> >>> // CXX-NEXT: | |-CompoundStmt [[ADDR_1:0x[a-z0-9]*]]
> <col:23, line:7:1>
> >> > > >> >>> @@ -140,18 +140,18 @@ int main() {
> >> > > >> >>> // CXX-NEXT: `-FunctionDecl [[ADDR_28:0x[a-z0-9]*]]
> <line:24:1, line:32:1> line:24:5 main 'int ({{.*}})'
> >> > > >> >>> // CXX-NEXT: `-CompoundStmt [[ADDR_29:0x[a-z0-9]*]]
> <col:12, line:32:1>
> >> > > >> >>> // CXX-NEXT: |-DeclStmt [[ADDR_30:0x[a-z0-9]*]]
> <line:26:3, col:12>
> >> > > >> >>> -// CXX-NEXT: | `-VarDecl [[ADDR_31:0x[a-z0-9]*]]
> <col:3, col:11> col:6 used fns 'fd [2]'
> >> > > >> >>> +// CXX-NEXT: | `-VarDecl [[ADDR_31:0x[a-z0-9]*]]
> <col:3, col:11> col:6 used fns 'fd[2]'
> >> > > >> >>> // CXX-NEXT: |-BinaryOperator [[ADDR_32:0x[a-z0-9]*]]
> <line:27:3, col:13> 'fd':'int (*)({{.*}})' {{.*}}'='
> >> > > >> >>> // CXX-NEXT: | |-ArraySubscriptExpr
> [[ADDR_33:0x[a-z0-9]*]] <col:3, col:8> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // CXX-NEXT: | | |-ImplicitCastExpr
> [[ADDR_34:0x[a-z0-9]*]] <col:3> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// CXX-NEXT: | | | `-DeclRefExpr
> [[ADDR_35:0x[a-z0-9]*]] <col:3> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd
> [2]'
> >> > > >> >>> +// CXX-NEXT: | | | `-DeclRefExpr
> [[ADDR_35:0x[a-z0-9]*]] <col:3> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>> // CXX-NEXT: | | `-IntegerLiteral
> [[ADDR_36:0x[a-z0-9]*]] <col:7> 'int' 0
> >> > > >> >>> // CXX-NEXT: | `-UnaryOperator [[ADDR_37:0x[a-z0-9]*]]
> <col:12, col:13> 'int (*)({{.*}})' prefix '&' cannot overflow
> >> > > >> >>> // CXX-NEXT: | `-DeclRefExpr [[ADDR_38:0x[a-z0-9]*]]
> <col:13> 'int ({{.*}})' {{.*}}Function [[ADDR_0]] 'also_before' 'int
> ({{.*}})'
> >> > > >> >>> // CXX-NEXT: |-BinaryOperator [[ADDR_39:0x[a-z0-9]*]]
> <line:28:3, col:12> 'fd':'int (*)({{.*}})' {{.*}}'='
> >> > > >> >>> // CXX-NEXT: | |-ArraySubscriptExpr
> [[ADDR_40:0x[a-z0-9]*]] <col:3, col:8> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // CXX-NEXT: | | |-ImplicitCastExpr
> [[ADDR_41:0x[a-z0-9]*]] <col:3> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// CXX-NEXT: | | | `-DeclRefExpr
> [[ADDR_42:0x[a-z0-9]*]] <col:3> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd
> [2]'
> >> > > >> >>> +// CXX-NEXT: | | | `-DeclRefExpr
> [[ADDR_42:0x[a-z0-9]*]] <col:3> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>> // CXX-NEXT: | | `-IntegerLiteral
> [[ADDR_43:0x[a-z0-9]*]] <col:7> 'int' 1
> >> > > >> >>> // CXX-NEXT: | `-ImplicitCastExpr
> [[ADDR_44:0x[a-z0-9]*]] <col:12> 'int (*)({{.*}})' <FunctionToPointerDecay>
> >> > > >> >>> // CXX-NEXT: | `-DeclRefExpr [[ADDR_45:0x[a-z0-9]*]]
> <col:12> 'int ({{.*}})' {{.*}}Function [[ADDR_17]] 'also_after' 'int
> ({{.*}})'
> >> > > >> >>> @@ -171,7 +171,7 @@ int main() {
> >> > > >> >>> // CXX-NEXT: | `-ParenExpr
> [[ADDR_59:0x[a-z0-9]*]] <col:10, col:17> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // CXX-NEXT: | `-ArraySubscriptExpr
> [[ADDR_60:0x[a-z0-9]*]] <col:11, col:16> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // CXX-NEXT: | |-ImplicitCastExpr
> [[ADDR_61:0x[a-z0-9]*]] <col:11> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// CXX-NEXT: | | `-DeclRefExpr
> [[ADDR_62:0x[a-z0-9]*]] <col:11> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd
> [2]'
> >> > > >> >>> +// CXX-NEXT: | | `-DeclRefExpr
> [[ADDR_62:0x[a-z0-9]*]] <col:11> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>> // CXX-NEXT: | `-IntegerLiteral
> [[ADDR_63:0x[a-z0-9]*]] <col:15> 'int' 0
> >> > > >> >>> // CXX-NEXT: `-CallExpr [[ADDR_64:0x[a-z0-9]*]]
> <line:31:10, col:19> 'int'
> >> > > >> >>> // CXX-NEXT: `-ImplicitCastExpr
> [[ADDR_65:0x[a-z0-9]*]] <col:10, col:17> 'fd':'int (*)({{.*}})'
> <LValueToRValue>
> >> > > >> >>> @@ -179,4 +179,4 @@ int main() {
> >> > > >> >>> // CXX-NEXT: `-ArraySubscriptExpr
> [[ADDR_67:0x[a-z0-9]*]] <col:11, col:16> 'fd':'int (*)({{.*}})' lvalue
> >> > > >> >>> // CXX-NEXT: |-IntegerLiteral
> [[ADDR_68:0x[a-z0-9]*]] <col:11> 'int' 1
> >> > > >> >>> // CXX-NEXT: `-ImplicitCastExpr
> [[ADDR_69:0x[a-z0-9]*]] <col:13> 'fd *' <ArrayToPointerDecay>
> >> > > >> >>> -// CXX-NEXT: `-DeclRefExpr
> [[ADDR_70:0x[a-z0-9]*]] <col:13> 'fd [2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd
> [2]'
> >> > > >> >>> +// CXX-NEXT: `-DeclRefExpr
> [[ADDR_70:0x[a-z0-9]*]] <col:13> 'fd[2]' {{.*}}Var [[ADDR_31]] 'fns' 'fd[2]'
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-records-json.cpp
> b/clang/test/AST/ast-dump-records-json.cpp
> >> > > >> >>> index 2227a1fa33e0a..01deb82096dd5 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-records-json.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-records-json.cpp
> >> > > >> >>> @@ -1338,7 +1338,7 @@ struct Derived6 : virtual public
> Bases... {
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "name": "b",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: {
> >> > > >> >>> @@ -1364,7 +1364,7 @@ struct Derived6 : virtual public
> Bases... {
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "name": "c",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int []"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[]"
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: ]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-records.c
> b/clang/test/AST/ast-dump-records.c
> >> > > >> >>> index 52d841db2b472..c0fbac67bc491 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-records.c
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-records.c
> >> > > >> >>> @@ -84,9 +84,9 @@ struct D {
> >> > > >> >>> int a;
> >> > > >> >>> // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:7> col:7 a 'int'
> >> > > >> >>> int b[10];
> >> > > >> >>> - // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:11> col:7 b 'int [10]'
> >> > > >> >>> + // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:11> col:7 b 'int[10]'
> >> > > >> >>> int c[];
> >> > > >> >>> - // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:9> col:7 c 'int []'
> >> > > >> >>> + // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:9> col:7 c 'int[]'
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> union E;
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-records.cpp
> b/clang/test/AST/ast-dump-records.cpp
> >> > > >> >>> index 0e375d2ce53ae..3dc087709a836 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-records.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-records.cpp
> >> > > >> >>> @@ -132,9 +132,9 @@ struct D {
> >> > > >> >>> int a;
> >> > > >> >>> // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:7> col:7 a 'int'
> >> > > >> >>> int b[10];
> >> > > >> >>> - // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:11> col:7 b 'int [10]'
> >> > > >> >>> + // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:11> col:7 b 'int[10]'
> >> > > >> >>> int c[];
> >> > > >> >>> - // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:9> col:7 c 'int []'
> >> > > >> >>> + // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3,
> col:9> col:7 c 'int[]'
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> union E;
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-stmt-json.cpp
> b/clang/test/AST/ast-dump-stmt-json.cpp
> >> > > >> >>> index 6c357b4491922..b8988cc16d430 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-stmt-json.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-stmt-json.cpp
> >> > > >> >>> @@ -2965,7 +2965,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: "name": "us",
> >> > > >> >>> // CHECK-NEXT: "mangledName":
> "_ZZ17TestUnionInitListvE2us",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "U [3]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "U[3]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "init": "c",
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>> @@ -2985,7 +2985,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "U [3]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "U[3]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "prvalue",
> >> > > >> >>> // CHECK-NEXT: "array_filler": [
> >> > > >> >>> @@ -4392,7 +4392,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: "name": "vals",
> >> > > >> >>> // CHECK-NEXT: "mangledName":
> "_ZZ13TestIterationvE4vals",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: ]
> >> > > >> >>> @@ -4478,7 +4478,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "referencedDecl": {
> >> > > >> >>> @@ -4486,7 +4486,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: "kind": "VarDecl",
> >> > > >> >>> // CHECK-NEXT: "name": "vals",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> @@ -4577,7 +4577,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "referencedDecl": {
> >> > > >> >>> @@ -4699,7 +4699,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "referencedDecl": {
> >> > > >> >>> @@ -6039,7 +6039,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "referencedDecl": {
> >> > > >> >>> @@ -6047,7 +6047,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: "kind": "VarDecl",
> >> > > >> >>> // CHECK-NEXT: "name": "vals",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> @@ -6138,7 +6138,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "referencedDecl": {
> >> > > >> >>> @@ -6260,7 +6260,7 @@ void
> TestDependentGenericSelectionExpr(Ty T) {
> >> > > >> >>> // CHECK-NEXT: }
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [10]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[10]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "valueCategory": "lvalue",
> >> > > >> >>> // CHECK-NEXT: "referencedDecl": {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-stmt.cpp
> b/clang/test/AST/ast-dump-stmt.cpp
> >> > > >> >>> index 47e1ac4071d9a..4f73d39d4af21 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-stmt.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-stmt.cpp
> >> > > >> >>> @@ -97,8 +97,8 @@ union U {
> >> > > >> >>> void TestUnionInitList()
> >> > > >> >>> {
> >> > > >> >>> U us[3] = {1};
> >> > > >> >>> -// CHECK: VarDecl {{.+}} <col:3, col:15> col:5 us 'U [3]'
> cinit
> >> > > >> >>> -// CHECK-NEXT: `-InitListExpr {{.+}} <col:13, col:15> 'U
> [3]'
> >> > > >> >>> +// CHECK: VarDecl {{.+}} <col:3, col:15> col:5 us 'U[3]'
> cinit
> >> > > >> >>> +// CHECK-NEXT: `-InitListExpr {{.+}} <col:13, col:15> 'U[3]'
> >> > > >> >>> // CHECK-NEXT: |-array_filler: InitListExpr {{.+}}
> <col:15> 'U' field Field {{.+}} 'i' 'int'
> >> > > >> >>> // CHECK-NEXT: `-InitListExpr {{.+}} <col:14> 'U' field
> Field {{.+}} 'i' 'int'
> >> > > >> >>> // CHECK-NEXT: `-IntegerLiteral {{.+}} <col:14> 'int' 1
> >> > > >> >>> @@ -196,16 +196,16 @@ void TestIteration() {
> >> > > >> >>> // CHECK-NEXT: <<<NULL>>>
> >> > > >> >>> // CHECK-NEXT: DeclStmt
> >> > > >> >>> // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:16> col:16
> implicit used __range1 'int (&)[10]' cinit
> >> > > >> >>> - // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int
> [10]' lvalue Var 0x{{[^ ]*}} 'vals' 'int [10]'
> >> > > >> >>> + // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int[10]'
> lvalue Var 0x{{[^ ]*}} 'vals' 'int[10]'
> >> > > >> >>> // CHECK-NEXT: DeclStmt
> >> > > >> >>> // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14> col:14
> implicit used __begin1 'int *':'int *' cinit
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> - // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int
> [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> + // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int[10]'
> lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> // CHECK-NEXT: DeclStmt
> >> > > >> >>> // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14, col:16>
> col:14 implicit used __end1 'int *':'int *' cinit
> >> > > >> >>> // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14,
> col:16> 'int *' '+'
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> - // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int
> [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> + // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int[10]'
> lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:16> 'long'
> 10
> >> > > >> >>> // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14> 'bool'
> '!='
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> @@ -264,16 +264,16 @@ void TestIteration() {
> >> > > >> >>> // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:12> col:12
> a 'int'
> >> > > >> >>> // CHECK-NEXT: DeclStmt
> >> > > >> >>> // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:23> col:23
> implicit used __range1 'int (&)[10]' cinit
> >> > > >> >>> - // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int
> [10]' lvalue Var 0x{{[^ ]*}} 'vals' 'int [10]'
> >> > > >> >>> + // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int[10]'
> lvalue Var 0x{{[^ ]*}} 'vals' 'int[10]'
> >> > > >> >>> // CHECK-NEXT: DeclStmt
> >> > > >> >>> // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:21> col:21
> implicit used __begin1 'int *':'int *' cinit
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> - // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int
> [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> + // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int[10]'
> lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> // CHECK-NEXT: DeclStmt
> >> > > >> >>> // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:21, col:23>
> col:21 implicit used __end1 'int *':'int *' cinit
> >> > > >> >>> // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:21,
> col:23> 'int *' '+'
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> - // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int
> [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> + // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int[10]'
> lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:23> 'long'
> 10
> >> > > >> >>> // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:21> 'bool'
> '!='
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/AST/ast-dump-template-decls-json.cpp
> b/clang/test/AST/ast-dump-template-decls-json.cpp
> >> > > >> >>> index e3342190ff919..5e7a547e21615 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-template-decls-json.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-template-decls-json.cpp
> >> > > >> >>> @@ -185,14 +185,14 @@ void i();
> >> > > >> >>> // CHECK-NEXT: "isImplicit": true,
> >> > > >> >>> // CHECK-NEXT: "name": "__builtin_va_list",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "__va_list_tag [1]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "__va_list_tag[1]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>> // CHECK-NEXT: {
> >> > > >> >>> // CHECK-NEXT: "id": "0x{{.*}}",
> >> > > >> >>> // CHECK-NEXT: "kind": "ConstantArrayType",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "__va_list_tag [1]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "__va_list_tag[1]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "size": 1,
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-templates.cpp
> b/clang/test/AST/ast-dump-templates.cpp
> >> > > >> >>> index 89feee75268a3..ab4a7356028e1 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-templates.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-templates.cpp
> >> > > >> >>> @@ -46,9 +46,9 @@ template <typename ...T> struct A {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK1-LABEL: template <typename ...T> void f(T ...[3]) {
> >> > > >> >>> -// CHECK1-NEXT: A<T [3]...> a;
> >> > > >> >>> +// CHECK1-NEXT: A<T[3]...> a;
> >> > > >> >>> template <typename ...T> void f(T ...[3]) {
> >> > > >> >>> - A<T [3]...> a;
> >> > > >> >>> + A<T[3]...> a;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace test2 {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/ast-dump-types-errors-json.cpp
> b/clang/test/AST/ast-dump-types-errors-json.cpp
> >> > > >> >>> index 89535fcb70f43..1f79130d9db3c 100644
> >> > > >> >>> --- a/clang/test/AST/ast-dump-types-errors-json.cpp
> >> > > >> >>> +++ b/clang/test/AST/ast-dump-types-errors-json.cpp
> >> > > >> >>> @@ -24,14 +24,14 @@ using TestContainsErrors =
> int[sizeof(undef())];
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "name": "TestContainsErrors",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [sizeof
> (<recovery-expr>(undef))]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[sizeof
> (<recovery-expr>(undef))]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "inner": [
> >> > > >> >>> // CHECK-NEXT: {
> >> > > >> >>> // CHECK-NEXT: "id": "0x{{.*}}",
> >> > > >> >>> // CHECK-NEXT: "kind": "DependentSizedArrayType",
> >> > > >> >>> // CHECK-NEXT: "type": {
> >> > > >> >>> -// CHECK-NEXT: "qualType": "int [sizeof
> (<recovery-expr>(undef))]"
> >> > > >> >>> +// CHECK-NEXT: "qualType": "int[sizeof
> (<recovery-expr>(undef))]"
> >> > > >> >>> // CHECK-NEXT: },
> >> > > >> >>> // CHECK-NEXT: "containsErrors": true,
> >> > > >> >>> // CHECK-NEXT: "isDependent": true,
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/atomic-expr.cpp
> b/clang/test/AST/atomic-expr.cpp
> >> > > >> >>> index db21d61e98c2a..bdb7bcb00569a 100644
> >> > > >> >>> --- a/clang/test/AST/atomic-expr.cpp
> >> > > >> >>> +++ b/clang/test/AST/atomic-expr.cpp
> >> > > >> >>> @@ -28,14 +28,14 @@ void useage(){
> >> > > >> >>> // CHECK: AtomicExpr
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> // CHECK-SAME: <ArrayToPointerDecay>
> >> > > >> >>> -// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:20>
> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
> >> > > >> >>> +// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:20>
> 'int[2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int[2]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:28> 'int' 5
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:25> 'int' 0
> >> > > >> >>> // CHECK:FunctionDecl 0x{{[0-9a-f]+}} <line:{{.*}}:1,
> line:{{.*}}:1> line:{{.*}}:6 used pr43370
> >> > > >> >>> // CHECK: AtomicExpr
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> // CHECK-SAME: <ArrayToPointerDecay>
> >> > > >> >>> -// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:20>
> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
> >> > > >> >>> +// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:20>
> 'int[2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int[2]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:28> 'int' 5
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:25> 'int' 0
> >> > > >> >>>
> >> > > >> >>> @@ -43,11 +43,11 @@ void useage(){
> >> > > >> >>> // CHECK: AtomicExpr
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> // CHECK-SAME: <ArrayToPointerDecay>
> >> > > >> >>> -// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:37>
> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
> >> > > >> >>> +// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:37>
> 'int[2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int[2]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:53> 'int' 3
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> // CHECK-SAME: <ArrayToPointerDecay>
> >> > > >> >>> -// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:42>
> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
> >> > > >> >>> +// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:42>
> 'int[2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int[2]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:56> 'int' 4
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:47> 'int' 1
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> @@ -56,11 +56,11 @@ void useage(){
> >> > > >> >>> // CHECK: AtomicExpr
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> // CHECK-SAME: <ArrayToPointerDecay>
> >> > > >> >>> -// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:37>
> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
> >> > > >> >>> +// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:37>
> 'int[2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int[2]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:53> 'int' 3
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>> // CHECK-SAME: <ArrayToPointerDecay>
> >> > > >> >>> -// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:42>
> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
> >> > > >> >>> +// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:42>
> 'int[2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int[2]'
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:56> 'int' 4
> >> > > >> >>> // CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}}
> <{{[^:]+}}:47> 'int' 1
> >> > > >> >>> // CHECK-NEXT: ImplicitCastExpr
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/float16.cpp
> b/clang/test/AST/float16.cpp
> >> > > >> >>> index 807289ac0a7f1..104ade6b54d6b 100644
> >> > > >> >>> --- a/clang/test/AST/float16.cpp
> >> > > >> >>> +++ b/clang/test/AST/float16.cpp
> >> > > >> >>> @@ -33,9 +33,9 @@ namespace {
> >> > > >> >>> //CHECK-NEXT: | |-VarDecl {{.*}} f1n '_Float16'
> >> > > >> >>> //CHECK-NEXT: | |-VarDecl {{.*}} f2n '_Float16' cinit
> >> > > >> >>> //CHECK-NEXT: | | `-FloatingLiteral {{.*}} '_Float16'
> 3.300000e+01
> >> > > >> >>> -//CHECK-NEXT: | |-VarDecl {{.*}} arr1n '_Float16 [10]'
> >> > > >> >>> -//CHECK-NEXT: | |-VarDecl {{.*}} arr2n '_Float16 [3]' cinit
> >> > > >> >>> -//CHECK-NEXT: | | `-InitListExpr {{.*}} '_Float16 [3]'
> >> > > >> >>> +//CHECK-NEXT: | |-VarDecl {{.*}} arr1n '_Float16[10]'
> >> > > >> >>> +//CHECK-NEXT: | |-VarDecl {{.*}} arr2n '_Float16[3]' cinit
> >> > > >> >>> +//CHECK-NEXT: | | `-InitListExpr {{.*}} '_Float16[3]'
> >> > > >> >>> //CHECK-NEXT: | | |-ImplicitCastExpr {{.*}} '_Float16'
> <FloatingCast>
> >> > > >> >>> //CHECK-NEXT: | | | `-FloatingLiteral {{.*}} 'double'
> 1.200000e+00
> >> > > >> >>> //CHECK-NEXT: | | |-ImplicitCastExpr {{.*}} '_Float16'
> <FloatingCast>
> >> > > >> >>> @@ -55,9 +55,9 @@ _Float16 func1f(_Float16 arg);
> >> > > >> >>> //CHECK-NEXT: |-VarDecl {{.*}} f2f '_Float16' cinit
> >> > > >> >>> //CHECK-NEXT: | `-ImplicitCastExpr {{.*}} '_Float16'
> <FloatingCast>
> >> > > >> >>> //CHECK-NEXT: | `-FloatingLiteral {{.*}} 'double'
> 3.240000e+01
> >> > > >> >>> -//CHECK-NEXT: |-VarDecl {{.*}} arr1f '_Float16 [10]'
> >> > > >> >>> -//CHECK-NEXT: |-VarDecl {{.*}} arr2f '_Float16 [3]' cinit
> >> > > >> >>> -//CHECK-NEXT: | `-InitListExpr {{.*}} '_Float16 [3]'
> >> > > >> >>> +//CHECK-NEXT: |-VarDecl {{.*}} arr1f '_Float16[10]'
> >> > > >> >>> +//CHECK-NEXT: |-VarDecl {{.*}} arr2f '_Float16[3]' cinit
> >> > > >> >>> +//CHECK-NEXT: | `-InitListExpr {{.*}} '_Float16[3]'
> >> > > >> >>> //CHECK-NEXT: | |-ImplicitCastExpr {{.*}} '_Float16'
> <FloatingCast>
> >> > > >> >>> //CHECK-NEXT: | | `-UnaryOperator {{.*}} 'double' prefix
> '-'
> >> > > >> >>> //CHECK-NEXT: | | `-FloatingLiteral {{.*}} 'double'
> 1.200000e+00
> >> > > >> >>> @@ -297,8 +297,8 @@ int main(void) {
> >> > > >> >>> //CHECK-NEXT: | `-DeclRefExpr {{.*}} '_Float16' lvalue
> Var {{.*}} 'f4l' '_Float16'
> >> > > >> >>>
> >> > > >> >>> _Float16 arr1l[] = { -1.f16, -0.f16, -11.f16 };
> >> > > >> >>> -//CHECK: `-VarDecl {{.*}} arr1l '_Float16 [3]' cinit
> >> > > >> >>> -//CHECK-NEXT: `-InitListExpr {{.*}} '_Float16 [3]'
> >> > > >> >>> +//CHECK: `-VarDecl {{.*}} arr1l '_Float16[3]' cinit
> >> > > >> >>> +//CHECK-NEXT: `-InitListExpr {{.*}} '_Float16[3]'
> >> > > >> >>> //CHECK-NEXT: |-UnaryOperator {{.*}} '_Float16' prefix
> '-'
> >> > > >> >>> //CHECK-NEXT: | `-FloatingLiteral {{.*}} '_Float16'
> 1.000000e+00
> >> > > >> >>> //CHECK-NEXT: |-UnaryOperator {{.*}} '_Float16' prefix
> '-'
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/pr47636.cpp
> b/clang/test/AST/pr47636.cpp
> >> > > >> >>> index 29d2a0a06e791..5311edb892c55 100644
> >> > > >> >>> --- a/clang/test/AST/pr47636.cpp
> >> > > >> >>> +++ b/clang/test/AST/pr47636.cpp
> >> > > >> >>> @@ -2,25 +2,25 @@
> >> > > >> >>>
> >> > > >> >>> int(&&intu_rvref)[] {1,2,3,4};
> >> > > >> >>> // CHECK: VarDecl 0x[[GLOB_ADDR:[0-9a-f]+]] {{.*}}
> intu_rvref 'int (&&)[4]' listinit
> >> > > >> >>> -// CHECK-NEXT: ExprWithCleanups {{.*}} 'int [4]' xvalue
> >> > > >> >>> -// CHECK-NEXT: MaterializeTemporaryExpr {{.*}} 'int [4]'
> xvalue extended by Var 0x[[GLOB_ADDR]] 'intu_rvref' 'int (&&)[4]'
> >> > > >> >>> -// CHECK-NEXT: InitListExpr {{.*}} 'int [4]'
> >> > > >> >>> +// CHECK-NEXT: ExprWithCleanups {{.*}} 'int[4]' xvalue
> >> > > >> >>> +// CHECK-NEXT: MaterializeTemporaryExpr {{.*}} 'int[4]'
> xvalue extended by Var 0x[[GLOB_ADDR]] 'intu_rvref' 'int (&&)[4]'
> >> > > >> >>> +// CHECK-NEXT: InitListExpr {{.*}} 'int[4]'
> >> > > >> >>>
> >> > > >> >>> // CHECK: FunctionDecl {{.*}} static_const
> >> > > >> >>> void static_const() {
> >> > > >> >>> static const int(&&intu_rvref)[] {1,2,3,4};
> >> > > >> >>> // CHECK: VarDecl 0x[[STATIC_ADDR:[0-9a-f]+]] {{.*}}
> intu_rvref 'const int (&&)[4]' static listinit
> >> > > >> >>> - // CHECK-NEXT: ExprWithCleanups {{.*}} 'const int [4]'
> xvalue
> >> > > >> >>> - // CHECK-NEXT: MaterializeTemporaryExpr {{.*}} 'const int
> [4]' xvalue extended by Var 0x[[STATIC_ADDR]] 'intu_rvref' 'const int
> (&&)[4]'
> >> > > >> >>> - // CHECK-NEXT: InitListExpr {{.*}} 'const int [4]'
> >> > > >> >>> + // CHECK-NEXT: ExprWithCleanups {{.*}} 'const int[4]'
> xvalue
> >> > > >> >>> + // CHECK-NEXT: MaterializeTemporaryExpr {{.*}} 'const
> int[4]' xvalue extended by Var 0x[[STATIC_ADDR]] 'intu_rvref' 'const int
> (&&)[4]'
> >> > > >> >>> + // CHECK-NEXT: InitListExpr {{.*}} 'const int[4]'
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> // CHECK: FunctionDecl {{.*}} const_expr
> >> > > >> >>> constexpr int const_expr() {
> >> > > >> >>> int(&&intu_rvref)[]{1, 2, 3, 4};
> >> > > >> >>> // CHECK: VarDecl 0x[[CE_ADDR:[0-9a-f]+]] {{.*}}
> intu_rvref 'int (&&)[4]' listinit
> >> > > >> >>> - // CHECK-NEXT: ExprWithCleanups {{.*}} 'int [4]' xvalue
> >> > > >> >>> - // CHECK-NEXT: MaterializeTemporaryExpr {{.*}} 'int [4]'
> xvalue extended by Var 0x[[CE_ADDR]] 'intu_rvref' 'int (&&)[4]'
> >> > > >> >>> - // CHECK-NEXT: InitListExpr {{.*}} 'int [4]'
> >> > > >> >>> + // CHECK-NEXT: ExprWithCleanups {{.*}} 'int[4]' xvalue
> >> > > >> >>> + // CHECK-NEXT: MaterializeTemporaryExpr {{.*}} 'int[4]'
> xvalue extended by Var 0x[[CE_ADDR]] 'intu_rvref' 'int (&&)[4]'
> >> > > >> >>> + // CHECK-NEXT: InitListExpr {{.*}} 'int[4]'
> >> > > >> >>> return intu_rvref[0];
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/AST/sourceranges.cpp
> b/clang/test/AST/sourceranges.cpp
> >> > > >> >>> index cd1095c69afc3..afb9492b2c366 100644
> >> > > >> >>> --- a/clang/test/AST/sourceranges.cpp
> >> > > >> >>> +++ b/clang/test/AST/sourceranges.cpp
> >> > > >> >>> @@ -13,7 +13,7 @@ enum B {};
> >> > > >> >>> typedef int C;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> -// CHECK: VarDecl {{0x[0-9a-fA-F]+}} <line:[[@LINE+1]]:1,
> col:36> col:15 ImplicitConstrArray 'foo::A [2]'
> >> > > >> >>> +// CHECK: VarDecl {{0x[0-9a-fA-F]+}} <line:[[@LINE+1]]:1,
> col:36> col:15 ImplicitConstrArray 'foo::A[2]'
> >> > > >> >>> static foo::A ImplicitConstrArray[2];
> >> > > >> >>>
> >> > > >> >>> int main() {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/ASTMerge/var/test.c
> b/clang/test/ASTMerge/var/test.c
> >> > > >> >>> index a43de77bfe62a..5efc25fdb573d 100644
> >> > > >> >>> --- a/clang/test/ASTMerge/var/test.c
> >> > > >> >>> +++ b/clang/test/ASTMerge/var/test.c
> >> > > >> >>> @@ -7,6 +7,6 @@
> >> > > >> >>> // CHECK: var2.c:3:5: warning: external variable 'x2'
> declared with incompatible types in
> >> > > >> >>> diff erent translation units ('int' vs. 'double')
> >> > > >> >>> // CHECK: In file included from{{.*}}var1.c:3:
> >> > > >> >>> // CHECK: var1.h:1:8: note: declared here with type 'double'
> >> > > >> >>> -// CHECK: warning: external variable 'xarray3' declared
> with incompatible types in
> >> > > >> >>> diff erent translation units ('int [17]' vs. 'int [18]')
> >> > > >> >>> -// CHECK: var1.c:7:5: note: declared here with type 'int
> [18]'
> >> > > >> >>> +// CHECK: warning: external variable 'xarray3' declared
> with incompatible types in
> >> > > >> >>> diff erent translation units ('int[17]' vs. 'int[18]')
> >> > > >> >>> +// CHECK: var1.c:7:5: note: declared here with type
> 'int[18]'
> >> > > >> >>> // CHECK: 3 warnings generated
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Analysis/auto-obj-dtors-cfg-output.cpp
> b/clang/test/Analysis/auto-obj-dtors-cfg-output.cpp
> >> > > >> >>> index 22df86e1773c6..82c86a95792a9 100644
> >> > > >> >>> --- a/clang/test/Analysis/auto-obj-dtors-cfg-output.cpp
> >> > > >> >>> +++ b/clang/test/Analysis/auto-obj-dtors-cfg-output.cpp
> >> > > >> >>> @@ -334,7 +334,7 @@ void
> test_aggregate_array_lifetime_extension() {
> >> > > >> >>> // CHECK-NEXT: 61: ~A() (Temporary object destructor)
> >> > > >> >>> // CHECK-NEXT: 62: ~A() (Temporary object destructor)
> >> > > >> >>> // CHECK-NEXT: 63: ~A() (Temporary object destructor)
> >> > > >> >>> -// CHECK-NEXT: 64: [B1.57].~D [2]() (Implicit destructor)
> >> > > >> >>> +// CHECK-NEXT: 64: [B1.57].~D[2]() (Implicit destructor)
> >> > > >> >>> // CHECK-NEXT: 65: [B1.18].~D() (Implicit destructor)
> >> > > >> >>> // CHECK-NEXT: Preds (1): B2
> >> > > >> >>> // CHECK-NEXT: Succs (1): B0
> >> > > >> >>> @@ -357,13 +357,13 @@ void
> test_aggregate_with_nontrivial_own_destructor() {
> >> > > >> >>> // CHECK: [B2 (ENTRY)]
> >> > > >> >>> // CHECK-NEXT: Succs (1): B1
> >> > > >> >>> // CHECK: [B1]
> >> > > >> >>> -// WARNINGS-NEXT: 1: (CXXConstructExpr, class A [2])
> >> > > >> >>> -// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class A
> [2])
> >> > > >> >>> +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A[2])
> >> > > >> >>> +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class
> A[2])
> >> > > >> >>> // CHECK-NEXT: 2: A a[2];
> >> > > >> >>> -// WARNINGS-NEXT: 3: (CXXConstructExpr, class A [0])
> >> > > >> >>> -// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class A
> [0])
> >> > > >> >>> +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A[0])
> >> > > >> >>> +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class
> A[0])
> >> > > >> >>> // CHECK-NEXT: 4: A b[0];
> >> > > >> >>> -// CHECK-NEXT: 5: [B1.2].~A [2]() (Implicit destructor)
> >> > > >> >>> +// CHECK-NEXT: 5: [B1.2].~A[2]() (Implicit destructor)
> >> > > >> >>> // CHECK-NEXT: Preds (1): B2
> >> > > >> >>> // CHECK-NEXT: Succs (1): B0
> >> > > >> >>> // CHECK: [B0 (EXIT)]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Analysis/cfg.cpp
> b/clang/test/Analysis/cfg.cpp
> >> > > >> >>> index 14f5d1e155fd8..b61addcb5d861 100644
> >> > > >> >>> --- a/clang/test/Analysis/cfg.cpp
> >> > > >> >>> +++ b/clang/test/Analysis/cfg.cpp
> >> > > >> >>> @@ -116,8 +116,8 @@ void test_deletedtor() {
> >> > > >> >>> // CHECK: [B1]
> >> > > >> >>> // CHECK-NEXT: 1: 5
> >> > > >> >>> // CHECK-NEXT: 2: CFGNewAllocator(A *)
> >> > > >> >>> -// WARNINGS-NEXT: 3: (CXXConstructExpr, class A [5])
> >> > > >> >>> -// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class A
> [5])
> >> > > >> >>> +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A[5])
> >> > > >> >>> +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class
> A[5])
> >> > > >> >>> // CHECK-NEXT: 4: new A {{\[\[}}B1.1]]
> >> > > >> >>> // CHECK-NEXT: 5: A *a = new A [5];
> >> > > >> >>> // CHECK-NEXT: 6: a
> >> > > >> >>> @@ -342,8 +342,8 @@ void test_placement_new() {
> >> > > >> >>> // CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, BitCast, void
> *)
> >> > > >> >>> // CHECK-NEXT: 5: 5
> >> > > >> >>> // CHECK-NEXT: 6: CFGNewAllocator(MyClass *)
> >> > > >> >>> -// WARNINGS-NEXT: 7: (CXXConstructExpr, class MyClass [5])
> >> > > >> >>> -// ANALYZER-NEXT: 7: (CXXConstructExpr, [B1.8], class
> MyClass [5])
> >> > > >> >>> +// WARNINGS-NEXT: 7: (CXXConstructExpr, class MyClass[5])
> >> > > >> >>> +// ANALYZER-NEXT: 7: (CXXConstructExpr, [B1.8], class
> MyClass[5])
> >> > > >> >>> // CHECK-NEXT: 8: new ([B1.4]) MyClass {{\[\[}}B1.5]]
> >> > > >> >>> // CHECK-NEXT: 9: MyClass *obj = new (buffer) MyClass [5];
> >> > > >> >>> // CHECK-NEXT: Preds (1): B2
> >> > > >> >>> @@ -513,7 +513,7 @@ void vla_typedef(int x) {
> >> > > >> >>> // CHECK: [B1]
> >> > > >> >>> // CHECK-NEXT: 1: x
> >> > > >> >>> // CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr,
> LValueToRValue, int)
> >> > > >> >>> -// CHECK-NEXT: 3: using VLA = int [x];
> >> > > >> >>> +// CHECK-NEXT: 3: using VLA = int[x];
> >> > > >> >>> void vla_typealias(int x) {
> >> > > >> >>> using VLA = int[x];
> >> > > >> >>> }
> >> > > >> >>> @@ -538,7 +538,7 @@ void vla_typedef_multi(int x, int y) {
> >> > > >> >>> // CHECK-NEXT: 5: [B1.4] (ImplicitCastExpr,
> LValueToRValue, int)
> >> > > >> >>> // CHECK-NEXT: 6: typedef VLA VLA1[y];
> >> > > >> >>> // CHECK-NEXT: 7: 3
> >> > > >> >>> -// CHECK-NEXT: 8: using VLA2 = VLA1 [3];
> >> > > >> >>> +// CHECK-NEXT: 8: using VLA2 = VLA1[3];
> >> > > >> >>> // CHECK-NEXT: 9: 4
> >> > > >> >>> // CHECK-NEXT: 10: VLA2 vla[4];
> >> > > >> >>> void vla_typedefname_multi(int x, int y) {
> >> > > >> >>> @@ -557,8 +557,8 @@ void vla_typedefname_multi(int x, int y)
> {
> >> > > >> >>> // CHECK-NEXT: 5: x
> >> > > >> >>> // CHECK-NEXT: 6: ++[B1.5]
> >> > > >> >>> // CHECK-NEXT: 7: [B1.6] (ImplicitCastExpr,
> LValueToRValue, int)
> >> > > >> >>> -// CHECK-NEXT: 8: sizeof(int [++x])
> >> > > >> >>> -// CHECK-NEXT: 9: alignof(int [++x])
> >> > > >> >>> +// CHECK-NEXT: 8: sizeof(int[++x])
> >> > > >> >>> +// CHECK-NEXT: 9: alignof(int[++x])
> >> > > >> >>> // CHECK-NEXT: 10: 0
> >> > > >> >>> // CHECK-NEXT: 11: x
> >> > > >> >>> // CHECK-NEXT: 12: [B1.11] (ImplicitCastExpr,
> LValueToRValue, int)
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Analysis/explain-svals.cpp
> b/clang/test/Analysis/explain-svals.cpp
> >> > > >> >>> index 387530c17f6cd..44cd66b491ea7 100644
> >> > > >> >>> --- a/clang/test/Analysis/explain-svals.cpp
> >> > > >> >>> +++ b/clang/test/Analysis/explain-svals.cpp
> >> > > >> >>> @@ -81,7 +81,7 @@ void test_4(int x, int y) {
> >> > > >> >>> clang_analyzer_explain(&stat); //
> expected-warning-re{{{{^pointer to static local variable 'stat'$}}}}
> >> > > >> >>> clang_analyzer_explain(stat_glob); //
> expected-warning-re{{{{^initial value of global variable 'stat_glob'$}}}}
> >> > > >> >>> clang_analyzer_explain(&stat_glob); //
> expected-warning-re{{{{^pointer to global variable 'stat_glob'$}}}}
> >> > > >> >>> - clang_analyzer_explain((int[]){1, 2, 3}); //
> expected-warning-re{{{{^pointer to element of type 'int' with index 0 of
> temporary object constructed at statement '\(int \[3\]\)\{1, 2, 3\}'$}}}}
> >> > > >> >>> + clang_analyzer_explain((int[]){1, 2, 3}); //
> expected-warning-re{{{{^pointer to element of type 'int' with index 0 of
> temporary object constructed at statement '\(int\[3\]\)\{1, 2, 3\}'$}}}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Analysis/lifetime-cfg-output.cpp
> b/clang/test/Analysis/lifetime-cfg-output.cpp
> >> > > >> >>> index dc2849db1b63f..2c574c7cae8a4 100644
> >> > > >> >>> --- a/clang/test/Analysis/lifetime-cfg-output.cpp
> >> > > >> >>> +++ b/clang/test/Analysis/lifetime-cfg-output.cpp
> >> > > >> >>> @@ -84,9 +84,9 @@ void test_const_ref() {
> >> > > >> >>> // CHECK: [B2 (ENTRY)]
> >> > > >> >>> // CHECK-NEXT: Succs (1): B1
> >> > > >> >>> // CHECK: [B1]
> >> > > >> >>> -// CHECK-NEXT: 1: (CXXConstructExpr, class A [2])
> >> > > >> >>> +// CHECK-NEXT: 1: (CXXConstructExpr, class A[2])
> >> > > >> >>> // CHECK-NEXT: 2: A a[2];
> >> > > >> >>> -// CHECK-NEXT: 3: (CXXConstructExpr, class A [0])
> >> > > >> >>> +// CHECK-NEXT: 3: (CXXConstructExpr, class A[0])
> >> > > >> >>> // CHECK-NEXT: 4: A b[0];
> >> > > >> >>> // lifetime of a ends when its destructors are run
> >> > > >> >>> // CHECK-NEXT: 5: [B1.2] (Lifetime ends)
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Analysis/malloc-sizeof.c
> b/clang/test/Analysis/malloc-sizeof.c
> >> > > >> >>> index 22c4045b7bbd3..9d2ada4af1e25 100644
> >> > > >> >>> --- a/clang/test/Analysis/malloc-sizeof.c
> >> > > >> >>> +++ b/clang/test/Analysis/malloc-sizeof.c
> >> > > >> >>> @@ -49,6 +49,6 @@ int *mallocArraySize() {
> >> > > >> >>>
> >> > > >> >>> int *mallocWrongArraySize() {
> >> > > >> >>> static const double sTable[10];
> >> > > >> >>> - int *table = malloc(sizeof sTable); // expected-warning
> {{Result of 'malloc' is converted to a pointer of type 'int', which is
> incompatible with sizeof operand type 'const double [10]'}}
> >> > > >> >>> + int *table = malloc(sizeof sTable); // expected-warning
> {{Result of 'malloc' is converted to a pointer of type 'int', which is
> incompatible with sizeof operand type 'const double[10]'}}
> >> > > >> >>> return table;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Analysis/more-dtors-cfg-output.cpp
> b/clang/test/Analysis/more-dtors-cfg-output.cpp
> >> > > >> >>> index 668210a0f61e0..964c6d94d378d 100644
> >> > > >> >>> --- a/clang/test/Analysis/more-dtors-cfg-output.cpp
> >> > > >> >>> +++ b/clang/test/Analysis/more-dtors-cfg-output.cpp
> >> > > >> >>> @@ -208,7 +208,7 @@ void compound_literal() {
> >> > > >> >>> // CHECK: void compound_literal()
> >> > > >> >>> // CHECK: (CXXConstructExpr, struct Bar)
> >> > > >> >>> // CHECK: (CXXConstructExpr, struct Bar)
> >> > > >> >>> -// CHECK: ~Bar [2]() (Temporary object destructor)
> >> > > >> >>> +// CHECK: ~Bar[2]() (Temporary object destructor)
> >> > > >> >>>
> >> > > >> >>> Foo elided_return() {
> >> > > >> >>> return get_foo();
> >> > > >> >>> @@ -258,17 +258,17 @@ void default_ctor_with_default_arg() {
> >> > > >> >>> DefaultArgInCtor qux[3];
> >> > > >> >>> }
> >> > > >> >>> // CHECK: void default_ctor_with_default_arg()
> >> > > >> >>> -// CHECK: CXXConstructExpr, {{.*}}, struct DefaultArgInCtor
> [3]
> >> > > >> >>> +// CHECK: CXXConstructExpr, {{.*}}, struct
> DefaultArgInCtor[3]
> >> > > >> >>> // CXX14: ~Foo() (Temporary object destructor)
> >> > > >> >>> // CHECK: ~Foo() (Temporary object destructor)
> >> > > >> >>> -// CHECK: .~DefaultArgInCtor [3]() (Implicit destructor)
> >> > > >> >>> +// CHECK: .~DefaultArgInCtor[3]() (Implicit destructor)
> >> > > >> >>>
> >> > > >> >>> void new_default_ctor_with_default_arg(long count) {
> >> > > >> >>> // Same problems as above.
> >> > > >> >>> new DefaultArgInCtor[count];
> >> > > >> >>> }
> >> > > >> >>> // CHECK: void new_default_ctor_with_default_arg(long count)
> >> > > >> >>> -// CHECK: CXXConstructExpr, {{.*}}, struct DefaultArgInCtor
> []
> >> > > >> >>> +// CHECK: CXXConstructExpr, {{.*}}, struct
> DefaultArgInCtor[]
> >> > > >> >>> // CXX14: ~Foo() (Temporary object destructor)
> >> > > >> >>> // CHECK: ~Foo() (Temporary object destructor)
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Analysis/scopes-cfg-output.cpp
> b/clang/test/Analysis/scopes-cfg-output.cpp
> >> > > >> >>> index 4b6e2a92c53ad..c8212d51f6b24 100644
> >> > > >> >>> --- a/clang/test/Analysis/scopes-cfg-output.cpp
> >> > > >> >>> +++ b/clang/test/Analysis/scopes-cfg-output.cpp
> >> > > >> >>> @@ -34,11 +34,11 @@ extern const bool UV;
> >> > > >> >>> // CHECK-NEXT: Succs (1): B1
> >> > > >> >>> // CHECK: [B1]
> >> > > >> >>> // CHECK-NEXT: 1: CFGScopeBegin(a)
> >> > > >> >>> -// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class A [2])
> >> > > >> >>> +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class A[2])
> >> > > >> >>> // CHECK-NEXT: 3: A a[2];
> >> > > >> >>> -// CHECK-NEXT: 4: (CXXConstructExpr, [B1.5], class A [0])
> >> > > >> >>> +// CHECK-NEXT: 4: (CXXConstructExpr, [B1.5], class A[0])
> >> > > >> >>> // CHECK-NEXT: 5: A b[0];
> >> > > >> >>> -// CHECK-NEXT: 6: [B1.3].~A [2]() (Implicit destructor)
> >> > > >> >>> +// CHECK-NEXT: 6: [B1.3].~A[2]() (Implicit destructor)
> >> > > >> >>> // CHECK-NEXT: 7: CFGScopeEnd(a)
> >> > > >> >>> // CHECK-NEXT: Preds (1): B2
> >> > > >> >>> // CHECK-NEXT: Succs (1): B0
> >> > > >> >>> @@ -810,7 +810,7 @@ void test_for_compound_and_break() {
> >> > > >> >>> // CHECK-NEXT: 1: CFGScopeEnd(__end1)
> >> > > >> >>> // CHECK-NEXT: 2: CFGScopeEnd(__begin1)
> >> > > >> >>> // CHECK-NEXT: 3: CFGScopeEnd(__range1)
> >> > > >> >>> -// CHECK-NEXT: 4: [B5.3].~A [10]() (Implicit destructor)
> >> > > >> >>> +// CHECK-NEXT: 4: [B5.3].~A[10]() (Implicit destructor)
> >> > > >> >>> // CHECK-NEXT: 5: CFGScopeEnd(a)
> >> > > >> >>> // CHECK-NEXT: Preds (1): B2
> >> > > >> >>> // CHECK-NEXT: Succs (1): B0
> >> > > >> >>> @@ -846,7 +846,7 @@ void test_for_compound_and_break() {
> >> > > >> >>> // CHECK-NEXT: Succs (1): B3
> >> > > >> >>> // CHECK: [B5]
> >> > > >> >>> // CHECK-NEXT: 1: CFGScopeBegin(a)
> >> > > >> >>> -// CHECK-NEXT: 2: (CXXConstructExpr, [B5.3], class A
> [10])
> >> > > >> >>> +// CHECK-NEXT: 2: (CXXConstructExpr, [B5.3], class A[10])
> >> > > >> >>> // CHECK-NEXT: 3: A a[10];
> >> > > >> >>> // CHECK-NEXT: 4: a
> >> > > >> >>> // CHECK-NEXT: 5: auto &&__range1 = a;
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/basic/basic.types/p10.cpp
> b/clang/test/CXX/basic/basic.types/p10.cpp
> >> > > >> >>> index eae0c6513ac24..d41b394bb60f2 100644
> >> > > >> >>> --- a/clang/test/CXX/basic/basic.types/p10.cpp
> >> > > >> >>> +++ b/clang/test/CXX/basic/basic.types/p10.cpp
> >> > > >> >>> @@ -32,7 +32,7 @@ struct Incomplete; // expected-note
> 2{{forward declaration of 'Incomplete'}}
> >> > > >> >>> template<class T> struct ClassTemp {};
> >> > > >> >>>
> >> > > >> >>> constexpr Incomplete incomplete = {}; // expected-error
> {{constexpr variable cannot have non-literal type 'const Incomplete'}}
> expected-note {{incomplete type 'const Incomplete' is not a literal type}}
> >> > > >> >>> -constexpr Incomplete incomplete2[] = {}; // expected-error
> {{constexpr variable cannot have non-literal type 'const Incomplete []'}}
> expected-note {{incomplete type 'const Incomplete []' is not a literal
> type}}
> >> > > >> >>> +constexpr Incomplete incomplete2[] = {}; // expected-error
> {{constexpr variable cannot have non-literal type 'const Incomplete[]'}}
> expected-note {{incomplete type 'const Incomplete[]' is not a literal type}}
> >> > > >> >>> constexpr ClassTemp<int> classtemplate = {};
> >> > > >> >>> constexpr ClassTemp<int> classtemplate2[] = {};
> >> > > >> >>>
> >> > > >> >>> @@ -132,12 +132,12 @@ struct ArrGood {
> >> > > >> >>> constexpr int f(ArrGood) { return 0; }
> >> > > >> >>>
> >> > > >> >>> struct ArrBad {
> >> > > >> >>> - S s[3]; // expected-note {{data member 's' of non-literal
> type 'S [3]'}}
> >> > > >> >>> + S s[3]; // expected-note {{data member 's' of non-literal
> type 'S[3]'}}
> >> > > >> >>> };
> >> > > >> >>> constexpr int f(ArrBad) { return 0; } // expected-error
> {{1st parameter type 'ArrBad' is not a literal type}}
> >> > > >> >>>
> >> > > >> >>> constexpr int arb(int n) {
> >> > > >> >>> - int a[n]; // expected-error {{variable of non-literal
> type 'int [n]' cannot be defined in a constexpr function}}
> >> > > >> >>> + int a[n]; // expected-error {{variable of non-literal
> type 'int[n]' cannot be defined in a constexpr function}}
> >> > > >> >>> }
> >> > > >> >>> // expected-warning at +1 {{variable length array folded to
> constant array as an extension}}
> >> > > >> >>> constexpr long Overflow[(1 << 30) << 2]{}; //
> expected-warning {{requires 34 bits to represent}}
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p7.cpp
> b/clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p7.cpp
> >> > > >> >>> index 81e2ca5f1e4d6..4f28d5359aa2e 100644
> >> > > >> >>> --- a/clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p7.cpp
> >> > > >> >>> +++ b/clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p7.cpp
> >> > > >> >>> @@ -9,7 +9,7 @@ static_assert(alignof(X<int, char, 1>) ==
> alignof(int), "");
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> template<typename T, typename A, int N> struct Y {
> >> > > >> >>> - alignas(A) T buffer[N]; // expected-error {{requested
> alignment is less than minimum alignment of 4 for type 'int [1]'}}
> >> > > >> >>> + alignas(A) T buffer[N]; // expected-error {{requested
> alignment is less than minimum alignment of 4 for type 'int[1]'}}
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> static_assert(alignof(Y<char, int, sizeof(int)>) ==
> alignof(int), "");
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp
> b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp
> >> > > >> >>> index 8c6f6e5ddc796..5ef917fe356c5 100644
> >> > > >> >>> --- a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp
> >> > > >> >>> +++ b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp
> >> > > >> >>> @@ -40,7 +40,7 @@ namespace VariableLengthArrays {
> >> > > >> >>> const int m = 42;
> >> > > >> >>> using U = int[m];
> >> > > >> >>> using U = int[42]; // expected-note {{previous
> definition}}
> >> > > >> >>> - using U = int; // expected-error {{type alias
> redefinition with
> >> > > >> >>> diff erent types ('int' vs 'int [42]')}}
> >> > > >> >>> + using U = int; // expected-error {{type alias
> redefinition with
> >> > > >> >>> diff erent types ('int' vs 'int[42]')}}
> >> > > >> >>>
> >> > > >> >>> void f() {
> >> > > >> >>> int n = 42;
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/dcl.decl/dcl.decomp/p2.cpp
> b/clang/test/CXX/dcl.decl/dcl.decomp/p2.cpp
> >> > > >> >>> index 211719a7e9c64..cad7d8e89ce0f 100644
> >> > > >> >>> --- a/clang/test/CXX/dcl.decl/dcl.decomp/p2.cpp
> >> > > >> >>> +++ b/clang/test/CXX/dcl.decl/dcl.decomp/p2.cpp
> >> > > >> >>> @@ -16,8 +16,8 @@ int array() {
> >> > > >> >>> using X3 = X[3];
> >> > > >> >>> auto [a3, b3, c3] = X3{1, 2, 3};
> >> > > >> >>>
> >> > > >> >>> - auto &[d, e] = arr; // expected-error {{type 'int [3]'
> decomposes into 3 elements, but only 2 names were provided}}
> >> > > >> >>> - auto &[f, g, h, i] = arr; // expected-error {{type 'int
> [3]' decomposes into 3 elements, but 4 names were provided}}
> >> > > >> >>> + auto &[d, e] = arr; // expected-error {{type 'int[3]'
> decomposes into 3 elements, but only 2 names were provided}}
> >> > > >> >>> + auto &[f, g, h, i] = arr; // expected-error {{type
> 'int[3]' decomposes into 3 elements, but 4 names were provided}}
> >> > > >> >>>
> >> > > >> >>> auto &[r0, r1, r2] = arr;
> >> > > >> >>> const auto &[cr0, cr1, cr2] = arr;
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3.cpp
> b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3.cpp
> >> > > >> >>> index 6e39bdd2429dd..46f46d249666e 100644
> >> > > >> >>> --- a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3.cpp
> >> > > >> >>> +++ b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3.cpp
> >> > > >> >>> @@ -134,11 +134,11 @@ namespace rdar13395022 {
> >> > > >> >>>
> >> > > >> >>> void test(MoveOnly mo) {
> >> > > >> >>> auto &&list1 = {mo}; // expected-error {{call to
> implicitly-deleted copy constructor}} expected-note {{in initialization of
> temporary of type 'std::initializer_list}}
> >> > > >> >>> - MoveOnly (&&list2)[1] = {mo}; // expected-error {{call
> to implicitly-deleted copy constructor}} expected-note {{in initialization
> of temporary of type 'rdar13395022::MoveOnly [1]'}}
> >> > > >> >>> + MoveOnly (&&list2)[1] = {mo}; // expected-error {{call
> to implicitly-deleted copy constructor}} expected-note {{in initialization
> of temporary of type 'rdar13395022::MoveOnly[1]'}}
> >> > > >> >>> std::initializer_list<MoveOnly> &&list3 = {};
> >> > > >> >>> MoveOnly (&&list4)[1] = {}; // expected-error {{no
> matching constructor}}
> >> > > >> >>> // expected-note at -1 {{in implicit initialization of
> array element 0 with omitted initializer}}
> >> > > >> >>> - // expected-note at -2 {{in initialization of temporary
> of type 'rdar13395022::MoveOnly [1]' created to list-initialize this
> reference}}
> >> > > >> >>> + // expected-note at -2 {{in initialization of temporary
> of type 'rdar13395022::MoveOnly[1]' created to list-initialize this
> reference}}
> >> > > >> >>> }
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p3.cpp
> b/clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p3.cpp
> >> > > >> >>> index 188a0a2c7eed0..bf16d123abe77 100644
> >> > > >> >>> --- a/clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p3.cpp
> >> > > >> >>> +++ b/clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p3.cpp
> >> > > >> >>> @@ -8,9 +8,9 @@
> >> > > >> >>> namespace test0 {
> >> > > >> >>> extern "C" int array[];
> >> > > >> >>> void declare() { extern int array[100]; }
> >> > > >> >>> - int value1 = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int value1 = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> extern "C" int array[];
> >> > > >> >>> - int value2 = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int value2 = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace test1 {
> >> > > >> >>> @@ -18,21 +18,21 @@ namespace test1 {
> >> > > >> >>> void test() {
> >> > > >> >>> { extern int array[100]; }
> >> > > >> >>> extern int array[];
> >> > > >> >>> - int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace test2 {
> >> > > >> >>> void declare() { extern int array[100]; }
> >> > > >> >>> extern int array[];
> >> > > >> >>> - int value = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int value = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace test3 {
> >> > > >> >>> void test() {
> >> > > >> >>> { extern int array[100]; }
> >> > > >> >>> extern int array[];
> >> > > >> >>> - int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -42,7 +42,7 @@ namespace test4 {
> >> > > >> >>> extern int array[100];
> >> > > >> >>> int x = sizeof(array);
> >> > > >> >>> }
> >> > > >> >>> - int y = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int y = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace test5 {
> >> > > >> >>> @@ -58,7 +58,7 @@ namespace test6 {
> >> > > >> >>> extern int array[100];
> >> > > >> >>> {
> >> > > >> >>> extern int array[];
> >> > > >> >>> - int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>> int y = sizeof(array);
> >> > > >> >>> extern int array[];
> >> > > >> >>> @@ -70,7 +70,7 @@ namespace test7 {
> >> > > >> >>> extern int array[100];
> >> > > >> >>> void test() {
> >> > > >> >>> extern int array[];
> >> > > >> >>> - int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int x = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>> int y = sizeof(array);
> >> > > >> >>> extern int array[];
> >> > > >> >>> @@ -83,9 +83,9 @@ namespace test8 {
> >> > > >> >>> extern int array[100];
> >> > > >> >>> int x = sizeof(array);
> >> > > >> >>> }
> >> > > >> >>> - int y = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int y = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> extern int array[];
> >> > > >> >>> - int z = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int z = sizeof(array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace dependent {
> >> > > >> >>> @@ -145,7 +145,7 @@ namespace dependent {
> >> > > >> >>>
> >> > > >> >>> template<typename T, typename U> void l() {
> >> > > >> >>> extern T arrX; // expected-note {{previous}}
> >> > > >> >>> - extern U arrX; // expected-error {{
> >> > > >> >>> diff erent type: 'int [4]' vs 'int [3]'}}
> >> > > >> >>> + extern U arrX; // expected-error {{
> >> > > >> >>> diff erent type: 'int[4]' vs 'int[3]'}}
> >> > > >> >>> (void)sizeof(arrX); // expected-error {{incomplete}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -210,4 +210,4 @@ namespace use_outside_ns {
> >> > > >> >>>
> >> > > >> >>> extern int arr[];
> >> > > >> >>> void f1() { extern int arr[2]; } // expected-note
> {{previous}}
> >> > > >> >>> -void f2() { extern int arr[3]; } // expected-error {{
> >> > > >> >>> diff erent type: 'int [3]' vs 'int [2]'}}
> >> > > >> >>> +void f2() { extern int arr[3]; } // expected-error {{
> >> > > >> >>> diff erent type: 'int[3]' vs 'int[2]'}}
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp
> b/clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp
> >> > > >> >>> index de1c5a708db68..9cc13b4efb80f 100644
> >> > > >> >>> --- a/clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp
> >> > > >> >>> +++ b/clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp
> >> > > >> >>> @@ -57,15 +57,15 @@ template<typename T>
> >> > > >> >>> void b(T[] ...);
> >> > > >> >>>
> >> > > >> >>> template<typename T>
> >> > > >> >>> -void c(T ... []); // expected-error{{type 'T []' of
> function parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>> +void c(T ... []); // expected-error{{type 'T[]' of function
> parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>>
> >> > > >> >>> template<typename T>
> >> > > >> >>> -void d(T ... x[]); // expected-error{{type 'T []' of
> function parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>> +void d(T ... x[]); // expected-error{{type 'T[]' of
> function parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>>
> >> > > >> >>> void ai(int[] ... x); // expected-error{{expected ')'}}
> expected-note{{to match this '('}}
> >> > > >> >>> void bi(int[] ...);
> >> > > >> >>> -void ci(int ... []); // expected-error{{type 'int []' of
> function parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>> -void di(int ... x[]); // expected-error{{type 'int []' of
> function parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>> +void ci(int ... []); // expected-error{{type 'int[]' of
> function parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>> +void di(int ... x[]); // expected-error{{type 'int[]' of
> function parameter pack does not contain any unexpanded parameter packs}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> void f5a(auto fp(int)->unk ...) {} //
> expected-error{{unknown type name 'unk'}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/drs/dr177x.cpp
> b/clang/test/CXX/drs/dr177x.cpp
> >> > > >> >>> index d307988ddbb66..7b96ff0996c72 100644
> >> > > >> >>> --- a/clang/test/CXX/drs/dr177x.cpp
> >> > > >> >>> +++ b/clang/test/CXX/drs/dr177x.cpp
> >> > > >> >>> @@ -13,8 +13,8 @@ namespace dr1772 { // dr1772: 14
> >> > > >> >>> // CXX11: CXXRecordDecl
> >> > > >> >>> // CXX11: CXXMethodDecl{{.+}} operator() 'void ()
> {{.*}}const'
> >> > > >> >>> // CXX11-NEXT: CompoundStmt
> >> > > >> >>> - // CXX11-NEXT: PredefinedExpr{{.+}} 'const char [11]'
> lvalue __func__
> >> > > >> >>> - // CXX11-NEXT: StringLiteral{{.+}} 'const char [11]'
> lvalue "operator()"
> >> > > >> >>> + // CXX11-NEXT: PredefinedExpr{{.+}} 'const char[11]'
> lvalue __func__
> >> > > >> >>> + // CXX11-NEXT: StringLiteral{{.+}} 'const char[11]'
> lvalue "operator()"
> >> > > >> >>>
> >> > > >> >>> void func() {
> >> > > >> >>> // CXX11: FunctionDecl{{.+}} func
> >> > > >> >>> @@ -24,8 +24,8 @@ namespace dr1772 { // dr1772: 14
> >> > > >> >>> // CXX11: CXXRecordDecl
> >> > > >> >>> // CXX11: CXXMethodDecl{{.+}} operator() 'void ()
> {{.*}}const'
> >> > > >> >>> // CXX11-NEXT: CompoundStmt
> >> > > >> >>> - // CXX11-NEXT: PredefinedExpr{{.+}} 'const char [11]'
> lvalue __func__
> >> > > >> >>> - // CXX11-NEXT: StringLiteral{{.+}} 'const char [11]'
> lvalue "operator()"
> >> > > >> >>> + // CXX11-NEXT: PredefinedExpr{{.+}} 'const char[11]'
> lvalue __func__
> >> > > >> >>> + // CXX11-NEXT: StringLiteral{{.+}} 'const char[11]'
> lvalue "operator()"
> >> > > >> >>> }
> >> > > >> >>> #endif // __cplusplus >= 201103L
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/expr/expr.prim/
> expr.prim.id/mixed-constraints.cpp b/clang/test/CXX/expr/expr.prim/
> expr.prim.id/mixed-constraints.cpp
> >> > > >> >>> index 6add2c5d10a49..dee5487771ef3 100644
> >> > > >> >>> --- a/clang/test/CXX/expr/expr.prim/
> expr.prim.id/mixed-constraints.cpp
> >> > > >> >>> +++ b/clang/test/CXX/expr/expr.prim/
> expr.prim.id/mixed-constraints.cpp
> >> > > >> >>> @@ -1,13 +1,13 @@
> >> > > >> >>> // RUN: %clang_cc1 -std=c++2a -verify %s
> >> > > >> >>>
> >> > > >> >>> template<typename T> requires (sizeof(T) >= 4 && sizeof(T)
> <= 10)
> >> > > >> >>> -// expected-note at -1{{because 'sizeof(char [20]) <= 10' (20
> <= 10) evaluated to false}}
> >> > > >> >>> +// expected-note at -1{{because 'sizeof(char[20]) <= 10' (20
> <= 10) evaluated to false}}
> >> > > >> >>> // expected-note at -2{{because 'sizeof(char) >= 4' (1 >= 4)
> evaluated to false}}
> >> > > >> >>> void foo() requires (sizeof(T) <= 8) {}
> >> > > >> >>> // expected-note at -1{{candidate template ignored:
> constraints not satisfied [with T = char]}}
> >> > > >> >>> -// expected-note at -2{{candidate template ignored:
> constraints not satisfied [with T = char [9]]}}
> >> > > >> >>> -// expected-note at -3{{candidate template ignored:
> constraints not satisfied [with T = char [20]]}}
> >> > > >> >>> -// expected-note at -4{{because 'sizeof(char [9]) <= 8' (9 <=
> 8) evaluated to false}}
> >> > > >> >>> +// expected-note at -2{{candidate template ignored:
> constraints not satisfied [with T = char[9]]}}
> >> > > >> >>> +// expected-note at -3{{candidate template ignored:
> constraints not satisfied [with T = char[20]]}}
> >> > > >> >>> +// expected-note at -4{{because 'sizeof(char[9]) <= 8' (9 <=
> 8) evaluated to false}}
> >> > > >> >>>
> >> > > >> >>> void bar() {
> >> > > >> >>> foo<char>(); // expected-error{{no matching function for
> call to 'foo'}}
> >> > > >> >>> @@ -15,4 +15,4 @@ void bar() {
> >> > > >> >>> foo<unsigned long long int>();
> >> > > >> >>> foo<char[9]>(); // expected-error{{no matching function
> for call to 'foo'}}
> >> > > >> >>> foo<char[20]>(); // expected-error{{no matching function
> for call to 'foo'}}
> >> > > >> >>> -}
> >> > > >> >>> \ No newline at end of file
> >> > > >> >>> +}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/expr/expr.prim/
> expr.prim.id/p4.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.id/p4.cpp
> >> > > >> >>> index d3dde10ff2b2d..3c6b1b1bac590 100644
> >> > > >> >>> --- a/clang/test/CXX/expr/expr.prim/expr.prim.id/p4.cpp
> >> > > >> >>> +++ b/clang/test/CXX/expr/expr.prim/expr.prim.id/p4.cpp
> >> > > >> >>> @@ -24,7 +24,7 @@ namespace methods
> >> > > >> >>> {
> >> > > >> >>> template<typename T>
> >> > > >> >>> struct A {
> >> > > >> >>> - static void foo(int) requires (sizeof(T) == 1) {} //
> expected-note 3{{because 'sizeof(char [2]) == 1' (2 == 1) evaluated to
> false}}
> >> > > >> >>> + static void foo(int) requires (sizeof(T) == 1) {} //
> expected-note 3{{because 'sizeof(char[2]) == 1' (2 == 1) evaluated to
> false}}
> >> > > >> >>> static void bar(int) requires (sizeof(T) == 2) {} //
> expected-note 3{{because 'sizeof(char) == 2' (1 == 2) evaluated to false}}
> >> > > >> >>> // Make sure the function body is not instantiated
> before constraints are checked.
> >> > > >> >>> static auto baz(int) requires (sizeof(T) == 2) { return
> T::foo(); } // expected-note{{because 'sizeof(char) == 2' (1 == 2)
> evaluated to false}}
> >> > > >> >>> @@ -58,4 +58,4 @@ namespace operators
> >> > > >> >>> auto* x = &A<int>::operator-; //
> expected-error{{invalid reference to function 'operator-': constraints not
> satisfied}}
> >> > > >> >>> auto y = &A<char>::operator-;
> >> > > >> >>> }
> >> > > >> >>> -}
> >> > > >> >>> \ No newline at end of file
> >> > > >> >>> +}
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp
> b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp
> >> > > >> >>> index a36175af6fec5..5f7f73d622d82 100644
> >> > > >> >>> --- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp
> >> > > >> >>> +++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp
> >> > > >> >>> @@ -48,5 +48,5 @@ void test_result_type(int N) {
> >> > > >> >>> auto l1 = [] () -> Incomplete { }; //
> expected-error{{incomplete result type 'Incomplete' in lambda expression}}
> >> > > >> >>>
> >> > > >> >>> typedef int vla[N];
> >> > > >> >>> - auto l2 = [] () -> vla { }; // expected-error{{function
> cannot return array type 'vla' (aka 'int [N]')}}
> >> > > >> >>> + auto l2 = [] () -> vla { }; // expected-error{{function
> cannot return array type 'vla' (aka 'int[N]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/special/class.copy/p23-cxx11.cpp
> b/clang/test/CXX/special/class.copy/p23-cxx11.cpp
> >> > > >> >>> index 0b9652b50fcfb..3e2341c3331fb 100644
> >> > > >> >>> --- a/clang/test/CXX/special/class.copy/p23-cxx11.cpp
> >> > > >> >>> +++ b/clang/test/CXX/special/class.copy/p23-cxx11.cpp
> >> > > >> >>> @@ -78,7 +78,7 @@ struct B1 {
> >> > > >> >>> const int a; // expected-note 2{{field 'a' is of
> const-qualified type}}
> >> > > >> >>> };
> >> > > >> >>> struct B2 {
> >> > > >> >>> - const void *const a[3][9][2]; // expected-note 2{{field
> 'a' is of const-qualified type 'const void *const [3][9][2]'}}
> >> > > >> >>> + const void *const a[3][9][2]; // expected-note 2{{field
> 'a' is of const-qualified type 'const void *const[3][9][2]'}}
> >> > > >> >>> };
> >> > > >> >>> struct B3 {
> >> > > >> >>> const void *a[3];
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/special/class.ctor/p5-0x.cpp
> b/clang/test/CXX/special/class.ctor/p5-0x.cpp
> >> > > >> >>> index 5fa61008e8b77..67f0d2a935744 100644
> >> > > >> >>> --- a/clang/test/CXX/special/class.ctor/p5-0x.cpp
> >> > > >> >>> +++ b/clang/test/CXX/special/class.ctor/p5-0x.cpp
> >> > > >> >>> @@ -57,7 +57,7 @@ class Deleted3a { const int a; }; //
> expected-note {{because field 'a' of const-
> >> > > >> >>> expected-warning
> {{does not declare any constructor}} \
> >> > > >> >>> expected-note {{will
> never be initialized}}
> >> > > >> >>> Deleted3a d3a; // expected-error {{implicitly-deleted
> default constructor}}
> >> > > >> >>> -class Deleted3b { const DefaultedDefCtor1 a[42]; }; //
> expected-note {{because field 'a' of const-qualified type 'const
> DefaultedDefCtor1 [42]' would not be initialized}}
> >> > > >> >>> +class Deleted3b { const DefaultedDefCtor1 a[42]; }; //
> expected-note {{because field 'a' of const-qualified type 'const
> DefaultedDefCtor1[42]' would not be initialized}}
> >> > > >> >>> Deleted3b d3b; // expected-error {{implicitly-deleted
> default constructor}}
> >> > > >> >>> class Deleted3c { const DefaultedDefCtor2 a; }; //
> expected-note {{because field 'a' of const-qualified type 'const
> DefaultedDefCtor2' would not be initialized}}
> >> > > >> >>> Deleted3c d3c; // expected-error {{implicitly-deleted
> default constructor}}
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp
> b/clang/test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp
> >> > > >> >>> index 1c6aeeefe0067..d6d171470c21d 100644
> >> > > >> >>> --- a/clang/test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp
> >> > > >> >>> +++ b/clang/test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp
> >> > > >> >>> @@ -121,10 +121,10 @@ void g() {
> >> > > >> >>> ;
> >> > > >> >>>
> >> > > >> >>> extern int incomplete[];
> >> > > >> >>> - for (auto a : incomplete) // expected-error {{cannot use
> incomplete type 'int []' as a range}}
> >> > > >> >>> + for (auto a : incomplete) // expected-error {{cannot use
> incomplete type 'int[]' as a range}}
> >> > > >> >>> ;
> >> > > >> >>> extern struct Incomplete also_incomplete[2]; //
> expected-note 2{{forward declaration}}
> >> > > >> >>> - for (auto &a : also_incomplete) // expected-error
> {{cannot use incomplete type 'struct Incomplete [2]' as a range}}
> >> > > >> >>> + for (auto &a : also_incomplete) // expected-error
> {{cannot use incomplete type 'struct Incomplete[2]' as a range}}
> >> > > >> >>> ;
> >> > > >> >>>
> >> > > >> >>> struct VoidBegin {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
> b/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
> >> > > >> >>> index 58290ac40fdb0..47bb95f2c024d 100644
> >> > > >> >>> --- a/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
> >> > > >> >>> +++ b/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
> >> > > >> >>> @@ -113,7 +113,7 @@ namespace addr_of_obj_or_func {
> >> > > >> >>>
> >> > > >> >>> X2<i> x2a;
> >> > > >> >>> X2<&i> x2a_addr; // expected-error {{address taken}}
> >> > > >> >>> - X2<iarr> x2b; // expected-error {{cannot bind to
> template argument of type 'int [10]'}}
> >> > > >> >>> + X2<iarr> x2b; // expected-error {{cannot bind to
> template argument of type 'int[10]'}}
> >> > > >> >>> X2<&iarr> x2b_addr; // expected-error {{address taken}}
> >> > > >> >>> X2<ki> x2c; // expected-error {{ignores qualifiers}}
> >> > > >> >>> #if __cplusplus <= 199711L
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp
> b/clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp
> >> > > >> >>> index 7d4d858b286f0..dd6bfe8011ddf 100644
> >> > > >> >>> ---
> a/clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp
> >> > > >> >>> +++
> b/clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp
> >> > > >> >>> @@ -9,20 +9,20 @@ static_assert(A<int>::value == 4);
> >> > > >> >>> static_assert(A<char>::value == 1); //
> expected-error{{constraints not satisfied for class template 'A' [with T =
> char]}}
> >> > > >> >>>
> >> > > >> >>> template<typename T, typename U>
> >> > > >> >>> - requires (sizeof(T) != sizeof(U) //
> expected-note{{because 'sizeof(int) != sizeof(char [4])' (4 != 4) evaluated
> to false}}
> >> > > >> >>> + requires (sizeof(T) != sizeof(U) //
> expected-note{{because 'sizeof(int) != sizeof(char[4])' (4 != 4) evaluated
> to false}}
> >> > > >> >>> && sizeof(T) >= 4) // expected-note{{because
> 'sizeof(char) >= 4' (1 >= 4) evaluated to false}}
> >> > > >> >>> constexpr int SizeDiff = sizeof(T) > sizeof(U) ? sizeof(T)
> - sizeof(U) : sizeof(U) - sizeof(T);
> >> > > >> >>>
> >> > > >> >>> static_assert(SizeDiff<int, char> == 3);
> >> > > >> >>> -static_assert(SizeDiff<int, char[4]> == 0); //
> expected-error{{constraints not satisfied for variable template 'SizeDiff'
> [with T = int, U = char [4]]}}
> >> > > >> >>> +static_assert(SizeDiff<int, char[4]> == 0); //
> expected-error{{constraints not satisfied for variable template 'SizeDiff'
> [with T = int, U = char[4]]}}
> >> > > >> >>> static_assert(SizeDiff<char, int> == 3); //
> expected-error{{constraints not satisfied for variable template 'SizeDiff'
> [with T = char, U = int]}}
> >> > > >> >>>
> >> > > >> >>> template<typename... Ts>
> >> > > >> >>> - requires ((sizeof(Ts) == 4) || ...) //
> expected-note{{because 'sizeof(char) == 4' (1 == 4) evaluated to false}}
> expected-note{{'sizeof(long long) == 4' (8 == 4) evaluated to false}}
> expected-note{{'sizeof(int [20]) == 4' (80 == 4) evaluated to false}}
> >> > > >> >>> + requires ((sizeof(Ts) == 4) || ...) //
> expected-note{{because 'sizeof(char) == 4' (1 == 4) evaluated to false}}
> expected-note{{'sizeof(long long) == 4' (8 == 4) evaluated to false}}
> expected-note{{'sizeof(int[20]) == 4' (80 == 4) evaluated to false}}
> >> > > >> >>> constexpr auto SumSizes = (sizeof(Ts) + ...);
> >> > > >> >>>
> >> > > >> >>> static_assert(SumSizes<char, long long, int> == 13);
> >> > > >> >>> -static_assert(SumSizes<char, long long, int[20]> == 89); //
> expected-error{{constraints not satisfied for variable template 'SumSizes'
> [with Ts = <char, long long, int [20]>]}}
> >> > > >> >>> +static_assert(SumSizes<char, long long, int[20]> == 89); //
> expected-error{{constraints not satisfied for variable template 'SumSizes'
> [with Ts = <char, long long, int[20]>]}}
> >> > > >> >>>
> >> > > >> >>> template<typename T>
> >> > > >> >>> concept IsBig = sizeof(T) > 100; // expected-note{{because
> 'sizeof(int) > 100' (4 > 100) evaluated to false}}
> >> > > >> >>> @@ -44,28 +44,28 @@ static_assert(S<S2>::value);
> >> > > >> >>> template<typename T>
> >> > > >> >>> struct AA
> >> > > >> >>> {
> >> > > >> >>> - template<typename U> requires (sizeof(U) == sizeof(T))
> // expected-note{{because 'sizeof(int [2]) == sizeof(int)' (8 == 4)
> evaluated to false}}
> >> > > >> >>> + template<typename U> requires (sizeof(U) == sizeof(T))
> // expected-note{{because 'sizeof(int[2]) == sizeof(int)' (8 == 4)
> evaluated to false}}
> >> > > >> >>> struct B
> >> > > >> >>> {
> >> > > >> >>> static constexpr int a = 0;
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> - template<typename U> requires (sizeof(U) == sizeof(T))
> // expected-note{{because 'sizeof(int [2]) == sizeof(int)' (8 == 4)
> evaluated to false}}
> >> > > >> >>> + template<typename U> requires (sizeof(U) == sizeof(T))
> // expected-note{{because 'sizeof(int[2]) == sizeof(int)' (8 == 4)
> evaluated to false}}
> >> > > >> >>> static constexpr int b = 1;
> >> > > >> >>>
> >> > > >> >>> - template<typename U> requires (sizeof(U) == sizeof(T))
> // expected-note{{because 'sizeof(int [2]) == sizeof(int)' (8 == 4)
> evaluated to false}}
> >> > > >> >>> - static constexpr int getB() { //
> expected-note{{candidate template ignored: constraints not satisfied [with
> U = int [2]]}}
> >> > > >> >>> + template<typename U> requires (sizeof(U) == sizeof(T))
> // expected-note{{because 'sizeof(int[2]) == sizeof(int)' (8 == 4)
> evaluated to false}}
> >> > > >> >>> + static constexpr int getB() { //
> expected-note{{candidate template ignored: constraints not satisfied [with
> U = int[2]]}}
> >> > > >> >>> return 2;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> static auto foo()
> >> > > >> >>> {
> >> > > >> >>> - return B<T[2]>::a; // expected-error{{constraints
> not satisfied for class template 'B' [with U = int [2]]}}
> >> > > >> >>> + return B<T[2]>::a; // expected-error{{constraints
> not satisfied for class template 'B' [with U = int[2]]}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> static auto foo1()
> >> > > >> >>> {
> >> > > >> >>> - return b<T[2]>; // expected-error{{constraints not
> satisfied for variable template 'b' [with U = int [2]]}}
> >> > > >> >>> + return b<T[2]>; // expected-error{{constraints not
> satisfied for variable template 'b' [with U = int[2]]}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> static auto foo2()
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/CXX/temp/temp.decls/temp.variadic/p2.cpp
> b/clang/test/CXX/temp/temp.decls/temp.variadic/p2.cpp
> >> > > >> >>> index e7a62366a9be5..8c2a9c1513235 100644
> >> > > >> >>> --- a/clang/test/CXX/temp/temp.decls/temp.variadic/p2.cpp
> >> > > >> >>> +++ b/clang/test/CXX/temp/temp.decls/temp.variadic/p2.cpp
> >> > > >> >>> @@ -12,11 +12,11 @@ void test() {
> >> > > >> >>> template<typename Head, typename ...Tail>
> >> > > >> >>> void recurse_until_fail(const Head &, const Tail &...tail)
> { // expected-note{{candidate function template not viable: requires at
> least 1 argument, but 0 were provided}}
> >> > > >> >>> recurse_until_fail(tail...); // expected-error{{no
> matching function for call to 'recurse_until_fail'}} \
> >> > > >> >>> - // expected-note{{in instantiation of function template
> specialization 'recurse_until_fail<char [7]>' requested here}} \
> >> > > >> >>> - // expected-note{{in instantiation of function template
> specialization 'recurse_until_fail<double, char [7]>' requested here}}
> >> > > >> >>> + // expected-note{{in instantiation of function template
> specialization 'recurse_until_fail<char[7]>' requested here}} \
> >> > > >> >>> + // expected-note{{in instantiation of function template
> specialization 'recurse_until_fail<double, char[7]>' requested here}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> void test_recurse_until_fail() {
> >> > > >> >>> - recurse_until_fail(1, 3.14159, "string"); //
> expected-note{{in instantiation of function template specialization
> 'recurse_until_fail<int, double, char [7]>' requested here}}
> >> > > >> >>> + recurse_until_fail(1, 3.14159, "string"); //
> expected-note{{in instantiation of function template specialization
> 'recurse_until_fail<int, double, char[7]>' requested here}}
> >> > > >> >>>
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/temp/temp.explicit/p8.cpp
> b/clang/test/CXX/temp/temp.explicit/p8.cpp
> >> > > >> >>> index 1f09be04afb9a..6224080588b87 100644
> >> > > >> >>> --- a/clang/test/CXX/temp/temp.explicit/p8.cpp
> >> > > >> >>> +++ b/clang/test/CXX/temp/temp.explicit/p8.cpp
> >> > > >> >>> @@ -1,13 +1,13 @@
> >> > > >> >>> // RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
> >> > > >> >>>
> >> > > >> >>> template<typename T, typename S = char> requires (sizeof(T)
> + sizeof(S) < 10)
> >> > > >> >>> -// expected-note at -1{{because 'sizeof(char [100]) +
> sizeof(char) < 10' (101 < 10) evaluated to false}}
> >> > > >> >>> +// expected-note at -1{{because 'sizeof(char[100]) +
> sizeof(char) < 10' (101 < 10) evaluated to false}}
> >> > > >> >>> void f(T t, S s) requires (sizeof(t) == 1 && sizeof(s) ==
> 1) { };
> >> > > >> >>> // expected-note at -1{{candidate template ignored:
> constraints not satisfied [with T = int, S = char]}}
> >> > > >> >>> // expected-note at -2{{because 'sizeof (t) == 1' (4 == 1)
> evaluated to false}}
> >> > > >> >>> // expected-note at -3{{candidate template ignored:
> constraints not satisfied [with T = char, S = short]}}
> >> > > >> >>> // expected-note at -4{{because 'sizeof (s) == 1' (2 == 1)
> evaluated to false}}
> >> > > >> >>> -// expected-note at -5{{candidate template ignored:
> constraints not satisfied [with T = char [100], S = char]}}
> >> > > >> >>> +// expected-note at -5{{candidate template ignored:
> constraints not satisfied [with T = char[100], S = char]}}
> >> > > >> >>>
> >> > > >> >>> template<>
> >> > > >> >>> void f<int>(int t, char s) { };
> >> > > >> >>> @@ -19,4 +19,4 @@ void f<char, short>(char t, short s) { };
> >> > > >> >>>
> >> > > >> >>> template<>
> >> > > >> >>> void f<char[100]>(char t[100], char s) { };
> >> > > >> >>> -// expected-error at -1{{no function template matches
> function template specialization 'f'}}
> >> > > >> >>> \ No newline at end of file
> >> > > >> >>> +// expected-error at -1{{no function template matches
> function template specialization 'f'}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CXX/temp/temp.param/p10-2a.cpp
> b/clang/test/CXX/temp/temp.param/p10-2a.cpp
> >> > > >> >>> index f0364274fb359..4f5fdd3b4809a 100644
> >> > > >> >>> --- a/clang/test/CXX/temp/temp.param/p10-2a.cpp
> >> > > >> >>> +++ b/clang/test/CXX/temp/temp.param/p10-2a.cpp
> >> > > >> >>> @@ -27,21 +27,21 @@ using b4 = B<short, char>; //
> expected-error {{constraints not satisfied for ali
> >> > > >> >>>
> >> > > >> >>> template<typename... T>
> >> > > >> >>> concept C3 = (sizeof(T) + ...) == 12;
> >> > > >> >>> -// expected-note at -1 {{because 'sizeof(char [11]) == 12'
> (11 == 12) evaluated to false}}
> >> > > >> >>> -// expected-note at -2 {{because 'sizeof(char [10]) == 12'
> (10 == 12) evaluated to false}}
> >> > > >> >>> +// expected-note at -1 {{because 'sizeof(char[11]) == 12' (11
> == 12) evaluated to false}}
> >> > > >> >>> +// expected-note at -2 {{because 'sizeof(char[10]) == 12' (10
> == 12) evaluated to false}}
> >> > > >> >>> // expected-note at -3 3{{because 'sizeof(int) == 12' (4 ==
> 12) evaluated to false}}
> >> > > >> >>> // expected-note at -4 6{{because 'sizeof(short) == 12' (2 ==
> 12) evaluated to false}}
> >> > > >> >>>
> >> > > >> >>> template<C3 T1, C3 T2, C3 T3>
> >> > > >> >>> -// expected-note at -1 {{because 'char [11]' does not satisfy
> 'C3'}}
> >> > > >> >>> -// expected-note at -2 {{because 'char [10]' does not satisfy
> 'C3'}}
> >> > > >> >>> +// expected-note at -1 {{because 'char[11]' does not satisfy
> 'C3'}}
> >> > > >> >>> +// expected-note at -2 {{because 'char[10]' does not satisfy
> 'C3'}}
> >> > > >> >>> using C = T2;
> >> > > >> >>>
> >> > > >> >>> using c1 = C<char[12], int[3], short[6]>;
> >> > > >> >>> using c2 = C<char[12], char[11], char[10]>;
> >> > > >> >>> -// expected-error at -1 {{constraints not satisfied for alias
> template 'C' [with T1 = char [12], T2 = char [11], T3 = char [10]]}}
> >> > > >> >>> +// expected-error at -1 {{constraints not satisfied for alias
> template 'C' [with T1 = char[12], T2 = char[11], T3 = char[10]]}}
> >> > > >> >>> using c3 = C<char[12], char[12], char[10]>;
> >> > > >> >>> -// expected-error at -1 {{constraints not satisfied for alias
> template 'C' [with T1 = char [12], T2 = char [12], T3 = char [10]]}}
> >> > > >> >>> +// expected-error at -1 {{constraints not satisfied for alias
> template 'C' [with T1 = char[12], T2 = char[12], T3 = char[10]]}}
> >> > > >> >>>
> >> > > >> >>> template<C3... Ts>
> >> > > >> >>> // expected-note at -1 {{because 'int' does not satisfy 'C3'}}
> >> > > >> >>> @@ -87,33 +87,33 @@ using f2 = F<long>; // expected-error
> {{constraints not satisfied for alias temp
> >> > > >> >>>
> >> > > >> >>> template<typename T, typename... Ts>
> >> > > >> >>> concept OneOf = (is_same_v<T, Ts> || ...);
> >> > > >> >>> -// expected-note at -1 2{{because 'is_same_v<char, char [1]>'
> evaluated to false}}
> >> > > >> >>> -// expected-note at -2 2{{and 'is_same_v<char, char [2]>'
> evaluated to false}}
> >> > > >> >>> +// expected-note at -1 2{{because 'is_same_v<char, char[1]>'
> evaluated to false}}
> >> > > >> >>> +// expected-note at -2 2{{and 'is_same_v<char, char[2]>'
> evaluated to false}}
> >> > > >> >>> // expected-note at -3 {{because 'is_same_v<short, int>'
> evaluated to false}}
> >> > > >> >>> // expected-note at -4 {{and 'is_same_v<short, long>'
> evaluated to false}}
> >> > > >> >>> // expected-note at -5 {{and 'is_same_v<short, char>'
> evaluated to false}}
> >> > > >> >>> -// expected-note at -6 3{{because 'is_same_v<int, char [1]>'
> evaluated to false}}
> >> > > >> >>> -// expected-note at -7 3{{and 'is_same_v<int, char [2]>'
> evaluated to false}}
> >> > > >> >>> +// expected-note at -6 3{{because 'is_same_v<int, char[1]>'
> evaluated to false}}
> >> > > >> >>> +// expected-note at -7 3{{and 'is_same_v<int, char[2]>'
> evaluated to false}}
> >> > > >> >>> // expected-note at -8 2{{because 'is_same_v<std::nullptr_t,
> char>' evaluated to false}}
> >> > > >> >>> // expected-note at -9 2{{and 'is_same_v<std::nullptr_t,
> int>' evaluated to false}}
> >> > > >> >>>
> >> > > >> >>> template<OneOf<char[1], char[2]> T, OneOf<int, long, char>
> U>
> >> > > >> >>> -// expected-note at -1 2{{because 'OneOf<char, char [1], char
> [2]>' evaluated to false}}
> >> > > >> >>> +// expected-note at -1 2{{because 'OneOf<char, char[1],
> char[2]>' evaluated to false}}
> >> > > >> >>> // expected-note at -2 {{because 'OneOf<short, int, long,
> char>' evaluated to false}}
> >> > > >> >>> using G = T;
> >> > > >> >>>
> >> > > >> >>> using g1 = G<char[1], int>;
> >> > > >> >>> using g2 = G<char, int>; // expected-error{{constraints not
> satisfied for alias template 'G' [with T = char, U = int]}}
> >> > > >> >>> -using g3 = G<char[1], short>; //
> expected-error{{constraints not satisfied for alias template 'G' [with T =
> char [1], U = short]}}
> >> > > >> >>> +using g3 = G<char[1], short>; //
> expected-error{{constraints not satisfied for alias template 'G' [with T =
> char[1], U = short]}}
> >> > > >> >>> using g4 = G<char, short>; // expected-error{{constraints
> not satisfied for alias template 'G' [with T = char, U = short]}}
> >> > > >> >>>
> >> > > >> >>> template<OneOf<char[1], char[2]>... Ts>
> >> > > >> >>> -// expected-note at -1 2{{because 'OneOf<int, char [1], char
> [2]>' evaluated to false}}
> >> > > >> >>> -// expected-note at -2 {{and 'OneOf<int, char [1], char [2]>'
> evaluated to false}}
> >> > > >> >>> +// expected-note at -1 2{{because 'OneOf<int, char[1],
> char[2]>' evaluated to false}}
> >> > > >> >>> +// expected-note at -2 {{and 'OneOf<int, char[1], char[2]>'
> evaluated to false}}
> >> > > >> >>> using H = int;
> >> > > >> >>>
> >> > > >> >>> using h1 = H<char[1], int>;
> >> > > >> >>> -// expected-error at -1 {{constraints not satisfied for alias
> template 'H' [with Ts = <char [1], int>]}}
> >> > > >> >>> +// expected-error at -1 {{constraints not satisfied for alias
> template 'H' [with Ts = <char[1], int>]}}
> >> > > >> >>> using h2 = H<int, int>;
> >> > > >> >>> // expected-error at -1 {{constraints not satisfied for alias
> template 'H' [with Ts = <int, int>]}}
> >> > > >> >>> using h3 = H<char[1], char[2]>;
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CodeGen/const-init.c
> b/clang/test/CodeGen/const-init.c
> >> > > >> >>> index 08783862837e8..7a0818a78a0a6 100644
> >> > > >> >>> --- a/clang/test/CodeGen/const-init.c
> >> > > >> >>> +++ b/clang/test/CodeGen/const-init.c
> >> > > >> >>> @@ -156,7 +156,7 @@ void g29() {
> >> > > >> >>> // CHECK: @g29.b = internal global [1 x i32] [i32
> ptrtoint ([5 x i8]* @.str.1 to i32)], align 4
> >> > > >> >>> // CHECK: @g29.c = internal global [1 x i32] [i32 97],
> align 4
> >> > > >> >>> static DCC_SRVR_NM a = { {"@"} };
> >> > > >> >>> - static int b[1] = { "asdf" }; // expected-warning
> {{incompatible pointer to integer conversion initializing 'int' with an
> expression of type 'char [5]'}}
> >> > > >> >>> + static int b[1] = { "asdf" }; // expected-warning
> {{incompatible pointer to integer conversion initializing 'int' with an
> expression of type 'char[5]'}}
> >> > > >> >>> static int c[1] = { L"a" };
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/CodeGen/dump-struct-builtin.c
> b/clang/test/CodeGen/dump-struct-builtin.c
> >> > > >> >>> index 929c5f71131bc..6464d7fa70d89 100644
> >> > > >> >>> --- a/clang/test/CodeGen/dump-struct-builtin.c
> >> > > >> >>> +++ b/clang/test/CodeGen/dump-struct-builtin.c
> >> > > >> >>> @@ -91,7 +91,7 @@
> >> > > >> >>>
> >> > > >> >>> // CHECK: @__const.unit15.a = private unnamed_addr constant
> %struct.U15A { [3 x i32] [i32 1, i32 2, i32 3] }, align 4
> >> > > >> >>> // CHECK-NEXT: [[STRUCT_STR_U15:@[0-9]+]] = private
> unnamed_addr constant [15 x i8] c"struct U15A {\0A\00"
> >> > > >> >>> -// CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private
> unnamed_addr constant [13 x i8] c"int [3] a : \00"
> >> > > >> >>> +// CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private
> unnamed_addr constant [12 x i8] c"int[3] a : \00"
> >> > > >> >>> // CHECK-NEXT: [[FORMAT_U15:@[0-9]+]] = private
> unnamed_addr constant [4 x i8] c"%p\0A\00"
> >> > > >> >>> // CHECK-NEXT: [[END_STRUCT_U15:@[0-9]+]] = private
> unnamed_addr constant [3 x i8] c"}\0A\00"
> >> > > >> >>>
> >> > > >> >>> @@ -380,7 +380,7 @@ void unit15() {
> >> > > >> >>>
> >> > > >> >>> // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr
> inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U15]], i32 0, i32 0))
> >> > > >> >>> // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds
> %struct.U15A, %struct.U15A* %a, i32 0, i32 0
> >> > > >> >>> - // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr
> inbounds ([13 x i8], [13 x i8]* [[FIELD_U15]], i32 0, i32 0))
> >> > > >> >>> + // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr
> inbounds ([12 x i8], [12 x i8]* [[FIELD_U15]], i32 0, i32 0))
> >> > > >> >>> // CHECK: [[LOAD1:%[0-9]+]] = load [3 x i32], [3 x i32]*
> [[RES1]],
> >> > > >> >>> // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr
> inbounds ([4 x i8], [4 x i8]* [[FORMAT_U15]], i32 0, i32 0), [3 x i32]
> [[LOAD1]])
> >> > > >> >>> // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr
> inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U15]], i32 0, i32 0)
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Import/array-init-loop-expr/test.cpp
> b/clang/test/Import/array-init-loop-expr/test.cpp
> >> > > >> >>> index 7fe109c305ddd..653f68140d5a5 100644
> >> > > >> >>> --- a/clang/test/Import/array-init-loop-expr/test.cpp
> >> > > >> >>> +++ b/clang/test/Import/array-init-loop-expr/test.cpp
> >> > > >> >>> @@ -1,7 +1,7 @@
> >> > > >> >>> // RUN: clang-import-test -dump-ast -import %S/Inputs/S.cpp
> -expression %s | FileCheck %s
> >> > > >> >>> // CHECK: CXXCtorInitializer
> >> > > >> >>> // CHECK-NEXT: ArrayInitLoopExpr
> >> > > >> >>> -// CHECK-SAME: 'int [10]'
> >> > > >> >>> +// CHECK-SAME: 'int[10]'
> >> > > >> >>>
> >> > > >> >>> // CHECK: ArrayInitIndexExpr
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Index/print-type-size.cpp
> b/clang/test/Index/print-type-size.cpp
> >> > > >> >>> index b4098d97726c4..c61965004000b 100644
> >> > > >> >>> --- a/clang/test/Index/print-type-size.cpp
> >> > > >> >>> +++ b/clang/test/Index/print-type-size.cpp
> >> > > >> >>> @@ -368,7 +368,7 @@ struct BaseStruct
> >> > > >> >>> namespace NotConstantSize {
> >> > > >> >>>
> >> > > >> >>> void f(int i) {
> >> > > >> >>> -// CHECK32: VarDecl=v2:[[@LINE+1]]:8 (Definition) [type=int
> [i]] [typekind=VariableArray] [sizeof=-4] [alignof=4]
> >> > > >> >>> +// CHECK32: VarDecl=v2:[[@LINE+1]]:8 (Definition)
> [type=int[i]] [typekind=VariableArray] [sizeof=-4] [alignof=4]
> >> > > >> >>> int v2[i];
> >> > > >> >>> {
> >> > > >> >>> struct CS1 {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Index/print-type.c
> b/clang/test/Index/print-type.c
> >> > > >> >>> index 745b661113ca0..c976e28e3321f 100644
> >> > > >> >>> --- a/clang/test/Index/print-type.c
> >> > > >> >>> +++ b/clang/test/Index/print-type.c
> >> > > >> >>> @@ -32,12 +32,12 @@ void fun(struct { int x; int y; }
> *param);
> >> > > >> >>> _Atomic(unsigned long) aul;
> >> > > >> >>>
> >> > > >> >>> // RUN: c-index-test -test-print-type %s | FileCheck %s
> >> > > >> >>> -// CHECK: FunctionDecl=f:3:6 (Definition) [type=int *(int
> *, char *, FooType, int *, void (*)(int))] [typekind=FunctionProto]
> [canonicaltype=int *(int *, char *, int, int *, void (*)(int))]
> [canonicaltypekind=FunctionProto] [resulttype=int *]
> [resulttypekind=Pointer] [args= [int *] [Pointer] [char *] [Pointer]
> [FooType] [Typedef] [int [5]] [ConstantArray] [void (*)(int)] [Pointer]]
> [isPOD=0]
> >> > > >> >>> +// CHECK: FunctionDecl=f:3:6 (Definition) [type=int *(int
> *, char *, FooType, int *, void (*)(int))] [typekind=FunctionProto]
> [canonicaltype=int *(int *, char *, int, int *, void (*)(int))]
> [canonicaltypekind=FunctionProto] [resulttype=int *]
> [resulttypekind=Pointer] [args= [int *] [Pointer] [char *] [Pointer]
> [FooType] [Typedef] [int[5]] [ConstantArray] [void (*)(int)] [Pointer]]
> [isPOD=0]
> >> > > >> >>> // CHECK: ParmDecl=p:3:13 (Definition) [type=int *]
> [typekind=Pointer] [isPOD=1] [pointeetype=int] [pointeekind=Int]
> >> > > >> >>> // CHECK: ParmDecl=x:3:22 (Definition) [type=char *]
> [typekind=Pointer] [isPOD=1] [pointeetype=char] [pointeekind=Char_{{[US]}}]
> >> > > >> >>> // CHECK: ParmDecl=z:3:33 (Definition) [type=FooType]
> [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
> >> > > >> >>> // CHECK: TypeRef=FooType:1:13 [type=FooType]
> [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
> >> > > >> >>> -// CHECK: ParmDecl=arr:3:40 (Definition) [type=int [5]]
> [typekind=ConstantArray] [isPOD=1]
> >> > > >> >>> +// CHECK: ParmDecl=arr:3:40 (Definition) [type=int[5]]
> [typekind=ConstantArray] [isPOD=1]
> >> > > >> >>> // CHECK: IntegerLiteral= [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> // CHECK: ParmDecl=fn:3:55 (Definition) [type=void
> (*)(int)] [typekind=Pointer] [canonicaltype=void (*)(int)]
> [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=void (int)]
> [pointeekind=FunctionProto]
> >> > > >> >>> // CHECK: ParmDecl=:3:62 (Definition) [type=int]
> [typekind=Int] [isPOD=1]
> >> > > >> >>> @@ -56,14 +56,14 @@ _Atomic(unsigned long) aul;
> >> > > >> >>> // CHECK: DeclRefExpr=p:3:13 [type=int *]
> [typekind=Pointer] [isPOD=1] [pointeetype=int] [pointeekind=Int]
> >> > > >> >>> // CHECK: DeclRefExpr=z:3:33 [type=FooType]
> [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
> >> > > >> >>> // CHECK: ArraySubscriptExpr= [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> -// CHECK: UnexposedExpr=arr:3:40 [type=int [5]]
> [typekind=ConstantArray] [isPOD=1]
> >> > > >> >>> +// CHECK: UnexposedExpr=arr:3:40 [type=int[5]]
> [typekind=ConstantArray] [isPOD=1]
> >> > > >> >>> // CHECK: IntegerLiteral= [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> // CHECK: TypedefDecl=OtherType:8:16 (Definition)
> [type=OtherType] [typekind=Typedef] [canonicaltype=double]
> [canonicaltypekind=Double] [isPOD=1]
> >> > > >> >>> -// CHECK: TypedefDecl=ArrayType:9:13 (Definition)
> [type=ArrayType] [typekind=Typedef] [canonicaltype=int [5]]
> [canonicaltypekind=ConstantArray] [isPOD=1]
> >> > > >> >>> +// CHECK: TypedefDecl=ArrayType:9:13 (Definition)
> [type=ArrayType] [typekind=Typedef] [canonicaltype=int[5]]
> [canonicaltypekind=ConstantArray] [isPOD=1]
> >> > > >> >>> // CHECK: IntegerLiteral= [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> // CHECK: VarDecl=x:10:38
> [type=__attribute__((__vector_size__(4 * sizeof(int)))) int]
> [typekind=Vector] [isPOD=1]
> >> > > >> >>> // CHECK: TypedefDecl=int4_t:11:46 (Definition)
> [type=int4_t] [typekind=Typedef]
> [canonicaltype=__attribute__((__vector_size__(4 * sizeof(int)))) int]
> [canonicaltypekind=Vector] [isPOD=1]
> >> > > >> >>> -// CHECK: ParmDecl=incompletearray:13:12 (Definition)
> [type=int []] [typekind=IncompleteArray] [isPOD=1]
> >> > > >> >>> +// CHECK: ParmDecl=incompletearray:13:12 (Definition)
> [type=int[]] [typekind=IncompleteArray] [isPOD=1]
> >> > > >> >>> // CHECK: FunctionDecl=elaboratedEnumType:15:25 [type=enum
> Enum ()] [typekind=FunctionNoProto] [canonicaltype=enum Enum ()]
> [canonicaltypekind=FunctionNoProto] [resulttype=enum Enum]
> [resulttypekind=Elaborated] [isPOD=0]
> >> > > >> >>> // CHECK: TypeRef=enum Enum:15:6 [type=enum Enum]
> [typekind=Enum] [isPOD=1]
> >> > > >> >>> // CHECK: StructDecl=Struct:16:8 (Definition) [type=struct
> Struct] [typekind=Record] [isPOD=1]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Index/print-type.cpp
> b/clang/test/Index/print-type.cpp
> >> > > >> >>> index 18259e80ebac2..f52ee8092e8f3 100644
> >> > > >> >>> --- a/clang/test/Index/print-type.cpp
> >> > > >> >>> +++ b/clang/test/Index/print-type.cpp
> >> > > >> >>> @@ -130,7 +130,7 @@ inline namespace InlineNS {}
> >> > > >> >>> // CHECK: UnexposedExpr=z:22:35
> [type=outer::inner::Bar::FooType] [typekind=Typedef] [canonicaltype=int]
> [canonicaltypekind=Int] [isPOD=1]
> >> > > >> >>> // CHECK: DeclRefExpr=z:22:35
> [type=outer::inner::Bar::FooType] [typekind=Typedef] [canonicaltype=int]
> [canonicaltypekind=Int] [isPOD=1]
> >> > > >> >>> // CHECK: TypedefDecl=OtherType:26:18 (Definition)
> [type=outer::inner::Bar::OtherType] [typekind=Typedef]
> [canonicaltype=double] [canonicaltypekind=Double] [isPOD=1]
> >> > > >> >>> -// CHECK: TypedefDecl=ArrayType:27:15 (Definition)
> [type=outer::inner::Bar::ArrayType] [typekind=Typedef] [canonicaltype=int
> [5]] [canonicaltypekind=ConstantArray] [isPOD=1]
> >> > > >> >>> +// CHECK: TypedefDecl=ArrayType:27:15 (Definition)
> [type=outer::inner::Bar::ArrayType] [typekind=Typedef]
> [canonicaltype=int[5]] [canonicaltypekind=ConstantArray] [isPOD=1]
> >> > > >> >>> // CHECK: IntegerLiteral= [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> // CHECK: FieldDecl=baz:28:20 (Definition) [type=Baz<int,
> 1, outer::Foo>] [typekind=Unexposed] [templateargs/3= [type=int]
> [typekind=Int]] [canonicaltype=outer::Baz<int, 1, outer::Foo>]
> [canonicaltypekind=Record] [canonicaltemplateargs/3= [type=int]
> [typekind=Int]] [isPOD=1]
> >> > > >> >>> // CHECK: TemplateRef=Baz:9:8 [type=] [typekind=Invalid]
> [isPOD=0]
> >> > > >> >>> @@ -146,20 +146,20 @@ inline namespace InlineNS {}
> >> > > >> >>> // CHECK: FunctionTemplate=tbar:39:3 [type=T (int *)]
> [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int *)]
> [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed]
> [isPOD=0]
> >> > > >> >>> // CHECK: TemplateTypeParameter=T:38:20 (Definition)
> [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0]
> [canonicaltypekind=Unexposed] [isPOD=0]
> >> > > >> >>> // CHECK: TypeRef=T:38:20 [type=T] [typekind=Unexposed]
> [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
> >> > > >> >>> -// CHECK: ParmDecl=:39:11 (Definition) [type=int [5]]
> [typekind=ConstantArray] [isPOD=1]
> >> > > >> >>> +// CHECK: ParmDecl=:39:11 (Definition) [type=int[5]]
> [typekind=ConstantArray] [isPOD=1]
> >> > > >> >>> // CHECK: IntegerLiteral= [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> // CHECK: FunctionTemplate=tbar:42:3 [type=T (int *)]
> [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int *)]
> [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed]
> [isPOD=0]
> >> > > >> >>> // CHECK: TemplateTypeParameter=T:41:20 (Definition)
> [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0]
> [canonicaltypekind=Unexposed] [isPOD=0]
> >> > > >> >>> // CHECK: NonTypeTemplateParameter=size:41:27 (Definition)
> [type=int] [typekind=Int] [isPOD=1]
> >> > > >> >>> // CHECK: TypeRef=T:41:20 [type=T] [typekind=Unexposed]
> [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
> >> > > >> >>> -// CHECK: ParmDecl=:42:11 (Definition) [type=int [size]]
> [typekind=DependentSizedArray] [isPOD=0]
> >> > > >> >>> +// CHECK: ParmDecl=:42:11 (Definition) [type=int[size]]
> [typekind=DependentSizedArray] [isPOD=0]
> >> > > >> >>> // CHECK: DeclRefExpr=size:41:27 [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> -// CHECK: FunctionDecl=foo:44:6 (Definition) [type=void
> (int, int *)] [typekind=FunctionProto] [canonicaltype=void (int, int *)]
> [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void]
> [args= [int] [Int] [int []] [IncompleteArray]] [isPOD=0]
> >> > > >> >>> +// CHECK: FunctionDecl=foo:44:6 (Definition) [type=void
> (int, int *)] [typekind=FunctionProto] [canonicaltype=void (int, int *)]
> [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void]
> [args= [int] [Int] [int[]] [IncompleteArray]] [isPOD=0]
> >> > > >> >>> // CHECK: ParmDecl=i:44:14 (Definition) [type=int]
> [typekind=Int] [isPOD=1]
> >> > > >> >>> -// CHECK: ParmDecl=incomplete_array:44:21 (Definition)
> [type=int []] [typekind=IncompleteArray] [isPOD=1]
> >> > > >> >>> +// CHECK: ParmDecl=incomplete_array:44:21 (Definition)
> [type=int[]] [typekind=IncompleteArray] [isPOD=1]
> >> > > >> >>> // CHECK: CompoundStmt= [type=] [typekind=Invalid] [isPOD=0]
> >> > > >> >>> // CHECK: DeclStmt= [type=] [typekind=Invalid] [isPOD=0]
> >> > > >> >>> -// CHECK: VarDecl=variable_array:44:47 (Definition)
> [type=int [i]] [typekind=VariableArray] [isPOD=1]
> >> > > >> >>> +// CHECK: VarDecl=variable_array:44:47 (Definition)
> [type=int[i]] [typekind=VariableArray] [isPOD=1]
> >> > > >> >>> // CHECK: DeclRefExpr=i:44:14 [type=int] [typekind=Int]
> [isPOD=1]
> >> > > >> >>> // CHECK: StructDecl=Blob:46:8 (Definition) [type=Blob]
> [typekind=Record] [isPOD=1] [nbFields=2]
> >> > > >> >>> // CHECK: FieldDecl=i:47:7 (Definition) [type=int]
> [typekind=Int] [isPOD=1]
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Layout/aix-Wpacked-expecting-diagnostics.cpp
> b/clang/test/Layout/aix-Wpacked-expecting-diagnostics.cpp
> >> > > >> >>> index 1980c04877c51..37982fcb74b96 100644
> >> > > >> >>> --- a/clang/test/Layout/aix-Wpacked-expecting-diagnostics.cpp
> >> > > >> >>> +++ b/clang/test/Layout/aix-Wpacked-expecting-diagnostics.cpp
> >> > > >> >>> @@ -22,9 +22,9 @@ int b = sizeof(C);
> >> > > >> >>>
> >> > > >> >>> // CHECK: 0 | struct C
> >> > > >> >>> // CHECK-NEXT: 0 | struct B (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [8] x
> >> > > >> >>> +// CHECK-NEXT: 0 | char[8] x
> >> > > >> >>> // CHECK-NEXT: 8 | struct A (base)
> >> > > >> >>> // CHECK-NEXT: 8 | double d
> >> > > >> >>> -// CHECK-NEXT: 16 | char [8] x
> >> > > >> >>> +// CHECK-NEXT: 16 | char[8] x
> >> > > >> >>> // CHECK-NEXT: | [sizeof=24, dsize=24, align=4,
> preferredalign=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=24, nvalign=4,
> preferrednvalign=4]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/aix-double-struct-member.cpp
> b/clang/test/Layout/aix-double-struct-member.cpp
> >> > > >> >>> index 32466259d31b6..6e091fcb1b1e1 100644
> >> > > >> >>> --- a/clang/test/Layout/aix-double-struct-member.cpp
> >> > > >> >>> +++ b/clang/test/Layout/aix-double-struct-member.cpp
> >> > > >> >>> @@ -196,14 +196,14 @@ int a = sizeof(A);
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct test6::A::B
> >> > > >> >>> -// CHECK-NEXT: 0 | double [3] d
> >> > > >> >>> +// CHECK-NEXT: 0 | double[3] d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=24, dsize=24, align=4,
> preferredalign=8,
> >> > > >> >>> // CHECK-NEXT: | nvsize=24, nvalign=4,
> preferrednvalign=8]
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct test6::A
> >> > > >> >>> // CHECK-NEXT: 0 | struct test6::A::B b
> >> > > >> >>> -// CHECK-NEXT: 0 | double [3] d
> >> > > >> >>> +// CHECK-NEXT: 0 | double[3] d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=24, dsize=24, align=4,
> preferredalign=8,
> >> > > >> >>> // CHECK-NEXT: | nvsize=24, nvalign=4,
> preferrednvalign=8]
> >> > > >> >>>
> >> > > >> >>> @@ -220,14 +220,14 @@ int a = sizeof(A);
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct test7::A::B
> >> > > >> >>> -// CHECK-NEXT: 0 | _Complex long double [3] d
> >> > > >> >>> +// CHECK-NEXT: 0 | _Complex long double[3] d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=48, dsize=48, align=4,
> preferredalign=8,
> >> > > >> >>> // CHECK-NEXT: | nvsize=48, nvalign=4,
> preferrednvalign=8]
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct test7::A
> >> > > >> >>> // CHECK-NEXT: 0 | struct test7::A::B b
> >> > > >> >>> -// CHECK-NEXT: 0 | _Complex long double [3] d
> >> > > >> >>> +// CHECK-NEXT: 0 | _Complex long double[3] d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=48, dsize=48, align=4,
> preferredalign=8,
> >> > > >> >>> // CHECK-NEXT: | nvsize=48, nvalign=4,
> preferrednvalign=8]
> >> > > >> >>>
> >> > > >> >>> @@ -284,14 +284,14 @@ int b = sizeof(D);
> >> > > >> >>>
> >> > > >> >>> // CHECK: 0 | struct test9::B
> >> > > >> >>> // CHECK-NEXT: 0 | struct test9::A (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [0] zea
> >> > > >> >>> +// CHECK-NEXT: 0 | char[0] zea
> >> > > >> >>> // CHECK-NEXT: 0 | double d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=8, dsize=8, align=4,
> preferredalign=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=8, nvalign=4,
> preferrednvalign=4]
> >> > > >> >>>
> >> > > >> >>> // CHECK: 0 | struct test9::D
> >> > > >> >>> // CHECK-NEXT: 0 | struct test9::A (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [0] zea
> >> > > >> >>> +// CHECK-NEXT: 0 | char[0] zea
> >> > > >> >>> // CHECK-NEXT: 0 | struct test9::C (base)
> >> > > >> >>> // CHECK-NEXT: 0 | double d
> >> > > >> >>> // CHECK-NEXT: 8 | char x
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Layout/aix-no-unique-address-with-double.cpp
> b/clang/test/Layout/aix-no-unique-address-with-double.cpp
> >> > > >> >>> index 5188bf128bc50..470f4dfcb01fd 100644
> >> > > >> >>> --- a/clang/test/Layout/aix-no-unique-address-with-double.cpp
> >> > > >> >>> +++ b/clang/test/Layout/aix-no-unique-address-with-double.cpp
> >> > > >> >>> @@ -52,7 +52,7 @@ struct B1 {
> >> > > >> >>> // CHECK-NEXT: 4 | struct A a
> >> > > >> >>> // CHECK-NEXT: 4 | double d
> >> > > >> >>> // CHECK-NEXT: 12 | char c
> >> > > >> >>> -// CHECK-NEXT: 13 | char [7] ext
> >> > > >> >>> +// CHECK-NEXT: 13 | char[7] ext
> >> > > >> >>> // CHECK-NEXT: | [sizeof=20, dsize=20, align=4,
> preferredalign=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=20, nvalign=4,
> preferrednvalign=4]
> >> > > >> >>>
> >> > > >> >>> @@ -85,7 +85,7 @@ struct C1 {
> >> > > >> >>> // CHECK-NEXT: 0 | struct A a
> >> > > >> >>> // CHECK-NEXT: 0 | double d
> >> > > >> >>> // CHECK-NEXT: 8 | char c
> >> > > >> >>> -// CHECK-NEXT: 9 | char [7] ext
> >> > > >> >>> +// CHECK-NEXT: 9 | char[7] ext
> >> > > >> >>> // CHECK-NEXT: | [sizeof=16, dsize=16, align=4,
> preferredalign=8,
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4,
> preferrednvalign=8]
> >> > > >> >>>
> >> > > >> >>> @@ -118,7 +118,7 @@ struct D1 {
> >> > > >> >>> // CHECK-NEXT: 4 | struct A a
> >> > > >> >>> // CHECK-NEXT: 4 | double d
> >> > > >> >>> // CHECK-NEXT: 12 | char c
> >> > > >> >>> -// CHECK-NEXT: 13 | char [7] ext
> >> > > >> >>> +// CHECK-NEXT: 13 | char[7] ext
> >> > > >> >>> // CHECK-NEXT: | [sizeof=20, dsize=20, align=4,
> preferredalign=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=20, nvalign=4,
> preferrednvalign=4]
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Layout/aix-power-alignment-typedef.cpp
> b/clang/test/Layout/aix-power-alignment-typedef.cpp
> >> > > >> >>> index f6925c34b1712..4696c195eaac1 100644
> >> > > >> >>> --- a/clang/test/Layout/aix-power-alignment-typedef.cpp
> >> > > >> >>> +++ b/clang/test/Layout/aix-power-alignment-typedef.cpp
> >> > > >> >>> @@ -67,7 +67,7 @@ union U {
> >> > > >> >>> int x = sizeof(U);
> >> > > >> >>>
> >> > > >> >>> // CHECK: 0 | union test4::U
> >> > > >> >>> -// CHECK-NEXT: 0 | test4::Dbl [] DblArr
> >> > > >> >>> +// CHECK-NEXT: 0 | test4::Dbl[] DblArr
> >> > > >> >>> // CHECK-NEXT: 0 | char x
> >> > > >> >>> // CHECK-NEXT: | [sizeof=2, dsize=2, align=2,
> preferredalign=2,
> >> > > >> >>> // CHECK-NEXT: | nvsize=2, nvalign=2,
> preferrednvalign=2]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/ms-aligned-array.c
> b/clang/test/Layout/ms-aligned-array.c
> >> > > >> >>> index 81fbbbb62753c..7cf976ccd2be4 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-aligned-array.c
> >> > > >> >>> +++ b/clang/test/Layout/ms-aligned-array.c
> >> > > >> >>> @@ -36,17 +36,17 @@ CHECK_SIZE(C, 16);
> >> > > >> >>> // CHECK-NEXT: | [sizeof=16, align=16]
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct A
> >> > > >> >>> -// CHECK-NEXT: 0 | struct AlignedStruct [1] a
> >> > > >> >>> +// CHECK-NEXT: 0 | struct AlignedStruct[1] a
> >> > > >> >>> // CHECK-NEXT: | [sizeof=16, align=16]
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct B
> >> > > >> >>> // CHECK-NEXT: 0 | char b
> >> > > >> >>> -// CHECK-NEXT: 16 | AlignedInt [1] a
> >> > > >> >>> +// CHECK-NEXT: 16 | AlignedInt[1] a
> >> > > >> >>> // CHECK-NEXT: | [sizeof=32, align=16]
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct C
> >> > > >> >>> // CHECK-NEXT: 0 | char b
> >> > > >> >>> -// CHECK-NEXT: 16 | AlignedInt [] a
> >> > > >> >>> +// CHECK-NEXT: 16 | AlignedInt[] a
> >> > > >> >>> // CHECK-NEXT: | [sizeof=16, align=16]
> >> > > >> >>>
> >> > > >> >>> #pragma pack(pop)
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/ms-x86-basic-layout.cpp
> b/clang/test/Layout/ms-x86-basic-layout.cpp
> >> > > >> >>> index 0b49fcb0b0747..1bd85bf6057e1 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-x86-basic-layout.cpp
> >> > > >> >>> +++ b/clang/test/Layout/ms-x86-basic-layout.cpp
> >> > > >> >>> @@ -716,11 +716,11 @@ struct ArrayFieldOfRecords {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct ArrayFieldOfRecords{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | struct A4 [2] InlineElts
> >> > > >> >>> +// CHECK-NEXT: 0 | struct A4[2] InlineElts
> >> > > >> >>> // CHECK-NEXT: | [sizeof=8, align=4
> >> > > >> >>> // CHECK-NEXT: | nvsize=8, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct ArrayFieldOfRecords{{$}}
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | struct A4 [2] InlineElts
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | struct A4[2] InlineElts
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=8, align=4
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=8, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> @@ -729,11 +729,11 @@ struct ArrayOfArrayFieldOfRecords {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct ArrayOfArrayFieldOfRecords{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | struct A4 [2][2] InlineElts
> >> > > >> >>> +// CHECK-NEXT: 0 | struct A4[2][2] InlineElts
> >> > > >> >>> // CHECK-NEXT: | [sizeof=16, align=4
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct
> ArrayOfArrayFieldOfRecords{{$}}
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | struct A4 [2][2] InlineElts
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | struct A4[2][2] InlineElts
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=16, align=4
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> @@ -743,11 +743,11 @@ struct RecordArrayTypedef {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct RecordArrayTypedef{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | RecordArrayTypedef::ArrayTy [2]
> InlineElts
> >> > > >> >>> +// CHECK-NEXT: 0 | RecordArrayTypedef::ArrayTy[2]
> InlineElts
> >> > > >> >>> // CHECK-NEXT: | [sizeof=16, align=4
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct RecordArrayTypedef{{$}}
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | RecordArrayTypedef::ArrayTy [2]
> InlineElts
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | RecordArrayTypedef::ArrayTy[2]
> InlineElts
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=16, align=4
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> @@ -756,11 +756,11 @@ struct EmptyIntMemb {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct EmptyIntMemb{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | int [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | int[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=1, align=4
> >> > > >> >>> // CHECK-NEXT: | nvsize=0, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct EmptyIntMemb{{$}}
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | int [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | int[0] FlexArrayMemb
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=4, align=4
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=0, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> @@ -769,11 +769,11 @@ struct EmptyLongLongMemb {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct EmptyLongLongMemb{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=1, align=8
> >> > > >> >>> // CHECK-NEXT: | nvsize=0, nvalign=8]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct EmptyLongLongMemb{{$}}
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=8, align=8
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=0, nvalign=8]
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/ms-x86-empty-layout.c
> b/clang/test/Layout/ms-x86-empty-layout.c
> >> > > >> >>> index 5dbd8446597ef..dfcbb851977ed 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-x86-empty-layout.c
> >> > > >> >>> +++ b/clang/test/Layout/ms-x86-empty-layout.c
> >> > > >> >>> @@ -8,7 +8,7 @@ struct EmptyIntMemb {
> >> > > >> >>> };
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct EmptyIntMemb
> >> > > >> >>> -// CHECK-NEXT: 0 | int [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | int[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=4, align=4
> >> > > >> >>>
> >> > > >> >>> struct EmptyLongLongMemb {
> >> > > >> >>> @@ -16,7 +16,7 @@ struct EmptyLongLongMemb {
> >> > > >> >>> };
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct EmptyLongLongMemb
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=4, align=8
> >> > > >> >>>
> >> > > >> >>> struct EmptyAligned2LongLongMemb {
> >> > > >> >>> @@ -25,7 +25,7 @@ struct EmptyAligned2LongLongMemb {
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct EmptyAligned2LongLongMemb
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=4, align=8
> >> > > >> >>>
> >> > > >> >>> struct EmptyAligned8LongLongMemb {
> >> > > >> >>> @@ -34,7 +34,7 @@ struct EmptyAligned8LongLongMemb {
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct EmptyAligned8LongLongMemb
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=8, align=8
> >> > > >> >>>
> >> > > >> >>> #pragma pack(1)
> >> > > >> >>> @@ -45,7 +45,7 @@ struct __declspec(align(4))
> EmptyPackedAligned4LongLongMemb {
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct EmptyPackedAligned4LongLongMemb
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=4, align=4
> >> > > >> >>>
> >> > > >> >>> #pragma pack(1)
> >> > > >> >>> @@ -56,7 +56,7 @@ struct EmptyPackedAligned8LongLongMemb {
> >> > > >> >>>
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct EmptyPackedAligned8LongLongMemb
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=8, align=8
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
> b/clang/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
> >> > > >> >>> index b4ea0e447b25a..41658f6a11e54 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
> >> > > >> >>> +++ b/clang/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
> >> > > >> >>> @@ -148,7 +148,7 @@ struct I {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct I{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | int [0] i0
> >> > > >> >>> +// CHECK-NEXT: 0 | int[0] i0
> >> > > >> >>> // CHECK-NEXT: | [sizeof={{1|4}}, align=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=0, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> @@ -158,7 +158,7 @@ struct J : I {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct J{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct I (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | int [0] i0
> >> > > >> >>> +// CHECK-NEXT: 0 | int[0] i0
> >> > > >> >>> // CHECK-NEXT: 0 | int j
> >> > > >> >>> // CHECK-NEXT: | [sizeof=4, align=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=4, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Layout/ms-x86-empty-virtual-base.cpp
> b/clang/test/Layout/ms-x86-empty-virtual-base.cpp
> >> > > >> >>> index 9b897a307953c..8c350a2a56e18 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-x86-empty-virtual-base.cpp
> >> > > >> >>> +++ b/clang/test/Layout/ms-x86-empty-virtual-base.cpp
> >> > > >> >>> @@ -572,7 +572,7 @@ struct T : virtual B0, virtual B1,
> virtual C0, virtual D2, virtual B2, virtual B
> >> > > >> >>> // CHECK-NEXT: 40 | struct C0 (virtual base)
> >> > > >> >>> // CHECK-NEXT: 40 | int a
> >> > > >> >>> // CHECK-NEXT: 44 | struct D2 (virtual base)
> >> > > >> >>> -// CHECK-NEXT: 44 | int [8] a
> >> > > >> >>> +// CHECK-NEXT: 44 | int[8] a
> >> > > >> >>> // CHECK-NEXT: 80 | struct B2 (virtual base) (empty)
> >> > > >> >>> // CHECK-NEXT: 88 | struct B3 (virtual base) (empty)
> >> > > >> >>> // CHECK-NEXT: 104 | struct B4 (virtual base) (empty)
> >> > > >> >>> @@ -586,7 +586,7 @@ struct T : virtual B0, virtual B1,
> virtual C0, virtual D2, virtual B2, virtual B
> >> > > >> >>> // CHECK-X64-NEXT: 40 | struct C0 (virtual base)
> >> > > >> >>> // CHECK-X64-NEXT: 40 | int a
> >> > > >> >>> // CHECK-X64-NEXT: 44 | struct D2 (virtual base)
> >> > > >> >>> -// CHECK-X64-NEXT: 44 | int [8] a
> >> > > >> >>> +// CHECK-X64-NEXT: 44 | int[8] a
> >> > > >> >>> // CHECK-X64-NEXT: 80 | struct B2 (virtual base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 88 | struct B3 (virtual base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 104 | struct B4 (virtual base) (empty)
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
> b/clang/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
> >> > > >> >>> index 58488ece2923b..7eb6958ce4462 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
> >> > > >> >>> +++ b/clang/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
> >> > > >> >>> @@ -33,7 +33,7 @@ struct AA : B8, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AA{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-NEXT: 13 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AA vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 16 | int a
> >> > > >> >>> @@ -42,7 +42,7 @@ struct AA : B8, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=20, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AA{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-X64-NEXT: 17 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AA vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 20 | int a
> >> > > >> >>> @@ -57,7 +57,7 @@ struct AB : B8, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AB{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-NEXT: 13 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AB vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 14 | short a
> >> > > >> >>> @@ -66,7 +66,7 @@ struct AB : B8, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AB{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-X64-NEXT: 17 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AB vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 18 | short a
> >> > > >> >>> @@ -81,7 +81,7 @@ struct AC : B8, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AC{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AC vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | char a
> >> > > >> >>> @@ -90,7 +90,7 @@ struct AC : B8, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AC{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AC vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | char a
> >> > > >> >>> @@ -104,7 +104,7 @@ struct AD : B8, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AD{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AD vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -112,7 +112,7 @@ struct AD : B8, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=12, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AD{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AD vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -126,7 +126,7 @@ struct AA1 : B9, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AA1{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-NEXT: 14 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AA1 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 16 | int a
> >> > > >> >>> @@ -135,7 +135,7 @@ struct AA1 : B9, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=20, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AA1{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-X64-NEXT: 18 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AA1 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 20 | int a
> >> > > >> >>> @@ -150,7 +150,7 @@ struct AB1 : B9, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AB1{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AB1 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | short a
> >> > > >> >>> @@ -159,7 +159,7 @@ struct AB1 : B9, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AB1{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AB1 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | short a
> >> > > >> >>> @@ -174,7 +174,7 @@ struct AC1 : B9, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AC1{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AC1 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | char a
> >> > > >> >>> @@ -183,7 +183,7 @@ struct AC1 : B9, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AC1{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AC1 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | char a
> >> > > >> >>> @@ -197,7 +197,7 @@ struct AD1 : B9, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AD1{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AD1 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -205,7 +205,7 @@ struct AD1 : B9, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=12, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AD1{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B9 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [6] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[6] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AD1 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -219,7 +219,7 @@ struct AA2 : B10, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AA2{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-NEXT: 15 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AA2 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 16 | int a
> >> > > >> >>> @@ -228,7 +228,7 @@ struct AA2 : B10, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=20, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AA2{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-X64-NEXT: 19 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AA2 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 20 | int a
> >> > > >> >>> @@ -243,7 +243,7 @@ struct AB2 : B10, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AB2{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-NEXT: 13 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AB2 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 14 | short a
> >> > > >> >>> @@ -252,7 +252,7 @@ struct AB2 : B10, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AB2{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-X64-NEXT: 17 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AB2 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 18 | short a
> >> > > >> >>> @@ -267,7 +267,7 @@ struct AC2 : B10, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AC2{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AC2 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | char a
> >> > > >> >>> @@ -276,7 +276,7 @@ struct AC2 : B10, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AC2{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AC2 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | char a
> >> > > >> >>> @@ -290,7 +290,7 @@ struct AD2 : B10, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AD2{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AD2 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -298,7 +298,7 @@ struct AD2 : B10, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=12, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AD2{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B10 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [7] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[7] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AD2 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -312,7 +312,7 @@ struct AA3 : B11, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AA3{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AA3 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | int a
> >> > > >> >>> @@ -321,7 +321,7 @@ struct AA3 : B11, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AA3{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AA3 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | int a
> >> > > >> >>> @@ -336,7 +336,7 @@ struct AB3 : B11, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AB3{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AB3 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | short a
> >> > > >> >>> @@ -345,7 +345,7 @@ struct AB3 : B11, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AB3{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AB3 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | short a
> >> > > >> >>> @@ -360,7 +360,7 @@ struct AC3 : B11, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AC3{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AC3 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | char a
> >> > > >> >>> @@ -369,7 +369,7 @@ struct AC3 : B11, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=16, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AC3{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AC3 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | char a
> >> > > >> >>> @@ -383,7 +383,7 @@ struct AD3 : B11, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct AD3{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (AD3 vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -391,7 +391,7 @@ struct AD3 : B11, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=12, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct AD3{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B11 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [8] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[8] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (AD3 vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty)
> >> > > >> >>> @@ -507,7 +507,7 @@ struct F : B1, B6, B4, B8, B5, virtual
> B0 {
> >> > > >> >>> // CHECK-NEXT: 2 | struct B6 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 3 | struct B4 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 3 | struct B8 (base)
> >> > > >> >>> -// CHECK-NEXT: 3 | char [5] c
> >> > > >> >>> +// CHECK-NEXT: 3 | char[5] c
> >> > > >> >>> // CHECK-NEXT: 12 | struct B5 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (F vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 12 | int a
> >> > > >> >>> @@ -519,7 +519,7 @@ struct F : B1, B6, B4, B8, B5, virtual
> B0 {
> >> > > >> >>> // CHECK-X64-NEXT: 2 | struct B6 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 3 | struct B4 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 3 | struct B8 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 3 | char [5] c
> >> > > >> >>> +// CHECK-X64-NEXT: 3 | char[5] c
> >> > > >> >>> // CHECK-X64-NEXT: 16 | struct B5 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (F vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 16 | int a
> >> > > >> >>> @@ -535,7 +535,7 @@ struct G : B8, B1, virtual B0 {
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct G{{$}}
> >> > > >> >>> // CHECK-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-NEXT: 21 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 8 | (G vbtable pointer)
> >> > > >> >>> // CHECK-NEXT: 24 | int a
> >> > > >> >>> @@ -545,7 +545,7 @@ struct G : B8, B1, virtual B0 {
> >> > > >> >>> // CHECK-NEXT: | nvsize=48, nvalign=16]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct G{{$}}
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct B8 (base)
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | char [5] c
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | char[5] c
> >> > > >> >>> // CHECK-X64-NEXT: 21 | struct B1 (base) (empty)
> >> > > >> >>> // CHECK-X64-NEXT: 8 | (G vbtable pointer)
> >> > > >> >>> // CHECK-X64-NEXT: 24 | int a
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/ms-x86-misalignedarray.cpp
> b/clang/test/Layout/ms-x86-misalignedarray.cpp
> >> > > >> >>> index de5bcc7c35c2d..7ca24ee6b468f 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-x86-misalignedarray.cpp
> >> > > >> >>> +++ b/clang/test/Layout/ms-x86-misalignedarray.cpp
> >> > > >> >>> @@ -11,7 +11,7 @@ struct T3 { T2 a[1]; char c; };
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-NEXT: 0 | struct T3
> >> > > >> >>> -// CHECK-NEXT: 0 | struct T2 [1] a
> >> > > >> >>> +// CHECK-NEXT: 0 | struct T2[1] a
> >> > > >> >>> // CHECK-NEXT: 5 | char c
> >> > > >> >>> // CHECK-NEXT: | [sizeof=8, align=4
> >> > > >> >>> // CHECK-NEXT: | nvsize=8, nvalign=4]
> >> > > >> >>> @@ -19,7 +19,7 @@ struct T3 { T2 a[1]; char c; };
> >> > > >> >>> // CHECK-X64: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-X64: *** Dumping AST Record Layout
> >> > > >> >>> // CHECK-X64-NEXT: 0 | struct T3
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | struct T2 [1] a
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | struct T2[1] a
> >> > > >> >>> // CHECK-X64-NEXT: 16 | char c
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=24, align=8
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=24, nvalign=8]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/ms-x86-pack-and-align.cpp
> b/clang/test/Layout/ms-x86-pack-and-align.cpp
> >> > > >> >>> index c557ebcc954dd..fc4fe17b29e3b 100644
> >> > > >> >>> --- a/clang/test/Layout/ms-x86-pack-and-align.cpp
> >> > > >> >>> +++ b/clang/test/Layout/ms-x86-pack-and-align.cpp
> >> > > >> >>> @@ -650,11 +650,11 @@ struct __declspec(align(4))
> EmptyAlignedLongLongMemb {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct EmptyAlignedLongLongMemb{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=8, align=8
> >> > > >> >>> // CHECK-NEXT: | nvsize=0, nvalign=8]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct
> EmptyAlignedLongLongMemb{{$}}
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=8, align=8
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=0, nvalign=8]
> >> > > >> >>>
> >> > > >> >>> @@ -665,11 +665,11 @@ struct __declspec(align(4))
> EmptyPackedAlignedLongLongMemb {
> >> > > >> >>> #pragma pack()
> >> > > >> >>>
> >> > > >> >>> // CHECK-LABEL: 0 | struct
> EmptyPackedAlignedLongLongMemb{{$}}
> >> > > >> >>> -// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-NEXT: | [sizeof=4, align=4
> >> > > >> >>> // CHECK-NEXT: | nvsize=0, nvalign=4]
> >> > > >> >>> // CHECK-X64-LABEL: 0 | struct
> EmptyPackedAlignedLongLongMemb{{$}}
> >> > > >> >>> -// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb
> >> > > >> >>> +// CHECK-X64-NEXT: 0 | long long[0] FlexArrayMemb
> >> > > >> >>> // CHECK-X64-NEXT: | [sizeof=4, align=4
> >> > > >> >>> // CHECK-X64-NEXT: | nvsize=0, nvalign=4]
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/no-unique-address.cpp
> b/clang/test/Layout/no-unique-address.cpp
> >> > > >> >>> index 977355b558863..d5bb46647b88d 100644
> >> > > >> >>> --- a/clang/test/Layout/no-unique-address.cpp
> >> > > >> >>> +++ b/clang/test/Layout/no-unique-address.cpp
> >> > > >> >>> @@ -154,7 +154,7 @@ namespace POD {
> >> > > >> >>> // CHECK: 0 | struct POD::B
> >> > > >> >>> // CHECK-NEXT: 0 | struct POD::A a
> >> > > >> >>> // CHECK-NEXT: 0 | int n
> >> > > >> >>> - // CHECK-NEXT: 4 | char [3] c
> >> > > >> >>> + // CHECK-NEXT: 4 | char[3] c
> >> > > >> >>> // CHECK-NEXT: 8 | char d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=12, dsize=12, align=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=12, nvalign=4]
> >> > > >> >>> @@ -169,7 +169,7 @@ namespace NonPOD {
> >> > > >> >>> // CHECK: 0 | struct NonPOD::B
> >> > > >> >>> // CHECK-NEXT: 0 | struct NonPOD::A a
> >> > > >> >>> // CHECK-NEXT: 0 | int n
> >> > > >> >>> - // CHECK-NEXT: 4 | char [3] c
> >> > > >> >>> + // CHECK-NEXT: 4 | char[3] c
> >> > > >> >>> // CHECK-NEXT: 7 | char d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=8, dsize=8, align=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=8, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Layout/watchos-standard-layout.cpp
> b/clang/test/Layout/watchos-standard-layout.cpp
> >> > > >> >>> index bd7bb1a434bdf..bf8af60fd98fb 100644
> >> > > >> >>> --- a/clang/test/Layout/watchos-standard-layout.cpp
> >> > > >> >>> +++ b/clang/test/Layout/watchos-standard-layout.cpp
> >> > > >> >>> @@ -20,7 +20,7 @@ static_assert(!__is_standard_layout(B));
> >> > > >> >>> // CHECK-NEXT: 0 | struct A (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 0:- | int
> >> > > >> >>> // CHECK-NEXT: 0 | int n
> >> > > >> >>> -// CHECK-NEXT: 4 | char [3] c
> >> > > >> >>> +// CHECK-NEXT: 4 | char[3] c
> >> > > >> >>> // CHECK-NEXT: 8 | char d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=12, dsize=9, align=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=9, nvalign=4]
> >> > > >> >>> @@ -41,7 +41,7 @@ static_assert(!__is_standard_layout(F));
> >> > > >> >>> // CHECK-NEXT: 1 | struct E (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 1 | struct D (base) (empty)
> >> > > >> >>> // CHECK-NEXT: 0 | int n
> >> > > >> >>> -// CHECK-NEXT: 4 | char [3] c
> >> > > >> >>> +// CHECK-NEXT: 4 | char[3] c
> >> > > >> >>> // CHECK-NEXT: 8 | char d
> >> > > >> >>> // CHECK-NEXT: | [sizeof=12, dsize=9, align=4,
> >> > > >> >>> // CHECK-NEXT: | nvsize=9, nvalign=4]
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Misc/diag-macro-backtrace2.c
> b/clang/test/Misc/diag-macro-backtrace2.c
> >> > > >> >>> index ca13dca074d83..b90dfa16900f2 100644
> >> > > >> >>> --- a/clang/test/Misc/diag-macro-backtrace2.c
> >> > > >> >>> +++ b/clang/test/Misc/diag-macro-backtrace2.c
> >> > > >> >>> @@ -14,7 +14,7 @@ void PR16799() {
> >> > > >> >>> const char str[] = "string";
> >> > > >> >>> a(str);
> >> > > >> >>> // CHECK: :15:3: error: invalid operands to binary
> expression
> >> > > >> >>> - // CHECK: ('const char [7]' and 'int')
> >> > > >> >>> + // CHECK: ('const char[7]' and 'int')
> >> > > >> >>> // CHECK: a(str);
> >> > > >> >>> // CHECK: ^~~~~~
> >> > > >> >>> // CHECK: :3:11: note: expanded from macro 'a'
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Misc/integer-literal-printing.cpp
> b/clang/test/Misc/integer-literal-printing.cpp
> >> > > >> >>> index 75e90be3c23ca..bd231a368fb70 100644
> >> > > >> >>> --- a/clang/test/Misc/integer-literal-printing.cpp
> >> > > >> >>> +++ b/clang/test/Misc/integer-literal-printing.cpp
> >> > > >> >>> @@ -68,12 +68,12 @@ void Function() {
> >> > > >> >>> Function1(Type1<-42>()); // expected-error{{no matching
> function for call to 'Function1'}}
> >> > > >> >>> Function2(Type2<42>()); // expected-error{{no matching
> function for call to 'Function2'}}
> >> > > >> >>>
> >> > > >> >>> - struct Type3<boolTy::b, "3"> t3; // expected-error{{value
> of type 'const char [2]' is not implicitly convertible to 'typename
> Type3Helper<(boolTy)false>::Ty' (aka 'boolTy')}}
> >> > > >> >>> -
> >> > > >> >>> - struct Type4<charTy::c, "4"> t4; // expected-error{{value
> of type 'const char [2]' is not implicitly convertible to 'typename
> Type4Helper<(charTy)'\x00'>::Ty' (aka 'charTy')}}
> >> > > >> >>> - struct Type5<scharTy::c, "5"> t5; //
> expected-error{{value of type 'const char [2]' is not implicitly
> convertible to 'typename Type5Helper<(scharTy)'\x00'>::Ty' (aka 'scharTy')}}
> >> > > >> >>> - struct Type6<ucharTy::c, "6"> t6; //
> expected-error{{value of type 'const char [2]' is not implicitly
> convertible to 'typename Type6Helper<(ucharTy)'\x00'>::Ty' (aka 'ucharTy')}}
> >> > > >> >>> - struct Type7<wcharTy::c, "7"> t7; //
> expected-error{{value of type 'const char [2]' is not implicitly
> convertible to 'typename Type7Helper<(wcharTy)L'\x00'>::Ty' (aka
> 'wcharTy')}}
> >> > > >> >>> - struct Type8<char16Ty::c, "8"> t8; //
> expected-error{{value of type 'const char [2]' is not implicitly
> convertible to 'typename Type8Helper<(char16Ty)u'\x00'>::Ty' (aka
> 'char16Ty')}}
> >> > > >> >>> - struct Type9<char32Ty::c, "9"> t9; //
> expected-error{{value of type 'const char [2]' is not implicitly
> convertible to 'typename Type9Helper<(char32Ty)u'\x00'>::Ty' (aka
> 'char32Ty')}}
> >> > > >> >>> + struct Type3<boolTy::b, "3"> t3; // expected-error{{value
> of type 'const char[2]' is not implicitly convertible to 'typename
> Type3Helper<(boolTy)false>::Ty' (aka 'boolTy')}}
> >> > > >> >>> +
> >> > > >> >>> + struct Type4<charTy::c, "4"> t4; // expected-error{{value
> of type 'const char[2]' is not implicitly convertible to 'typename
> Type4Helper<(charTy)'\x00'>::Ty' (aka 'charTy')}}
> >> > > >> >>> + struct Type5<scharTy::c, "5"> t5; //
> expected-error{{value of type 'const char[2]' is not implicitly convertible
> to 'typename Type5Helper<(scharTy)'\x00'>::Ty' (aka 'scharTy')}}
> >> > > >> >>> + struct Type6<ucharTy::c, "6"> t6; //
> expected-error{{value of type 'const char[2]' is not implicitly convertible
> to 'typename Type6Helper<(ucharTy)'\x00'>::Ty' (aka 'ucharTy')}}
> >> > > >> >>> + struct Type7<wcharTy::c, "7"> t7; //
> expected-error{{value of type 'const char[2]' is not implicitly convertible
> to 'typename Type7Helper<(wcharTy)L'\x00'>::Ty' (aka 'wcharTy')}}
> >> > > >> >>> + struct Type8<char16Ty::c, "8"> t8; //
> expected-error{{value of type 'const char[2]' is not implicitly convertible
> to 'typename Type8Helper<(char16Ty)u'\x00'>::Ty' (aka 'char16Ty')}}
> >> > > >> >>> + struct Type9<char32Ty::c, "9"> t9; //
> expected-error{{value of type 'const char[2]' is not implicitly convertible
> to 'typename Type9Helper<(char32Ty)u'\x00'>::Ty' (aka 'char32Ty')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Modules/cxx-templates.cpp
> b/clang/test/Modules/cxx-templates.cpp
> >> > > >> >>> index 5bb3ca3380516..b7d5741e69af6 100644
> >> > > >> >>> --- a/clang/test/Modules/cxx-templates.cpp
> >> > > >> >>> +++ b/clang/test/Modules/cxx-templates.cpp
> >> > > >> >>> @@ -251,7 +251,7 @@ namespace Std {
> >> > > >> >>>
> >> > > >> >>> // CHECK-DUMP: ClassTemplateDecl {{.*}}
> <{{.*[/\\]}}cxx-templates-common.h:1:1, {{.*}}> col:{{.*}} in
> cxx_templates_common SomeTemplate
> >> > > >> >>> // CHECK-DUMP: ClassTemplateSpecializationDecl
> {{.*}} prev {{.*}} SomeTemplate
> >> > > >> >>> -// CHECK-DUMP-NEXT: TemplateArgument type 'char [2]'
> >> > > >> >>> +// CHECK-DUMP-NEXT: TemplateArgument type 'char[2]'
> >> > > >> >>> // CHECK-DUMP: ClassTemplateSpecializationDecl
> {{.*}} SomeTemplate definition
> >> > > >> >>> // CHECK-DUMP-NEXT: DefinitionData
> >> > > >> >>> // CHECK-DUMP-NEXT: DefaultConstructor
> >> > > >> >>> @@ -260,9 +260,9 @@ namespace Std {
> >> > > >> >>> // CHECK-DUMP-NEXT: CopyAssignment
> >> > > >> >>> // CHECK-DUMP-NEXT: MoveAssignment
> >> > > >> >>> // CHECK-DUMP-NEXT: Destructor
> >> > > >> >>> -// CHECK-DUMP-NEXT: TemplateArgument type 'char [2]'
> >> > > >> >>> +// CHECK-DUMP-NEXT: TemplateArgument type 'char[2]'
> >> > > >> >>> // CHECK-DUMP: ClassTemplateSpecializationDecl
> {{.*}} prev {{.*}} SomeTemplate
> >> > > >> >>> -// CHECK-DUMP-NEXT: TemplateArgument type 'char [1]'
> >> > > >> >>> +// CHECK-DUMP-NEXT: TemplateArgument type 'char[1]'
> >> > > >> >>> // CHECK-DUMP: ClassTemplateSpecializationDecl
> {{.*}} SomeTemplate definition
> >> > > >> >>> // CHECK-DUMP-NEXT: DefinitionData
> >> > > >> >>> // CHECK-DUMP-NEXT: DefaultConstructor
> >> > > >> >>> @@ -271,4 +271,4 @@ namespace Std {
> >> > > >> >>> // CHECK-DUMP-NEXT: CopyAssignment
> >> > > >> >>> // CHECK-DUMP-NEXT: MoveAssignment
> >> > > >> >>> // CHECK-DUMP-NEXT: Destructor
> >> > > >> >>> -// CHECK-DUMP-NEXT: TemplateArgument type 'char [1]'
> >> > > >> >>> +// CHECK-DUMP-NEXT: TemplateArgument type 'char[1]'
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Modules/odr_hash.cpp
> b/clang/test/Modules/odr_hash.cpp
> >> > > >> >>> index 6d26b3cfb570f..e2ff4348f04bb 100644
> >> > > >> >>> --- a/clang/test/Modules/odr_hash.cpp
> >> > > >> >>> +++ b/clang/test/Modules/odr_hash.cpp
> >> > > >> >>> @@ -625,8 +625,8 @@ struct S14 {
> >> > > >> >>> };
> >> > > >> >>> #else
> >> > > >> >>> S14 s14;
> >> > > >> >>> -// expected-error at second.h:* {{'Method::S14' has
> >> > > >> >>> diff erent definitions in
> >> > > >> >>> diff erent modules; first
> >> > > >> >>> diff erence is definition in module 'SecondModule' found
> method 'A' with 1st parameter of type 'int *' decayed from 'int [3]'}}
> >> > > >> >>> -// expected-note at first.h:* {{but in 'FirstModule' found
> method 'A' with 1st parameter of type 'int *' decayed from 'int [2]'}}
> >> > > >> >>> +// expected-error at second.h:* {{'Method::S14' has
> >> > > >> >>> diff erent definitions in
> >> > > >> >>> diff erent modules; first
> >> > > >> >>> diff erence is definition in module 'SecondModule' found
> method 'A' with 1st parameter of type 'int *' decayed from 'int[3]'}}
> >> > > >> >>> +// expected-note at first.h:* {{but in 'FirstModule' found
> method 'A' with 1st parameter of type 'int *' decayed from 'int[2]'}}
> >> > > >> >>> #endif
> >> > > >> >>>
> >> > > >> >>> #if defined(FIRST)
> >> > > >> >>> @@ -4533,8 +4533,8 @@ int F9(int[1]) { return 0; }
> >> > > >> >>> int F9(int[2]) { return 0; }
> >> > > >> >>> #else
> >> > > >> >>> int I9 = F9(nullptr);
> >> > > >> >>> -// expected-error at second.h:* {{'FunctionDecl::F9' has
> >> > > >> >>> diff erent definitions in
> >> > > >> >>> diff erent modules; definition in module 'SecondModule' first
> >> > > >> >>> diff erence is 1st parameter with type 'int *' decayed from
> 'int [2]'}}
> >> > > >> >>> -// expected-note at first.h:* {{but in 'FirstModule' found
> 1st parameter with type 'int *' decayed from 'int [1]'}}
> >> > > >> >>> +// expected-error at second.h:* {{'FunctionDecl::F9' has
> >> > > >> >>> diff erent definitions in
> >> > > >> >>> diff erent modules; definition in module 'SecondModule' first
> >> > > >> >>> diff erence is 1st parameter with type 'int *' decayed from
> 'int[2]'}}
> >> > > >> >>> +// expected-note at first.h:* {{but in 'FirstModule' found
> 1st parameter with type 'int *' decayed from 'int[1]'}}
> >> > > >> >>> #endif
> >> > > >> >>>
> >> > > >> >>> #if defined(FIRST)
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_firstprivate_messages.cpp
> b/clang/test/OpenMP/distribute_firstprivate_messages.cpp
> >> > > >> >>> index 1eb629512e6d4..30fa8be519ef2 100644
> >> > > >> >>> --- a/clang/test/OpenMP/distribute_firstprivate_messages.cpp
> >> > > >> >>> +++ b/clang/test/OpenMP/distribute_firstprivate_messages.cpp
> >> > > >> >>> @@ -103,11 +103,11 @@ int main(int argc, char **argv) {
> >> > > >> >>> for (i = 0; i < argc; ++i) foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> - #pragma omp distribute firstprivate(ba) //
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> + #pragma omp distribute firstprivate(ba) //
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i) foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> - #pragma omp distribute firstprivate(ca) // expected-error
> {{no matching constructor for initialization of 'S3'}} expected-warning
> {{Type 'const S3 [5]' is not trivially copyable and not guaranteed to be
> mapped correctly}}
> >> > > >> >>> + #pragma omp distribute firstprivate(ca) // expected-error
> {{no matching constructor for initialization of 'S3'}} expected-warning
> {{Type 'const S3[5]' is not trivially copyable and not guaranteed to be
> mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i) foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
> b/clang/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
> >> > > >> >>> index 16584a005f24c..84d6337be34bb 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
> >> > > >> >>> @@ -256,12 +256,12 @@ int main(int argc, char **argv) {
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for firstprivate(ba) //
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for firstprivate(ba) //
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for firstprivate(ca) //
> expected-warning {{Type 'const S3 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for firstprivate(ca) //
> expected-warning {{Type 'const S3[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_parallel_for_lastprivate_messages.cpp
> b/clang/test/OpenMP/distribute_parallel_for_lastprivate_messages.cpp
> >> > > >> >>> index 6001e27155238..f403922e14e8b 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/distribute_parallel_for_lastprivate_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/distribute_parallel_for_lastprivate_messages.cpp
> >> > > >> >>> @@ -243,12 +243,12 @@ int main(int argc, char **argv) {
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for lastprivate(ba) //
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for lastprivate(ba) //
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for lastprivate(ca) //
> expected-error {{const-qualified variable without mutable fields cannot be
> lastprivate}} expected-warning {{Type 'const S3 [5]' is not trivially
> copyable and not guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for lastprivate(ca) //
> expected-error {{const-qualified variable without mutable fields cannot be
> lastprivate}} expected-warning {{Type 'const S3[5]' is not trivially
> copyable and not guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_parallel_for_reduction_messages.cpp
> b/clang/test/OpenMP/distribute_parallel_for_reduction_messages.cpp
> >> > > >> >>> index 800e33897226e..645da9b7f0fed 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/distribute_parallel_for_reduction_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/distribute_parallel_for_reduction_messages.cpp
> >> > > >> >>> @@ -374,12 +374,12 @@ int main(int argc, char **argv) {
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for reduction(+ : ba) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for reduction(+ : ba) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (int i = 0; i < 10; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for reduction(* : ca) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S3 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for reduction(* : ca) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S3[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (int i = 0; i < 10; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_parallel_for_simd_shared_messages.cpp
> b/clang/test/OpenMP/distribute_parallel_for_simd_shared_messages.cpp
> >> > > >> >>> index 455eb7d053bf5..7c83e4c674c66 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/distribute_parallel_for_simd_shared_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/distribute_parallel_for_simd_shared_messages.cpp
> >> > > >> >>> @@ -131,14 +131,14 @@ T tmain(T argc, S **argv) {
> >> > > >> >>>
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for simd shared(ba) //
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for simd shared(ba) //
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for(int k = 0 ; k < n ; k++) {
> >> > > >> >>> acc++;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for simd shared(ca) //
> expected-warning {{Type 'const S3 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for simd shared(ca) //
> expected-warning {{Type 'const S3[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for(int k = 0 ; k < n ; k++) {
> >> > > >> >>> acc++;
> >> > > >> >>> }
> >> > > >> >>> @@ -305,14 +305,14 @@ int main(int argc, char **argv) {
> >> > > >> >>>
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for simd shared(ba) //
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for simd shared(ba) //
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for(int k = 0 ; k < n ; k++) {
> >> > > >> >>> acc++;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute parallel for simd shared(ca) //
> expected-warning {{Type 'const S3 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute parallel for simd shared(ca) //
> expected-warning {{Type 'const S3[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for(int k = 0 ; k < n ; k++) {
> >> > > >> >>> acc++;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_simd_firstprivate_messages.cpp
> b/clang/test/OpenMP/distribute_simd_firstprivate_messages.cpp
> >> > > >> >>> index 7ec5cf2f27741..43057fe5bacc5 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/distribute_simd_firstprivate_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/distribute_simd_firstprivate_messages.cpp
> >> > > >> >>> @@ -248,12 +248,12 @@ int main(int argc, char **argv) {
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute simd firstprivate(ba) //
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute simd firstprivate(ba) //
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute simd firstprivate(ca) //
> expected-warning {{Type 'const S3 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute simd firstprivate(ca) //
> expected-warning {{Type 'const S3[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_simd_lastprivate_messages.cpp
> b/clang/test/OpenMP/distribute_simd_lastprivate_messages.cpp
> >> > > >> >>> index 6033f6b0f4b45..7658288242ab3 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/distribute_simd_lastprivate_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/distribute_simd_lastprivate_messages.cpp
> >> > > >> >>> @@ -244,12 +244,12 @@ int main(int argc, char **argv) {
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute simd lastprivate(ba) //
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute simd lastprivate(ba) //
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute simd lastprivate(ca) //
> expected-error {{const-qualified variable without mutable fields cannot be
> lastprivate}} expected-warning {{Type 'const S3 [5]' is not trivially
> copyable and not guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute simd lastprivate(ca) //
> expected-error {{const-qualified variable without mutable fields cannot be
> lastprivate}} expected-warning {{Type 'const S3[5]' is not trivially
> copyable and not guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/distribute_simd_reduction_messages.cpp
> b/clang/test/OpenMP/distribute_simd_reduction_messages.cpp
> >> > > >> >>> index 3ac2227625be1..841103d7a6b77 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/distribute_simd_reduction_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/distribute_simd_reduction_messages.cpp
> >> > > >> >>> @@ -379,12 +379,12 @@ int main(int argc, char **argv) {
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute simd reduction(+ : ba) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S2 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute simd reduction(+ : ba) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S2[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (int i = 0; i < 10; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>> #pragma omp teams
> >> > > >> >>> -#pragma omp distribute simd reduction(* : ca) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S3 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp distribute simd reduction(* : ca) //
> expected-error {{const-qualified variable cannot be reduction}}
> expected-warning {{Type 'const S3[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (int i = 0; i < 10; ++i)
> >> > > >> >>> foo();
> >> > > >> >>> #pragma omp target
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/parallel_reduction_messages.c
> b/clang/test/OpenMP/parallel_reduction_messages.c
> >> > > >> >>> index eef9a7d7d133a..fda8200f4b8d0 100644
> >> > > >> >>> --- a/clang/test/OpenMP/parallel_reduction_messages.c
> >> > > >> >>> +++ b/clang/test/OpenMP/parallel_reduction_messages.c
> >> > > >> >>> @@ -16,7 +16,7 @@ void test(int *p) {
> >> > > >> >>> ;
> >> > > >> >>> #pragma omp parallel reduction(inscan, + : a) //
> expected-error {{'inscan' modifier can be used only in 'omp for', 'omp
> simd', 'omp for simd', 'omp parallel for', or 'omp parallel for simd'
> directive}}
> >> > > >> >>> ;
> >> > > >> >>> -#pragma omp parallel reduction(+ : incomplete, ([10])p) //
> expected-error {{a reduction list item with incomplete type 'int []'}}
> expected-error {{expected variable name, array element or array section}}
> >> > > >> >>> +#pragma omp parallel reduction(+ : incomplete, ([10])p) //
> expected-error {{a reduction list item with incomplete type 'int[]'}}
> expected-error {{expected variable name, array element or array section}}
> >> > > >> >>> ;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
> b/clang/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
> >> > > >> >>> index cbb35568e22f1..fccf5515998dc 100644
> >> > > >> >>> ---
> a/clang/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
> >> > > >> >>> +++
> b/clang/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
> >> > > >> >>> @@ -119,7 +119,7 @@ int main(int argc, char **argv) {
> >> > > >> >>> for (i = 0; i < argc; ++i) foo();
> >> > > >> >>>
> >> > > >> >>> #pragma omp target
> >> > > >> >>> -#pragma omp teams distribute firstprivate(ca) //
> expected-error {{no matching constructor for initialization of 'S3'}}
> expected-warning {{Type 'const S3 [5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> +#pragma omp teams distribute firstprivate(ca) //
> expected-error {{no matching constructor for initialization of 'S3'}}
> expected-warning {{Type 'const S3[5]' is not trivially copyable and not
> guaranteed to be mapped correctly}}
> >> > > >> >>> for (i = 0; i < argc; ++i) foo();
> >> > > >> >>>
> >> > > >> >>> #pragma omp target teams distribute firstprivate(da, z)
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/PCH/objc_exprs.m
> b/clang/test/PCH/objc_exprs.m
> >> > > >> >>> index 1f971e794133f..b503f419c7a32 100644
> >> > > >> >>> --- a/clang/test/PCH/objc_exprs.m
> >> > > >> >>> +++ b/clang/test/PCH/objc_exprs.m
> >> > > >> >>> @@ -9,7 +9,7 @@
> >> > > >> >>> int *A1 = (objc_string)0; // expected-warning {{aka
> 'NSString *'}}
> >> > > >> >>>
> >> > > >> >>> char A2 = (objc_encode){}; // expected-error {{not a
> compile-time constant}} \
> >> > > >> >>> - expected-warning {{char [2]}}
> >> > > >> >>> + expected-warning {{char[2]}}
> >> > > >> >>>
> >> > > >> >>> int *A3 = (objc_protocol)0; // expected-warning {{aka
> 'Protocol *'}}
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Parser/atomic.c
> b/clang/test/Parser/atomic.c
> >> > > >> >>> index 928a43b330310..e8214966c3343 100644
> >> > > >> >>> --- a/clang/test/Parser/atomic.c
> >> > > >> >>> +++ b/clang/test/Parser/atomic.c
> >> > > >> >>> @@ -29,7 +29,7 @@ typedef int int_fn();
> >> > > >> >>> typedef _Atomic int_fn atomic_int_fn; // expected-error
> {{_Atomic cannot be applied to function type 'int_fn' (aka 'int ()')}} \
> >> > > >> >>> // ext-warning
> {{'_Atomic' is a C11 extension}}
> >> > > >> >>> typedef _Atomic int atomic_int_array[3]; // ext-warning
> {{'_Atomic' is a C11 extension}}
> >> > > >> >>> -typedef _Atomic atomic_int_array atomic_int_atomic_array;
> // expected-error {{_Atomic cannot be applied to array type
> 'atomic_int_array' (aka '_Atomic(int) [3]')}} \
> >> > > >> >>> +typedef _Atomic atomic_int_array atomic_int_atomic_array;
> // expected-error {{_Atomic cannot be applied to array type
> 'atomic_int_array' (aka '_Atomic(int)[3]')}} \
> >> > > >> >>>
> // ext-warning {{'_Atomic' is a C11 extension}}
> >> > > >> >>>
> >> > > >> >>> _Atomic struct S { int n; }; // expected-warning
> {{'_Atomic' ignored on this declaration}} \
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/array-constraint.c
> b/clang/test/Sema/array-constraint.c
> >> > > >> >>> index bee33c09efbd0..b7e46fda7c560 100644
> >> > > >> >>> --- a/clang/test/Sema/array-constraint.c
> >> > > >> >>> +++ b/clang/test/Sema/array-constraint.c
> >> > > >> >>> @@ -46,7 +46,7 @@ typedef int TA[I]; // expected-error
> {{variable length array declaration not all
> >> > > >> >>> void strFunc(char *); // expected-note{{passing argument to
> parameter here}}
> >> > > >> >>> const char staticAry[] = "test";
> >> > > >> >>> void checkStaticAry() {
> >> > > >> >>> - strFunc(staticAry); // expected-warning{{passing 'const
> char [5]' to parameter of type 'char *' discards qualifiers}}
> >> > > >> >>> + strFunc(staticAry); // expected-warning{{passing 'const
> char[5]' to parameter of type 'char *' discards qualifiers}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/array-init.c
> b/clang/test/Sema/array-init.c
> >> > > >> >>> index 15edcb0a86569..5ce5075dc9725 100644
> >> > > >> >>> --- a/clang/test/Sema/array-init.c
> >> > > >> >>> +++ b/clang/test/Sema/array-init.c
> >> > > >> >>> @@ -11,7 +11,7 @@ int ary2[] = { x, y, z }; //
> expected-error{{initializer element is not a compil
> >> > > >> >>>
> >> > > >> >>> extern int fileScopeExtern[3] = { 1, 3, 5 }; //
> expected-warning{{'extern' variable has an initializer}}
> >> > > >> >>>
> >> > > >> >>> -static long ary3[] = { 1, "abc", 3, 4 }; //
> expected-warning{{incompatible pointer to integer conversion initializing
> 'long' with an expression of type 'char [4]'}}
> >> > > >> >>> +static long ary3[] = { 1, "abc", 3, 4 }; //
> expected-warning{{incompatible pointer to integer conversion initializing
> 'long' with an expression of type 'char[4]'}}
> >> > > >> >>>
> >> > > >> >>> void func() {
> >> > > >> >>> int x = 1;
> >> > > >> >>> @@ -51,7 +51,7 @@ void func() {
> >> > > >> >>> extern int blockScopeExtern[3] = { 1, 3, 5 }; //
> expected-error{{'extern' variable cannot have an initializer}}
> >> > > >> >>>
> >> > > >> >>> static long x2[3] = { 1.0,
> >> > > >> >>> - "abc", //
> expected-warning{{incompatible pointer to integer conversion initializing
> 'long' with an expression of type 'char [4]'}}
> >> > > >> >>> + "abc", //
> expected-warning{{incompatible pointer to integer conversion initializing
> 'long' with an expression of type 'char[4]'}}
> >> > > >> >>> 5.8 }; // expected-warning
> {{implicit conversion from 'double' to 'long' changes value from 5.8 to 5}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -114,12 +114,12 @@ int legal2() {
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> void illegal() {
> >> > > >> >>> - short q2[4][][2] = { // expected-error{{array has
> incomplete element type 'short [][2]'}}
> >> > > >> >>> + short q2[4][][2] = { // expected-error{{array has
> incomplete element type 'short[][2]'}}
> >> > > >> >>> { 1, 0, 0, 0, 0, 0 },
> >> > > >> >>> { 2, 3, 0, 0, 0, 0 },
> >> > > >> >>> { 4, 5, 6 }
> >> > > >> >>> };
> >> > > >> >>> - short q3[4][3][] = { // expected-error{{array has
> incomplete element type 'short []'}}
> >> > > >> >>> + short q3[4][3][] = { // expected-error{{array has
> incomplete element type 'short[]'}}
> >> > > >> >>> {
> >> > > >> >>> { 1 },
> >> > > >> >>> },
> >> > > >> >>> @@ -131,7 +131,7 @@ void illegal() {
> >> > > >> >>> { 6 },
> >> > > >> >>> },
> >> > > >> >>> };
> >> > > >> >>> - int a[][] = { 1, 2 }; // expected-error{{array has
> incomplete element type 'int []'}}
> >> > > >> >>> + int a[][] = { 1, 2 }; // expected-error{{array has
> incomplete element type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> typedef int AryT[];
> >> > > >> >>> @@ -168,10 +168,10 @@ void charArrays() {
> >> > > >> >>> char c[] = { "Hello" };
> >> > > >> >>> int l[sizeof(c) == 6 ? 1 : -1];
> >> > > >> >>>
> >> > > >> >>> - int i[] = { "Hello "}; // expected-warning{{incompatible
> pointer to integer conversion initializing 'int' with an expression of type
> 'char [7]'}}
> >> > > >> >>> + int i[] = { "Hello "}; // expected-warning{{incompatible
> pointer to integer conversion initializing 'int' with an expression of type
> 'char[7]'}}
> >> > > >> >>> char c2[] = { "Hello", "Good bye" };
> //expected-warning{{excess elements in char array initializer}}
> >> > > >> >>>
> >> > > >> >>> - int i2[1] = { "Hello" }; //expected-warning{{incompatible
> pointer to integer conversion initializing 'int' with an expression of type
> 'char [6]'}}
> >> > > >> >>> + int i2[1] = { "Hello" }; //expected-warning{{incompatible
> pointer to integer conversion initializing 'int' with an expression of type
> 'char[6]'}}
> >> > > >> >>> char c3[5] = { "Hello" };
> >> > > >> >>> char c4[4] = { "Hello" };
> //expected-warning{{initializer-string for char array is too long}}
> >> > > >> >>>
> >> > > >> >>> @@ -204,7 +204,7 @@ void autoStructTest() {
> >> > > >> >>> struct s1 {char a; char b;} t1;
> >> > > >> >>> struct s2 {struct s1 c;} t2 = { t1 };
> >> > > >> >>> // The following is a less than great diagnostic (though
> it's on par with EDG).
> >> > > >> >>> -struct s1 t3[] = {t1, t1, "abc", 0};
> //expected-warning{{incompatible pointer to integer conversion initializing
> 'char' with an expression of type 'char [4]'}}
> >> > > >> >>> +struct s1 t3[] = {t1, t1, "abc", 0};
> //expected-warning{{incompatible pointer to integer conversion initializing
> 'char' with an expression of type 'char[4]'}}
> >> > > >> >>> int t4[sizeof t3 == 6 ? 1 : -1];
> >> > > >> >>> }
> >> > > >> >>> struct foo { int z; } w;
> >> > > >> >>> @@ -282,13 +282,13 @@ char badchararray[1] = {
> badchararray[0], "asdf" }; // expected-warning {{excess
> >> > > >> >>> // Test the GNU extension for initializing an array from an
> array
> >> > > >> >>> // compound literal. PR9261.
> >> > > >> >>> typedef int int5[5];
> >> > > >> >>> -int a1[5] = (int[]){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int [5]' from a
> compound literal of type 'int [5]' is a GNU extension}}
> >> > > >> >>> -int a2[5] = (int[5]){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int [5]' from a
> compound literal of type 'int [5]' is a GNU extension}}
> >> > > >> >>> -int a3[] = ((int[]){1, 2, 3, 4, 5}); //
> expected-warning{{initialization of an array of type 'int []' from a
> compound literal of type 'int [5]' is a GNU extension}}
> >> > > >> >>> -int a4[] = (int[5]){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int []' from a
> compound literal of type 'int [5]' is a GNU extension}}
> >> > > >> >>> -int a5[] = (int5){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int []' from a
> compound literal of type 'int5' (aka 'int [5]') is a GNU extension}}
> >> > > >> >>> +int a1[5] = (int[]){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int[5]' from a
> compound literal of type 'int[5]' is a GNU extension}}
> >> > > >> >>> +int a2[5] = (int[5]){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int[5]' from a
> compound literal of type 'int[5]' is a GNU extension}}
> >> > > >> >>> +int a3[] = ((int[]){1, 2, 3, 4, 5}); //
> expected-warning{{initialization of an array of type 'int[]' from a
> compound literal of type 'int[5]' is a GNU extension}}
> >> > > >> >>> +int a4[] = (int[5]){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int[]' from a
> compound literal of type 'int[5]' is a GNU extension}}
> >> > > >> >>> +int a5[] = (int5){1, 2, 3, 4, 5}; //
> expected-warning{{initialization of an array of type 'int[]' from a
> compound literal of type 'int5' (aka 'int[5]') is a GNU extension}}
> >> > > >> >>>
> >> > > >> >>> -int a6[5] = (int[]){1, 2, 3}; // expected-error{{cannot
> initialize array of type 'int [5]' with array of type 'int [3]'}}
> >> > > >> >>> +int a6[5] = (int[]){1, 2, 3}; // expected-error{{cannot
> initialize array of type 'int[5]' with array of type 'int[3]'}}
> >> > > >> >>>
> >> > > >> >>> int nonconst_value();
> >> > > >> >>> int a7[5] = (int[5]){ 1,
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/assign.c
> b/clang/test/Sema/assign.c
> >> > > >> >>> index d65f9bf26547e..3a329432dfbcb 100644
> >> > > >> >>> --- a/clang/test/Sema/assign.c
> >> > > >> >>> +++ b/clang/test/Sema/assign.c
> >> > > >> >>> @@ -13,8 +13,8 @@ typedef int arr[10];
> >> > > >> >>> void test3() {
> >> > > >> >>> const arr b; // expected-note {{variable 'b'
> declared const here}}
> >> > > >> >>> const int b2[10]; // expected-note {{variable 'b2'
> declared const here}}
> >> > > >> >>> - b[4] = 1; // expected-error {{cannot assign to
> variable 'b' with const-qualified type 'const arr' (aka 'const int [10]')}}
> >> > > >> >>> - b2[4] = 1; // expected-error {{cannot assign to
> variable 'b2' with const-qualified type 'const int [10]'}}
> >> > > >> >>> + b[4] = 1; // expected-error {{cannot assign to
> variable 'b' with const-qualified type 'const arr' (aka 'const int[10]')}}
> >> > > >> >>> + b2[4] = 1; // expected-error {{cannot assign to
> variable 'b2' with const-qualified type 'const int[10]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> typedef struct I {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Sema/builtin-expect-with-probability-avr.cpp
> b/clang/test/Sema/builtin-expect-with-probability-avr.cpp
> >> > > >> >>> index 1767480134a28..b27ca80fd95a2 100644
> >> > > >> >>> --- a/clang/test/Sema/builtin-expect-with-probability-avr.cpp
> >> > > >> >>> +++ b/clang/test/Sema/builtin-expect-with-probability-avr.cpp
> >> > > >> >>> @@ -6,7 +6,7 @@ void test(int x, double p) { //
> expected-note {{declared here}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, 1.1);
> // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, -1);
> // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, p);
> // expected-error {{probability argument to
> __builtin_expect_with_probability must be constant floating-point
> expression}} expected-note {{function parameter 'p' with unknown value}}
> >> > > >> >>> - dummy = __builtin_expect_with_probability(x > 0, 1,
> "aa"); // expected-error {{cannot initialize a parameter of type 'double'
> with an lvalue of type 'const char [3]'}}
> >> > > >> >>> + dummy = __builtin_expect_with_probability(x > 0, 1,
> "aa"); // expected-error {{cannot initialize a parameter of type 'double'
> with an lvalue of type 'const char[3]'}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1,
> __builtin_nan("")); // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1,
> __builtin_inf()); // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, -0.0);
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/Sema/builtin-expect-with-probability.cpp
> b/clang/test/Sema/builtin-expect-with-probability.cpp
> >> > > >> >>> index e05174f70673e..2b72c7b27ae93 100644
> >> > > >> >>> --- a/clang/test/Sema/builtin-expect-with-probability.cpp
> >> > > >> >>> +++ b/clang/test/Sema/builtin-expect-with-probability.cpp
> >> > > >> >>> @@ -44,7 +44,7 @@ void test(int x, double p) { //
> expected-note {{declared here}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, 1.1);
> // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, -1);
> // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, p);
> // expected-error {{probability argument to
> __builtin_expect_with_probability must be constant floating-point
> expression}} expected-note {{function parameter 'p'}}
> >> > > >> >>> - dummy = __builtin_expect_with_probability(x > 0, 1,
> "aa"); // expected-error {{cannot initialize a parameter of type 'double'
> with an lvalue of type 'const char [3]'}}
> >> > > >> >>> + dummy = __builtin_expect_with_probability(x > 0, 1,
> "aa"); // expected-error {{cannot initialize a parameter of type 'double'
> with an lvalue of type 'const char[3]'}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1,
> __builtin_nan("")); // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1,
> __builtin_inf()); // expected-error {{probability argument to
> __builtin_expect_with_probability is outside the range [0.0, 1.0]}}
> >> > > >> >>> dummy = __builtin_expect_with_probability(x > 0, 1, -0.0);
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/c11-typedef-redef.c
> b/clang/test/Sema/c11-typedef-redef.c
> >> > > >> >>> index b899f15ce6388..77e28d248338b 100644
> >> > > >> >>> --- a/clang/test/Sema/c11-typedef-redef.c
> >> > > >> >>> +++ b/clang/test/Sema/c11-typedef-redef.c
> >> > > >> >>> @@ -10,9 +10,9 @@ void f(int N) {
> >> > > >> >>> typedef int type2;
> >> > > >> >>>
> >> > > >> >>> typedef int vla[N]; // expected-note{{previous definition
> is here}}
> >> > > >> >>> - typedef int vla[N]; // expected-error{{redefinition of
> typedef for variably-modified type 'int [N]'}}
> >> > > >> >>> + typedef int vla[N]; // expected-error{{redefinition of
> typedef for variably-modified type 'int[N]'}}
> >> > > >> >>>
> >> > > >> >>> typedef int vla2[N];
> >> > > >> >>> typedef vla2 vla3; // expected-note{{previous definition
> is here}}
> >> > > >> >>> - typedef vla2 vla3; // expected-error{{redefinition of
> typedef for variably-modified type 'vla2' (aka 'int [N]')}}
> >> > > >> >>> + typedef vla2 vla3; // expected-error{{redefinition of
> typedef for variably-modified type 'vla2' (aka 'int[N]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/compound-literal.c
> b/clang/test/Sema/compound-literal.c
> >> > > >> >>> index 217dbeda8a7bc..ed18157a9276d 100644
> >> > > >> >>> --- a/clang/test/Sema/compound-literal.c
> >> > > >> >>> +++ b/clang/test/Sema/compound-literal.c
> >> > > >> >>> @@ -11,7 +11,7 @@ static int *p = (int []){2,4};
> >> > > >> >>> static int x = (int){1};
> >> > > >> >>>
> >> > > >> >>> static int *p2 = (int []){2,x}; // expected-error
> {{initializer element is not a compile-time constant}}
> >> > > >> >>> -static long *p3 = (long []){2,"x"}; // expected-warning
> {{incompatible pointer to integer conversion initializing 'long' with an
> expression of type 'char [2]'}}
> >> > > >> >>> +static long *p3 = (long []){2,"x"}; // expected-warning
> {{incompatible pointer to integer conversion initializing 'long' with an
> expression of type 'char[2]'}}
> >> > > >> >>>
> >> > > >> >>> typedef struct { } cache_t; // expected-warning{{empty
> struct is a GNU extension}}
> >> > > >> >>> static cache_t clo_I1_cache = ((cache_t) { } ); //
> expected-warning{{use of GNU empty initializer extension}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/crash-invalid-array.c
> b/clang/test/Sema/crash-invalid-array.c
> >> > > >> >>> index 029413b9843fe..18fbd1c84dbcf 100644
> >> > > >> >>> --- a/clang/test/Sema/crash-invalid-array.c
> >> > > >> >>> +++ b/clang/test/Sema/crash-invalid-array.c
> >> > > >> >>> @@ -10,7 +10,7 @@ int main()
> >> > > >> >>>
> >> > > >> >>> for(i = 0; i < 10; ++i)
> >> > > >> >>> {
> >> > > >> >>> - p[i][i] = i; // expected-error {{subscript of
> pointer to incomplete type 'int []'}}
> >> > > >> >>> + p[i][i] = i; // expected-error {{subscript of
> pointer to incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/empty1.c
> b/clang/test/Sema/empty1.c
> >> > > >> >>> index 9a2fb678de664..39a46a7b7cd53 100644
> >> > > >> >>> --- a/clang/test/Sema/empty1.c
> >> > > >> >>> +++ b/clang/test/Sema/empty1.c
> >> > > >> >>> @@ -75,13 +75,13 @@ int func_7(struct A *x, struct A *y) {
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> int func_8(struct emp_1 (*x)[10], struct emp_1 (*y)[10]) {
> >> > > >> >>> - return x - y; // expected-warning {{subtraction of
> pointers to type 'struct emp_1 [10]' of zero size has undefined behavior}}
> >> > > >> >>> + return x - y; // expected-warning {{subtraction of
> pointers to type 'struct emp_1[10]' of zero size has undefined behavior}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> int func_9(struct emp_1 (*x)[], struct emp_1 (*y)[]) {
> >> > > >> >>> - return x - y; // expected-error {{arithmetic on a pointer
> to an incomplete type 'struct emp_1 []'}}
> >> > > >> >>> + return x - y; // expected-error {{arithmetic on a pointer
> to an incomplete type 'struct emp_1[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> int func_10(int (*x)[0], int (*y)[0]) {
> >> > > >> >>> - return x - y; // expected-warning {{subtraction of
> pointers to type 'int [0]' of zero size has undefined behavior}}
> >> > > >> >>> + return x - y; // expected-warning {{subtraction of
> pointers to type 'int[0]' of zero size has undefined behavior}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/extern-redecl.c
> b/clang/test/Sema/extern-redecl.c
> >> > > >> >>> index 6bdb66e07f553..bccf7ba38a6df 100644
> >> > > >> >>> --- a/clang/test/Sema/extern-redecl.c
> >> > > >> >>> +++ b/clang/test/Sema/extern-redecl.c
> >> > > >> >>> @@ -26,12 +26,12 @@ extern int test1_a[];
> >> > > >> >>> // rdar://13535367
> >> > > >> >>> void test2declarer() { extern int test2_array[100]; }
> >> > > >> >>> extern int test2_array[];
> >> > > >> >>> -int test2v = sizeof(test2_array); // expected-error
> {{invalid application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> +int test2v = sizeof(test2_array); // expected-error
> {{invalid application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>>
> >> > > >> >>> void test3declarer() {
> >> > > >> >>> { extern int test3_array[100]; }
> >> > > >> >>> extern int test3_array[];
> >> > > >> >>> - int x = sizeof(test3_array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int x = sizeof(test3_array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> void test4() {
> >> > > >> >>> @@ -40,7 +40,7 @@ void test4() {
> >> > > >> >>> extern int test4_array[100];
> >> > > >> >>> int x = sizeof(test4_array); // fine
> >> > > >> >>> }
> >> > > >> >>> - int x = sizeof(test4_array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + int x = sizeof(test4_array); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> // Test that invalid local extern declarations of library
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/generic-selection.c
> b/clang/test/Sema/generic-selection.c
> >> > > >> >>> index f083dff8ac8b9..36cfce4a950af 100644
> >> > > >> >>> --- a/clang/test/Sema/generic-selection.c
> >> > > >> >>> +++ b/clang/test/Sema/generic-selection.c
> >> > > >> >>> @@ -7,7 +7,7 @@ void foo(int n) {
> >> > > >> >>> (void) _Generic(0, // ext-warning {{'_Generic' is a C11
> extension}}
> >> > > >> >>> struct A: 0, // expected-error {{type 'struct A' in
> generic association incomplete}}
> >> > > >> >>> void(): 0, // expected-error {{type 'void ()' in
> generic association not an object type}}
> >> > > >> >>> - int[n]: 0); // expected-error {{type 'int [n]' in
> generic association is a variably modified type}}
> >> > > >> >>> + int[n]: 0); // expected-error {{type 'int[n]' in
> generic association is a variably modified type}}
> >> > > >> >>>
> >> > > >> >>> (void) _Generic(0, // ext-warning {{'_Generic' is a C11
> extension}}
> >> > > >> >>> void (*)(): 0, // expected-note {{compatible
> type 'void (*)()' specified here}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/gnu-flags.c
> b/clang/test/Sema/gnu-flags.c
> >> > > >> >>> index e53e5fdf11df0..163ed50a38a41 100644
> >> > > >> >>> --- a/clang/test/Sema/gnu-flags.c
> >> > > >> >>> +++ b/clang/test/Sema/gnu-flags.c
> >> > > >> >>> @@ -97,7 +97,7 @@ void statementexp()
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> #if ALL || COMPOUNDLITERALINITIALIZER
> >> > > >> >>> -// expected-warning at +4 {{initialization of an array of
> type 'int [5]' from a compound literal of type 'int [5]' is a GNU
> extension}}
> >> > > >> >>> +// expected-warning at +4 {{initialization of an array of
> type 'int[5]' from a compound literal of type 'int[5]' is a GNU extension}}
> >> > > >> >>> #endif
> >> > > >> >>>
> >> > > >> >>> typedef int int5[5];
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/incomplete-decl.c
> b/clang/test/Sema/incomplete-decl.c
> >> > > >> >>> index 0214a0c6ce4c9..08f86f683b833 100644
> >> > > >> >>> --- a/clang/test/Sema/incomplete-decl.c
> >> > > >> >>> +++ b/clang/test/Sema/incomplete-decl.c
> >> > > >> >>> @@ -22,7 +22,7 @@ void func() {
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> int h[]; // expected-warning {{tentative array definition
> assumed to have one element}}
> >> > > >> >>> -int (*i)[] = &h+1; // expected-error {{arithmetic on a
> pointer to an incomplete type 'int []'}}
> >> > > >> >>> +int (*i)[] = &h+1; // expected-error {{arithmetic on a
> pointer to an incomplete type 'int[]'}}
> >> > > >> >>>
> >> > > >> >>> struct bar j = {1}; // expected-error {{variable has
> incomplete type 'struct bar'}} \
> >> > > >> >>> expected-note {{forward declaration of 'struct bar'}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/matrix-type-builtins.c
> b/clang/test/Sema/matrix-type-builtins.c
> >> > > >> >>> index 2f7e4549e4950..c58384613e79c 100644
> >> > > >> >>> --- a/clang/test/Sema/matrix-type-builtins.c
> >> > > >> >>> +++ b/clang/test/Sema/matrix-type-builtins.c
> >> > > >> >>> @@ -57,13 +57,13 @@ void column_major_load(float *p1, int
> *p2, _Bool *p3, struct Foo *p4) {
> >> > > >> >>> 10, // expected-error {{1st argument must be
> a pointer to a valid matrix element type}}
> >> > > >> >>> 1ull << 21, // expected-error {{row dimension is
> outside the allowed range [1, 1048575]}}
> >> > > >> >>> 1ull << 21, // expected-error {{column dimension is
> outside the allowed range [1, 1048575]}}
> >> > > >> >>> - ""); // expected-warning {{incompatible
> pointer to integer conversion casting 'char [1]' to type 'unsigned long'}}
> >> > > >> >>> + ""); // expected-warning {{incompatible
> pointer to integer conversion casting 'char[1]' to type 'unsigned long'}}
> >> > > >> >>>
> >> > > >> >>> sx5x10_t a13 = __builtin_matrix_column_major_load(
> >> > > >> >>> 10, // expected-error {{1st argument must be a
> pointer to a valid matrix element type}}
> >> > > >> >>> *p4, // expected-error {{casting 'struct Foo' to
> incompatible type 'unsigned long'}}
> >> > > >> >>> "", // expected-error {{column argument must be a
> constant unsigned integer expression}}
> >> > > >> >>> - // expected-warning at -1 {{incompatible pointer
> to integer conversion casting 'char [1]' to type 'unsigned long'}}
> >> > > >> >>> + // expected-warning at -1 {{incompatible pointer
> to integer conversion casting 'char[1]' to type 'unsigned long'}}
> >> > > >> >>> 10);
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/merge-decls.c
> b/clang/test/Sema/merge-decls.c
> >> > > >> >>> index 29707d259b963..3b27c04a3e251 100644
> >> > > >> >>> --- a/clang/test/Sema/merge-decls.c
> >> > > >> >>> +++ b/clang/test/Sema/merge-decls.c
> >> > > >> >>> @@ -73,7 +73,7 @@ void test4_f(a)
> >> > > >> >>>
> >> > > >> >>> int test5_f(int (*)[10]);
> >> > > >> >>> int test5_f(int (*x)[]) {
> >> > > >> >>> - return sizeof(*x); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int []'}}
> >> > > >> >>> + return sizeof(*x); // expected-error {{invalid
> application of 'sizeof' to an incomplete type 'int[]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> void test6_f(int (*a)[11]);
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/nullability.c
> b/clang/test/Sema/nullability.c
> >> > > >> >>> index a5cb4b9a031eb..d462886de0436 100644
> >> > > >> >>> --- a/clang/test/Sema/nullability.c
> >> > > >> >>> +++ b/clang/test/Sema/nullability.c
> >> > > >> >>> @@ -213,25 +213,25 @@ void testDecayedType() {
> >> > > >> >>> int produceAnErrorMessage = arrays; // expected-warning
> {{incompatible pointer to integer conversion initializing 'int' with an
> expression of type 'void (int * _Nonnull, void ** _Nullable, void ***
> _Nullable, void * _Null_unspecified * _Nonnull * _Nullable, int * _Nonnull,
> int * _Nonnull, int * _Nonnull, int * _Nonnull, int * _Nonnull, void **
> _Nullable)'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> -int notInFunction[_Nullable 3]; // expected-error
> {{nullability specifier '_Nullable' cannot be applied to non-pointer type
> 'int [3]'}}
> >> > > >> >>> +int notInFunction[_Nullable 3]; // expected-error
> {{nullability specifier '_Nullable' cannot be applied to non-pointer type
> 'int[3]'}}
> >> > > >> >>>
> >> > > >> >>> -void nestedArrays(int x[5][_Nonnull 1]) {} //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int [1]'}}
> >> > > >> >>> -void nestedArrays2(int x[5][_Nonnull 1][2]) {} //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int [1][2]'}}
> >> > > >> >>> +void nestedArrays(int x[5][_Nonnull 1]) {} //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int[1]'}}
> >> > > >> >>> +void nestedArrays2(int x[5][_Nonnull 1][2]) {} //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int[1][2]'}}
> >> > > >> >>> void nestedArraysOK(int x[_Nonnull 5][1]) {} // ok
> >> > > >> >>>
> >> > > >> >>> void nullabilityOnBase(_Nonnull int x[1], // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'int'}}
> >> > > >> >>> int _Nonnull y[1]); //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int'}}
> >> > > >> >>>
> >> > > >> >>> typedef int INTS[4];
> >> > > >> >>> -typedef int BAD_INTS[_Nonnull 4]; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'int [4]'}}
> >> > > >> >>> +typedef int BAD_INTS[_Nonnull 4]; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'int[4]'}}
> >> > > >> >>>
> >> > > >> >>> void typedefTest(INTS _Nonnull x,
> >> > > >> >>> _Nonnull INTS xx,
> >> > > >> >>> - INTS _Nonnull y[2], // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'INTS' (aka 'int [4]')}}
> >> > > >> >>> + INTS _Nonnull y[2], // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'INTS' (aka 'int[4]')}}
> >> > > >> >>> INTS z[_Nonnull 2]);
> >> > > >> >>>
> >> > > >> >>> -INTS _Nonnull x; // expected-error {{nullability specifier
> '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int [4]')}}
> >> > > >> >>> -_Nonnull INTS x; // expected-error {{nullability specifier
> '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int [4]')}}
> >> > > >> >>> +INTS _Nonnull x; // expected-error {{nullability specifier
> '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int[4]')}}
> >> > > >> >>> +_Nonnull INTS x; // expected-error {{nullability specifier
> '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int[4]')}}
> >> > > >> >>>
> >> > > >> >>> void arraysInBlocks() {
> >> > > >> >>> typedef int INTS[4];
> >> > > >> >>> @@ -239,11 +239,11 @@ void arraysInBlocks() {
> >> > > >> >>> simple(0); // expected-warning {{null passed to a callee
> that requires a non-null argument}}
> >> > > >> >>> void (^nested)(void *_Nullable x[_Nonnull 2]) = ^(void
> *_Nullable x[_Nonnull 2]) {};
> >> > > >> >>> nested(0); // expected-warning {{null passed to a callee
> that requires a non-null argument}}
> >> > > >> >>> - void (^nestedBad)(int x[2][_Nonnull 2]) = //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int [2]'}}
> >> > > >> >>> - ^(int x[2][_Nonnull 2]) {}; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'int [2]'}}
> >> > > >> >>> + void (^nestedBad)(int x[2][_Nonnull 2]) = //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int[2]'}}
> >> > > >> >>> + ^(int x[2][_Nonnull 2]) {}; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'int[2]'}}
> >> > > >> >>>
> >> > > >> >>> void (^withTypedef)(INTS _Nonnull) = ^(INTS _Nonnull x)
> {};
> >> > > >> >>> withTypedef(0); // expected-warning {{null passed to a
> callee that requires a non-null argument}}
> >> > > >> >>> - void (^withTypedefBad)(INTS _Nonnull [2]) = //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'INTS' (aka 'int [4]')}}
> >> > > >> >>> - ^(INTS _Nonnull x[2]) {}; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'INTS' (aka 'int [4]')}}
> >> > > >> >>> + void (^withTypedefBad)(INTS _Nonnull [2]) = //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'INTS' (aka 'int[4]')}}
> >> > > >> >>> + ^(INTS _Nonnull x[2]) {}; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'INTS' (aka 'int[4]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/predef.c
> b/clang/test/Sema/predef.c
> >> > > >> >>> index 95bcfb9d8d510..6db683eb66e1b 100644
> >> > > >> >>> --- a/clang/test/Sema/predef.c
> >> > > >> >>> +++ b/clang/test/Sema/predef.c
> >> > > >> >>> @@ -6,7 +6,7 @@ void abcdefghi12(void) {
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> char *X = __func__; // expected-warning {{predefined
> identifier is only valid}} \
> >> > > >> >>> - expected-warning {{initializing
> 'char *' with an expression of type 'const char [1]' discards qualifiers}}
> >> > > >> >>> + expected-warning {{initializing
> 'char *' with an expression of type 'const char[1]' discards qualifiers}}
> >> > > >> >>>
> >> > > >> >>> void a() {
> >> > > >> >>> __func__[0] = 'a'; // expected-error {{variable is not
> assignable}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/typedef-retain.c
> b/clang/test/Sema/typedef-retain.c
> >> > > >> >>> index d4358bce5ee5b..cbec109456a72 100644
> >> > > >> >>> --- a/clang/test/Sema/typedef-retain.c
> >> > > >> >>> +++ b/clang/test/Sema/typedef-retain.c
> >> > > >> >>> @@ -17,7 +17,7 @@ typedef int a[5];
> >> > > >> >>> void test3() {
> >> > > >> >>> typedef const a b;
> >> > > >> >>> b r; // expected-note {{variable 'r' declared const
> here}}
> >> > > >> >>> - r[0] = 10; // expected-error {{cannot assign to variable
> 'r' with const-qualified type 'b' (aka 'const int [5]')}}
> >> > > >> >>> + r[0] = 10; // expected-error {{cannot assign to variable
> 'r' with const-qualified type 'b' (aka 'const int[5]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> int test4(const a y) {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/types.c
> b/clang/test/Sema/types.c
> >> > > >> >>> index c306c1ead5c61..941b002890bbf 100644
> >> > > >> >>> --- a/clang/test/Sema/types.c
> >> > > >> >>> +++ b/clang/test/Sema/types.c
> >> > > >> >>> @@ -48,7 +48,7 @@ int i[(short)1];
> >> > > >> >>>
> >> > > >> >>> enum e { e_1 };
> >> > > >> >>> extern int j[sizeof(enum e)]; // expected-note {{previous
> declaration}}
> >> > > >> >>> -int j[42]; // expected-error {{redefinition of 'j' with a
> >> > > >> >>> diff erent type: 'int [42]' vs 'int [4]'}}
> >> > > >> >>> +int j[42]; // expected-error {{redefinition of 'j' with a
> >> > > >> >>> diff erent type: 'int[42]' vs 'int[4]'}}
> >> > > >> >>>
> >> > > >> >>> // rdar://6880104
> >> > > >> >>> _Decimal32 x; // expected-error {{GNU decimal type
> extension not supported}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/var-redecl.c
> b/clang/test/Sema/var-redecl.c
> >> > > >> >>> index 024bfd436a420..1c254f504f565 100644
> >> > > >> >>> --- a/clang/test/Sema/var-redecl.c
> >> > > >> >>> +++ b/clang/test/Sema/var-redecl.c
> >> > > >> >>> @@ -67,4 +67,4 @@ void f(int x) { // expected-note
> {{previous definition is here}}
> >> > > >> >>>
> >> > > >> >>> extern int b[];
> >> > > >> >>> void g20() { extern int b[3]; } // expected-note{{previous
> declaration is here}}
> >> > > >> >>> -void g21() { extern int b[4]; } //
> expected-error{{redeclaration of 'b' with a
> >> > > >> >>> diff erent type: 'int [4]' vs 'int [3]'}}
> >> > > >> >>> +void g21() { extern int b[4]; } //
> expected-error{{redeclaration of 'b' with a
> >> > > >> >>> diff erent type: 'int[4]' vs 'int[3]'}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/vla.cpp
> b/clang/test/Sema/vla.cpp
> >> > > >> >>> index b4416a07cf0ee..f7d2669fb499b 100644
> >> > > >> >>> --- a/clang/test/Sema/vla.cpp
> >> > > >> >>> +++ b/clang/test/Sema/vla.cpp
> >> > > >> >>> @@ -2,5 +2,5 @@
> >> > > >> >>>
> >> > > >> >>> void f1(int n) {
> >> > > >> >>> typedef int x[n];
> >> > > >> >>> - const x y; // expected-error {{default initialization of
> an object of const type 'const x' (aka 'const int [n]')}}
> >> > > >> >>> + const x y; // expected-error {{default initialization of
> an object of const type 'const x' (aka 'const int[n]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/warn-sizeof-array-decay.c
> b/clang/test/Sema/warn-sizeof-array-decay.c
> >> > > >> >>> index cc3ee1d0fc65f..1bf33e20ecad1 100644
> >> > > >> >>> --- a/clang/test/Sema/warn-sizeof-array-decay.c
> >> > > >> >>> +++ b/clang/test/Sema/warn-sizeof-array-decay.c
> >> > > >> >>> @@ -5,14 +5,14 @@ void f(int x) {
> >> > > >> >>> int bar[20];
> >> > > >> >>> char qux[30];
> >> > > >> >>>
> >> > > >> >>> - (void)sizeof(bar + 10); // expected-warning{{sizeof on
> pointer operation will return size of 'int *' instead of 'int [20]'}}
> >> > > >> >>> - (void)sizeof(foo - 20); // expected-warning{{sizeof on
> pointer operation will return size of 'char *' instead of 'char [10]'}}
> >> > > >> >>> - (void)sizeof(bar - x); // expected-warning{{sizeof on
> pointer operation will return size of 'int *' instead of 'int [20]'}}
> >> > > >> >>> - (void)sizeof(foo + x); // expected-warning{{sizeof on
> pointer operation will return size of 'char *' instead of 'char [10]'}}
> >> > > >> >>> + (void)sizeof(bar + 10); // expected-warning{{sizeof on
> pointer operation will return size of 'int *' instead of 'int[20]'}}
> >> > > >> >>> + (void)sizeof(foo - 20); // expected-warning{{sizeof on
> pointer operation will return size of 'char *' instead of 'char[10]'}}
> >> > > >> >>> + (void)sizeof(bar - x); // expected-warning{{sizeof on
> pointer operation will return size of 'int *' instead of 'int[20]'}}
> >> > > >> >>> + (void)sizeof(foo + x); // expected-warning{{sizeof on
> pointer operation will return size of 'char *' instead of 'char[10]'}}
> >> > > >> >>>
> >> > > >> >>> // This is ptr
> >> > > >> >>> diff _t.
> >> > > >> >>> (void)sizeof(foo - qux); // no-warning
> >> > > >> >>>
> >> > > >> >>> (void)sizeof(foo, x); // no-warning
> >> > > >> >>> - (void)sizeof(x, foo); // expected-warning{{sizeof on
> pointer operation will return size of 'char *' instead of 'char [10]'}}
> >> > > >> >>> + (void)sizeof(x, foo); // expected-warning{{sizeof on
> pointer operation will return size of 'char *' instead of 'char[10]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/warn-sizeof-arrayarg.c
> b/clang/test/Sema/warn-sizeof-arrayarg.c
> >> > > >> >>> index 32fd2b4d37458..7c1a9a2821617 100644
> >> > > >> >>> --- a/clang/test/Sema/warn-sizeof-arrayarg.c
> >> > > >> >>> +++ b/clang/test/Sema/warn-sizeof-arrayarg.c
> >> > > >> >>> @@ -8,13 +8,13 @@ void f(int a[10], Arr arr) { //
> expected-note 4 {{declared here}}
> >> > > >> >>>
> >> > > >> >>> /* Should warn. */
> >> > > >> >>> (void)sizeof(a); // \
> >> > > >> >>> - // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'int [10]'}}
> >> > > >> >>> + // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'int[10]'}}
> >> > > >> >>> (void)sizeof((((a)))); // \
> >> > > >> >>> - // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'int [10]'}}
> >> > > >> >>> + // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'int[10]'}}
> >> > > >> >>> (void)sizeof a; // \
> >> > > >> >>> - // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'int [10]'}}
> >> > > >> >>> + // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'int[10]'}}
> >> > > >> >>> (void)sizeof arr; // \
> >> > > >> >>> - // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'Arr' (aka 'int [10]')}}
> >> > > >> >>> + // expected-warning{{sizeof on array function
> parameter will return size of 'int *' instead of 'Arr' (aka 'int[10]')}}
> >> > > >> >>>
> >> > > >> >>> /* Shouldn't warn. */
> >> > > >> >>> int b[10];
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/Sema/warn-write-strings.c
> b/clang/test/Sema/warn-write-strings.c
> >> > > >> >>> index dee554cf6b575..d8e31d95df0f9 100644
> >> > > >> >>> --- a/clang/test/Sema/warn-write-strings.c
> >> > > >> >>> +++ b/clang/test/Sema/warn-write-strings.c
> >> > > >> >>> @@ -1,7 +1,7 @@
> >> > > >> >>> // RUN: %clang_cc1 -verify -fsyntax-only -fconst-strings %s
> >> > > >> >>>
> >> > > >> >>> // PR4804
> >> > > >> >>> -char* x = "foo"; // expected-warning {{initializing 'char
> *' with an expression of type 'const char [4]' discards qualifiers}}
> >> > > >> >>> +char* x = "foo"; // expected-warning {{initializing 'char
> *' with an expression of type 'const char[4]' discards qualifiers}}
> >> > > >> >>>
> >> > > >> >>> // PR7192
> >> > > >> >>> #include <stddef.h>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/MicrosoftExtensions.cpp
> b/clang/test/SemaCXX/MicrosoftExtensions.cpp
> >> > > >> >>> index 5dfadae3682a5..f1ba8afc221fc 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/MicrosoftExtensions.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/MicrosoftExtensions.cpp
> >> > > >> >>> @@ -96,7 +96,7 @@ void test_unaligned() {
> >> > > >> >>> p3_aligned_type4 = p1_aligned_type4;
> >> > > >> >>>
> >> > > >> >>> __unaligned int a[10];
> >> > > >> >>> - int *b = a; // expected-error {{cannot initialize a
> variable of type 'int *' with an lvalue of type '__unaligned int [10]'}}
> >> > > >> >>> + int *b = a; // expected-error {{cannot initialize a
> variable of type 'int *' with an lvalue of type '__unaligned int[10]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> // Test from PR27367
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/address-space-initialize.cpp
> b/clang/test/SemaCXX/address-space-initialize.cpp
> >> > > >> >>> index 50913384c5cf9..bd5ee926f5b6b 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/address-space-initialize.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/address-space-initialize.cpp
> >> > > >> >>> @@ -17,7 +17,7 @@ int nocv_iarray[10] = { 4 };
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> __attribute__((address_space(9999)))
> >> > > >> >>> -int* as_ptr = nocv_iarray; // expected-error{{cannot
> initialize a variable of type '__attribute__((address_space(9999))) int *'
> with an lvalue of type '__attribute__((address_space(42))) int [10]'}}
> >> > > >> >>> +int* as_ptr = nocv_iarray; // expected-error{{cannot
> initialize a variable of type '__attribute__((address_space(9999))) int *'
> with an lvalue of type '__attribute__((address_space(42))) int[10]'}}
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> __attribute__((address_space(42))) int*
> __attribute__((address_space(42))) ptr_in_same_addr_space = nocv_iarray;
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/alias-template.cpp
> b/clang/test/SemaCXX/alias-template.cpp
> >> > > >> >>> index f41c3aa8bca6a..0e5d9dae7bb7f 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/alias-template.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/alias-template.cpp
> >> > > >> >>> @@ -37,7 +37,7 @@ namespace VariableLengthArrays {
> >> > > >> >>> const int m = 42;
> >> > > >> >>> template<typename Z> using U = int[m];
> >> > > >> >>> template<typename Z> using U = int[42]; // expected-note
> {{previous definition}}
> >> > > >> >>> - template<typename Z> using U = int; // expected-error
> {{type alias template redefinition with
> >> > > >> >>> diff erent types ('int' vs 'int [42]')}}
> >> > > >> >>> + template<typename Z> using U = int; // expected-error
> {{type alias template redefinition with
> >> > > >> >>> diff erent types ('int' vs 'int[42]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace RedeclFunc {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/array-bound-merge.cpp
> b/clang/test/SemaCXX/array-bound-merge.cpp
> >> > > >> >>> index a360d007c3b7b..02d1916f6ee7f 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/array-bound-merge.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/array-bound-merge.cpp
> >> > > >> >>> @@ -8,7 +8,7 @@ int b[];
> >> > > >> >>> extern int c[1];
> >> > > >> >>> int c[] = {1,2}; // expected-error {{excess elements in
> array initializer}}
> >> > > >> >>>
> >> > > >> >>> -int d[1][]; // expected-error {{array has incomplete
> element type 'int []'}}
> >> > > >> >>> +int d[1][]; // expected-error {{array has incomplete
> element type 'int[]'}}
> >> > > >> >>>
> >> > > >> >>> extern const int e[2]; // expected-note {{previous
> declaration is here}}
> >> > > >> >>> -int e[] = { 1 }; // expected-error {{redefinition of 'e'
> with a
> >> > > >> >>> diff erent type: 'int []' vs 'const int [2]'}}
> >> > > >> >>> +int e[] = { 1 }; // expected-error {{redefinition of 'e'
> with a
> >> > > >> >>> diff erent type: 'int[]' vs 'const int[2]'}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/attr-gnu.cpp
> b/clang/test/SemaCXX/attr-gnu.cpp
> >> > > >> >>> index 83e58bbcd5e22..c257c2b029127 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/attr-gnu.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/attr-gnu.cpp
> >> > > >> >>> @@ -13,10 +13,10 @@ void f() {
> >> > > >> >>> void g(int a[static [[]] 5]); // expected-error {{static
> array size is a C99 feature, not permitted in C++}}
> >> > > >> >>>
> >> > > >> >>> template<typename T> struct A {
> >> > > >> >>> - int x[sizeof(T)] __attribute((vector_size(8))); //
> expected-error {{invalid vector element type 'int [sizeof(T)]'}}
> >> > > >> >>> + int x[sizeof(T)] __attribute((vector_size(8))); //
> expected-error {{invalid vector element type 'int[sizeof(T)]'}}
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> -typedef int myvect[4] __attribute__((vector_size(16))); //
> expected-error {{invalid vector element type 'int [4]'}}
> >> > > >> >>> +typedef int myvect[4] __attribute__((vector_size(16))); //
> expected-error {{invalid vector element type 'int[4]'}}
> >> > > >> >>> void foo(myvect *in, myvect *out) { (*out)[0] = (*in)[0]; }
> >> > > >> >>>
> >> > > >> >>> namespace {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/c99-variable-length-array-cxx11.cpp
> b/clang/test/SemaCXX/c99-variable-length-array-cxx11.cpp
> >> > > >> >>> index 1360a20bfe8c9..15757f52af8b8 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/c99-variable-length-array-cxx11.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/c99-variable-length-array-cxx11.cpp
> >> > > >> >>> @@ -22,7 +22,7 @@ void vla(int N) { // expected-note
> 5{{here}}
> >> > > >> >>> POD array2[N]; // expected-warning{{variable length
> arrays are a C99 feature}} expected-note {{parameter 'N'}}
> >> > > >> >>> StillPOD array3[N]; // expected-warning{{variable length
> arrays are a C99 feature}} expected-note {{parameter 'N'}}
> >> > > >> >>> StillPOD2 array4[N][3]; // expected-warning{{variable
> length arrays are a C99 feature}} expected-note {{parameter 'N'}}
> >> > > >> >>> - NonPOD array5[N]; // expected-error{{no matching
> constructor for initialization of 'NonPOD [N]'}}
> >> > > >> >>> + NonPOD array5[N]; // expected-error{{no matching
> constructor for initialization of 'NonPOD[N]'}}
> >> > > >> >>> // expected-warning at -1{{variable length arrays are a C99
> feature}} expected-note at -1 {{parameter 'N'}}
> >> > > >> >>> // expected-note at -16{{candidate constructor not viable}}
> >> > > >> >>> // expected-note at -18{{candidate constructor (the
> implicit copy constructor) not viable}}
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/c99-variable-length-array.cpp
> b/clang/test/SemaCXX/c99-variable-length-array.cpp
> >> > > >> >>> index 5f6337e1db061..726187ed0763a 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/c99-variable-length-array.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/c99-variable-length-array.cpp
> >> > > >> >>> @@ -52,7 +52,7 @@ template<typename T> struct X0 { };
> >> > > >> >>> // argument.
> >> > > >> >>> void inst_with_vla(int N) {
> >> > > >> >>> int array[N]; // expected-warning{{variable length arrays
> are a C99 feature}}
> >> > > >> >>> - X0<__typeof__(array)> x0a; // expected-error{{variably
> modified type 'typeof (array)' (aka 'int [N]') cannot be used as a template
> argument}}
> >> > > >> >>> + X0<__typeof__(array)> x0a; // expected-error{{variably
> modified type 'typeof (array)' (aka 'int[N]') cannot be used as a template
> argument}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> template<typename T>
> >> > > >> >>> @@ -70,7 +70,7 @@ X1<HasNonConstantValue> x1b; //
> expected-note{{in instantiation of}}
> >> > > >> >>> // Template argument deduction does not allow deducing a
> size from a VLA.
> >> > > >> >>> // FIXME: This diagnostic should make it clear that the two
> 'N's are
> >> > > >> >>> diff erent entities!
> >> > > >> >>> template<typename T, unsigned N>
> >> > > >> >>> -void accept_array(T (&array)[N]); //
> expected-note{{candidate template ignored: could not match 'T [N]' against
> 'int [N]'}}
> >> > > >> >>> +void accept_array(T (&array)[N]); //
> expected-note{{candidate template ignored: could not match 'T[N]' against
> 'int[N]'}}
> >> > > >> >>>
> >> > > >> >>> void test_accept_array(int N) {
> >> > > >> >>> int array[N]; // expected-warning{{variable length arrays
> are a C99 feature}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/compare-cxx2a.cpp
> b/clang/test/SemaCXX/compare-cxx2a.cpp
> >> > > >> >>> index fdeb93153715d..61b8558ccc02c 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/compare-cxx2a.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/compare-cxx2a.cpp
> >> > > >> >>> @@ -351,7 +351,7 @@ void test_array_conv() {
> >> > > >> >>> int arr[5];
> >> > > >> >>> int *ap = arr + 2;
> >> > > >> >>> int arr2[3];
> >> > > >> >>> - (void)(arr <=> arr); // expected-error {{invalid operands
> to binary expression ('int [5]' and 'int [5]')}}
> >> > > >> >>> + (void)(arr <=> arr); // expected-error {{invalid operands
> to binary expression ('int[5]' and 'int[5]')}}
> >> > > >> >>> (void)(+arr <=> arr);
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/constant-expression-cxx11.cpp
> b/clang/test/SemaCXX/constant-expression-cxx11.cpp
> >> > > >> >>> index 8d7e460c4b1ab..c338214b82312 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/constant-expression-cxx11.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/constant-expression-cxx11.cpp
> >> > > >> >>> @@ -2065,11 +2065,11 @@ namespace ZeroSizeTypes {
> >> > > >> >>> constexpr int (*p1)[0] = 0, (*p2)[0] = 0;
> >> > > >> >>> constexpr int k = p2 - p1;
> >> > > >> >>> // expected-error at -1 {{constexpr variable 'k' must be
> initialized by a constant expression}}
> >> > > >> >>> - // expected-note at -2 {{subtraction of pointers to type
> 'int [0]' of zero size}}
> >> > > >> >>> + // expected-note at -2 {{subtraction of pointers to type
> 'int[0]' of zero size}}
> >> > > >> >>>
> >> > > >> >>> int arr[5][0];
> >> > > >> >>> constexpr int f() { // expected-error {{never produces a
> constant expression}}
> >> > > >> >>> - return &arr[3] - &arr[0]; // expected-note
> {{subtraction of pointers to type 'int [0]' of zero size}}
> >> > > >> >>> + return &arr[3] - &arr[0]; // expected-note
> {{subtraction of pointers to type 'int[0]' of zero size}}
> >> > > >> >>> }
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/constant-expression-cxx2a.cpp
> b/clang/test/SemaCXX/constant-expression-cxx2a.cpp
> >> > > >> >>> index caba033476698..88c20c8d1bc69 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/constant-expression-cxx2a.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/constant-expression-cxx2a.cpp
> >> > > >> >>> @@ -816,15 +816,15 @@ namespace dynamic_alloc {
> >> > > >> >>> S *p = new T[3]{&a, &a, &a}; // expected-note 2{{heap
> allocation}}
> >> > > >> >>> switch (mode) {
> >> > > >> >>> case 0:
> >> > > >> >>> - delete p; // expected-note {{non-array delete used to
> delete pointer to array object of type 'T [3]'}}
> >> > > >> >>> + delete p; // expected-note {{non-array delete used to
> delete pointer to array object of type 'T[3]'}}
> >> > > >> >>> break;
> >> > > >> >>> case 1:
> >> > > >> >>> // FIXME: This diagnosic isn't great; we should
> mention the cast to S*
> >> > > >> >>> // somewhere in here.
> >> > > >> >>> - delete[] p; // expected-note {{delete of pointer to
> subobject '&{*new T [3]#0}[0]'}}
> >> > > >> >>> + delete[] p; // expected-note {{delete of pointer to
> subobject '&{*new T[3]#0}[0]'}}
> >> > > >> >>> break;
> >> > > >> >>> case 2:
> >> > > >> >>> - delete (T*)p; // expected-note {{non-array delete
> used to delete pointer to array object of type 'T [3]'}}
> >> > > >> >>> + delete (T*)p; // expected-note {{non-array delete
> used to delete pointer to array object of type 'T[3]'}}
> >> > > >> >>> break;
> >> > > >> >>> case 3:
> >> > > >> >>> delete[] (T*)p;
> >> > > >> >>> @@ -1033,7 +1033,7 @@ namespace delete_random_things {
> >> > > >> >>> struct A { int n; };
> >> > > >> >>> static_assert((delete &(new A)->n, true)); //
> expected-error {{}} expected-note {{delete of pointer to subobject '&{*new
> delete_random_things::A#0}.n'}}
> >> > > >> >>> static_assert((delete (new int + 1), true)); //
> expected-error {{}} expected-note {{delete of pointer '&{*new int#0} + 1'
> that does not point to complete object}}
> >> > > >> >>> - static_assert((delete[] (new int[3] + 1), true)); //
> expected-error {{}} expected-note {{delete of pointer to subobject '&{*new
> int [3]#0}[1]'}}
> >> > > >> >>> + static_assert((delete[] (new int[3] + 1), true)); //
> expected-error {{}} expected-note {{delete of pointer to subobject '&{*new
> int[3]#0}[1]'}}
> >> > > >> >>> static_assert((delete &(int&)(int&&)0, true)); //
> expected-error {{}} expected-note {{delete of pointer '&0' that does not
> point to a heap-allocated object}} expected-note {{temporary created here}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
> b/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
> >> > > >> >>> index 5b5d1cb7bc807..cb1812905d3d2 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
> >> > > >> >>> @@ -204,7 +204,7 @@ void backtrace() {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> struct B {
> >> > > >> >>> - // expected-note at +1 {{invalid type 'A [10]' is a
> member of 'B'}}
> >> > > >> >>> + // expected-note at +1 {{invalid type 'A[10]' is a member
> of 'B'}}
> >> > > >> >>> A as[10];
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/constexpr-string.cpp
> b/clang/test/SemaCXX/constexpr-string.cpp
> >> > > >> >>> index f33627e812b22..401f64945ef5c 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/constexpr-string.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/constexpr-string.cpp
> >> > > >> >>> @@ -661,7 +661,7 @@ namespace MemcpyEtc {
> >> > > >> >>> constexpr int test_address_of_incomplete_array_type() {
> // expected-error {{never produces a constant}}
> >> > > >> >>> extern int arr[];
> >> > > >> >>> __builtin_memmove(&arr, &arr, 4 * sizeof(arr[0]));
> >> > > >> >>> - // expected-note at -1 2{{cannot constant evaluate
> 'memmove' between objects of incomplete type 'int []'}}
> >> > > >> >>> + // expected-note at -1 2{{cannot constant evaluate
> 'memmove' between objects of incomplete type 'int[]'}}
> >> > > >> >>> return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 +
> arr[3];
> >> > > >> >>> }
> >> > > >> >>> static_assert(test_address_of_incomplete_array_type() ==
> 1234); // expected-error {{constant}} expected-note {{in call}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/coroutines.cpp
> b/clang/test/SemaCXX/coroutines.cpp
> >> > > >> >>> index 681af0a7f884c..9222066e87938 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/coroutines.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/coroutines.cpp
> >> > > >> >>> @@ -189,7 +189,7 @@ void coreturn(int n) {
> >> > > >> >>> if (n == 1)
> >> > > >> >>> co_return {4}; // expected-warning {{braces around
> scalar initializer}}
> >> > > >> >>> if (n == 2)
> >> > > >> >>> - co_return "foo"; // expected-error {{cannot initialize
> a parameter of type 'int' with an lvalue of type 'const char [4]'}}
> >> > > >> >>> + co_return "foo"; // expected-error {{cannot initialize
> a parameter of type 'int' with an lvalue of type 'const char[4]'}}
> >> > > >> >>> co_return 42;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp
> b/clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp
> >> > > >> >>> index 94fee530aea6a..e25b2cb25ee6b 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp
> >> > > >> >>> @@ -127,7 +127,7 @@ namespace multidimensional_array {
> >> > > >> >>>
> >> > > >> >>> namespace array_addressof {
> >> > > >> >>> using T = int[5];
> >> > > >> >>> - T *p = &T{1,2,3,4,5}; // expected-error {{taking the
> address of a temporary object of type 'array_addressof::T' (aka 'int [5]')}}
> >> > > >> >>> + T *p = &T{1,2,3,4,5}; // expected-error {{taking the
> address of a temporary object of type 'array_addressof::T' (aka 'int[5]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> namespace PR24816 {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaCXX/cxx0x-type-convert-construct.cpp
> b/clang/test/SemaCXX/cxx0x-type-convert-construct.cpp
> >> > > >> >>> index 25a43d7053ccd..a58a82ac2aaf5 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/cxx0x-type-convert-construct.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/cxx0x-type-convert-construct.cpp
> >> > > >> >>> @@ -2,20 +2,20 @@
> >> > > >> >>>
> >> > > >> >>> void f() {
> >> > > >> >>> char *u8str;
> >> > > >> >>> - u8str = u8"a UTF-8 string"; // expected-error {{assigning
> to 'char *' from incompatible type 'const char [15]'}}
> >> > > >> >>> + 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]'}}
> >> > > >> >>> + 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]'}}
> >> > > >> >>> + 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{{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{{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]'}}
> >> > > >> >>> + 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]'}}
> >> > > >> >>> + 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]'}}
> >> > > >> >>> + URstr = UR"foo(a UTF-32 raw string)foo"; //
> expected-error {{assigning to 'char32_t *' from incompatible type 'const
> char32_t[20]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/cxx1z-decomposition.cpp
> b/clang/test/SemaCXX/cxx1z-decomposition.cpp
> >> > > >> >>> index 1ce75fe48db33..26fbbadafdcbf 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/cxx1z-decomposition.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/cxx1z-decomposition.cpp
> >> > > >> >>> @@ -10,13 +10,13 @@ void num_elems() {
> >> > > >> >>>
> >> > > >> >>> auto [] = a0; // expected-warning {{does not allow a
> decomposition group to be empty}}
> >> > > >> >>> auto [v1] = a0; // expected-error {{type 'A0' decomposes
> into 0 elements, but 1 name was provided}}
> >> > > >> >>> - auto [] = a1; // expected-error {{type 'int [1]'
> decomposes into 1 element, but no names were provided}} expected-warning
> {{empty}}
> >> > > >> >>> + auto [] = a1; // expected-error {{type 'int[1]'
> decomposes into 1 element, but no names were provided}} expected-warning
> {{empty}}
> >> > > >> >>> auto [v2] = a1;
> >> > > >> >>> - auto [v3, v4] = a1; // expected-error {{type 'int [1]'
> decomposes into 1 element, but 2 names were provided}}
> >> > > >> >>> - auto [] = a2; // expected-error {{type 'int [2]'
> decomposes into 2 elements, but no names were provided}} expected-warning
> {{empty}}
> >> > > >> >>> - auto [v5] = a2; // expected-error {{type 'int [2]'
> decomposes into 2 elements, but only 1 name was provided}}
> >> > > >> >>> + auto [v3, v4] = a1; // expected-error {{type 'int[1]'
> decomposes into 1 element, but 2 names were provided}}
> >> > > >> >>> + auto [] = a2; // expected-error {{type 'int[2]'
> decomposes into 2 elements, but no names were provided}} expected-warning
> {{empty}}
> >> > > >> >>> + auto [v5] = a2; // expected-error {{type 'int[2]'
> decomposes into 2 elements, but only 1 name was provided}}
> >> > > >> >>> auto [v6, v7] = a2;
> >> > > >> >>> - auto [v8, v9, v10] = a2; // expected-error {{type 'int
> [2]' decomposes into 2 elements, but 3 names were provided}}
> >> > > >> >>> + auto [v8, v9, v10] = a2; // expected-error {{type
> 'int[2]' decomposes into 2 elements, but 3 names were provided}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> // As a Clang extension, _Complex can be decomposed.
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/cxx2a-compat.cpp
> b/clang/test/SemaCXX/cxx2a-compat.cpp
> >> > > >> >>> index de9d4442a45eb..0e9eafdc9b702 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/cxx2a-compat.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/cxx2a-compat.cpp
> >> > > >> >>> @@ -34,8 +34,8 @@ string u8str = u8"test" u8"test";
> >> > > >> >>> // expected-warning at -4 {{type of UTF-8 string literal will
> change}} expected-note at -4 {{remove 'u8' prefix}}
> >> > > >> >>> #else
> >> > > >> >>> // expected-error at -8 {{ISO C++20 does not permit
> initialization of char array with UTF-8 string literal}}
> >> > > >> >>> -// expected-error at -8 {{cannot initialize a variable of
> type 'const char *' with an lvalue of type 'const char8_t [6]'}}
> >> > > >> >>> -// expected-error at -8 {{no viable conversion from 'const
> char8_t [9]' to 'string'}}
> >> > > >> >>> +// expected-error at -8 {{cannot initialize a variable of
> type 'const char *' with an lvalue of type 'const char8_t[6]'}}
> >> > > >> >>> +// expected-error at -8 {{no viable conversion from 'const
> char8_t[9]' to 'string'}}
> >> > > >> >>> #endif
> >> > > >> >>>
> >> > > >> >>> template<bool b>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/dcl_init_aggr.cpp
> b/clang/test/SemaCXX/dcl_init_aggr.cpp
> >> > > >> >>> index 2b5149cf278f9..af04766c0e334 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/dcl_init_aggr.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/dcl_init_aggr.cpp
> >> > > >> >>> @@ -176,4 +176,4 @@ u u1 = { 1 };
> >> > > >> >>> u u2 = u1;
> >> > > >> >>> u u3 = 1; // expected-error{{no viable conversion}}
> >> > > >> >>> u u4 = { 0, "asdf" }; // expected-error{{excess elements
> in union initializer}}
> >> > > >> >>> -u u5 = { "asdf" }; // expected-error{{cannot initialize a
> member subobject of type 'int' with an lvalue of type 'const char [5]'}}
> >> > > >> >>> +u u5 = { "asdf" }; // expected-error{{cannot initialize a
> member subobject of type 'int' with an lvalue of type 'const char[5]'}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/decl-init-ref.cpp
> b/clang/test/SemaCXX/decl-init-ref.cpp
> >> > > >> >>> index f515630d3f5e1..e0ff2daf07928 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/decl-init-ref.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/decl-init-ref.cpp
> >> > > >> >>> @@ -26,10 +26,10 @@ int main() {
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> struct PR6139 { A (&x)[1]; };
> >> > > >> >>> -PR6139 x = {{A()}}; // expected-error{{non-const lvalue
> reference to type 'A [1]' cannot bind to an initializer list temporary}}
> >> > > >> >>> +PR6139 x = {{A()}}; // expected-error{{non-const lvalue
> reference to type 'A[1]' cannot bind to an initializer list temporary}}
> >> > > >> >>>
> >> > > >> >>> struct PR6139b { A (&x)[1]; };
> >> > > >> >>> -PR6139b y = {A()}; // expected-error{{non-const lvalue
> reference to type 'A [1]' cannot bind to a temporary of type 'A'}}
> >> > > >> >>> +PR6139b y = {A()}; // expected-error{{non-const lvalue
> reference to type 'A[1]' cannot bind to a temporary of type 'A'}}
> >> > > >> >>>
> >> > > >> >>> namespace PR16502 {
> >> > > >> >>> struct A { int &&temporary; int x, y; };
> >> > > >> >>> @@ -39,7 +39,7 @@ namespace PR16502 {
> >> > > >> >>>
> >> > > >> >>> namespace IncompleteTest {
> >> > > >> >>> struct String;
> >> > > >> >>> - // expected-error at +1 {{reference to incomplete type
> 'const IncompleteTest::String' could not bind to an lvalue of type 'const
> char [1]'}}
> >> > > >> >>> + // expected-error at +1 {{reference to incomplete type
> 'const IncompleteTest::String' could not bind to an lvalue of type 'const
> char[1]'}}
> >> > > >> >>> void takeString(const String& = "") {} // expected-note
> {{passing argument to parameter here}}
> >> > > >> >>> void test() {
> >> > > >> >>> takeString();
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/exceptions.cpp
> b/clang/test/SemaCXX/exceptions.cpp
> >> > > >> >>> index 1e786adaa1b41..61c3e4bccb2be 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/exceptions.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/exceptions.cpp
> >> > > >> >>> @@ -157,7 +157,7 @@ namespace Decay {
> >> > > >> >>>
> >> > > >> >>> C<E[10]> e;
> >> > > >> >>> #if __cplusplus <= 199711L
> >> > > >> >>> - // expected-note at -2 {{in instantiation of template class
> 'Decay::C<Decay::E [10]>' requested here}}
> >> > > >> >>> + // expected-note at -2 {{in instantiation of template class
> 'Decay::C<Decay::E[10]>' requested here}}
> >> > > >> >>> #endif
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/flexible-array-test.cpp
> b/clang/test/SemaCXX/flexible-array-test.cpp
> >> > > >> >>> index f2105ca361300..19f130288b610 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/flexible-array-test.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/flexible-array-test.cpp
> >> > > >> >>> @@ -67,7 +67,7 @@ union B {
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> class C {
> >> > > >> >>> - char c[]; // expected-error {{flexible array member 'c'
> with type 'char []' is not at the end of class}}
> >> > > >> >>> + char c[]; // expected-error {{flexible array member 'c'
> with type 'char[]' is not at the end of class}}
> >> > > >> >>> int s; // expected-note {{next field declaration is here}}
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> @@ -93,7 +93,7 @@ struct NonTrivDtor { ~NonTrivDtor(); };
> >> > > >> >>> // FIXME: It's not clear whether we should disallow
> examples like this. GCC accepts.
> >> > > >> >>> struct FlexNonTrivDtor {
> >> > > >> >>> int n;
> >> > > >> >>> - NonTrivDtor ntd[]; // expected-error {{flexible array
> member 'ntd' of type 'NonTrivDtor []' with non-trivial destruction}}
> >> > > >> >>> + NonTrivDtor ntd[]; // expected-error {{flexible array
> member 'ntd' of type 'NonTrivDtor[]' with non-trivial destruction}}
> >> > > >> >>> ~FlexNonTrivDtor() {
> >> > > >> >>> for (int i = n; i != 0; --i)
> >> > > >> >>> ntd[i-1].~NonTrivDtor();
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/for-range-examples.cpp
> b/clang/test/SemaCXX/for-range-examples.cpp
> >> > > >> >>> index 5424b7a8ee797..5376f48ff8e7f 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/for-range-examples.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/for-range-examples.cpp
> >> > > >> >>> @@ -196,7 +196,7 @@ namespace test5 {
> >> > > >> >>> namespace test6 {
> >> > > >> >>> void foo(int arr[]) { // expected-note {{declared here}}
> >> > > >> >>> for (auto i : arr) { }
> >> > > >> >>> - // expected-error at -1 {{cannot build range expression
> with array function parameter 'arr' since parameter with array type 'int
> []' is treated as pointer type 'int *'}}
> >> > > >> >>> + // expected-error at -1 {{cannot build range expression
> with array function parameter 'arr' since parameter with array type 'int[]'
> is treated as pointer type 'int *'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> struct vector {
> >> > > >> >>> @@ -207,7 +207,7 @@ namespace test6 {
> >> > > >> >>> void foo(vector arr[]) { // expected-note {{declared
> here}}
> >> > > >> >>> // Don't suggest to dereference arr.
> >> > > >> >>> for (auto i : arr) { }
> >> > > >> >>> - // expected-error at -1 {{cannot build range expression
> with array function parameter 'arr' since parameter with array type
> 'test6::vector []' is treated as pointer type 'test6::vector *'}}
> >> > > >> >>> + // expected-error at -1 {{cannot build range expression
> with array function parameter 'arr' since parameter with array type
> 'test6::vector[]' is treated as pointer type 'test6::vector *'}}
> >> > > >> >>> }
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/new-delete.cpp
> b/clang/test/SemaCXX/new-delete.cpp
> >> > > >> >>> index b26aba1296eb3..52dbe00f7e000 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/new-delete.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/new-delete.cpp
> >> > > >> >>> @@ -353,7 +353,7 @@ void h(unsigned i) {
> >> > > >> >>> (void)new T(i); // expected-error {{array 'new' cannot
> have initialization arguments}}
> >> > > >> >>> }
> >> > > >> >>> template void h<unsigned>(unsigned);
> >> > > >> >>> -template void h<unsigned[10]>(unsigned); // expected-note
> {{in instantiation of function template specialization 'Test1::h<unsigned
> int [10]>' requested here}}
> >> > > >> >>> +template void h<unsigned[10]>(unsigned); // expected-note
> {{in instantiation of function template specialization 'Test1::h<unsigned
> int[10]>' requested here}}
> >> > > >> >>>
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/no-wchar.cpp
> b/clang/test/SemaCXX/no-wchar.cpp
> >> > > >> >>> index 040b46cdf5e5b..93e17f29265b2 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/no-wchar.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/no-wchar.cpp
> >> > > >> >>> @@ -18,9 +18,9 @@ void foo1(wchar_t * t = L"");
> >> > > >> >>> #endif
> >> > > >> >>>
> >> > > >> >>> short *a = L"";
> >> > > >> >>> -// expected-error at -1 {{cannot initialize a variable of
> type 'short *' with an lvalue of type 'const unsigned short [1]'}}
> >> > > >> >>> +// expected-error at -1 {{cannot initialize a variable of
> type 'short *' with an lvalue of type 'const unsigned short[1]'}}
> >> > > >> >>> char *b = L"";
> >> > > >> >>> -// expected-error at -1 {{cannot initialize a variable of
> type 'char *' with an lvalue of type 'const unsigned short [1]'}}
> >> > > >> >>> +// expected-error at -1 {{cannot initialize a variable of
> type 'char *' with an lvalue of type 'const unsigned short[1]'}}
> >> > > >> >>>
> >> > > >> >>> // NOTE: MSVC allows deprecated conversion in conditional
> expression if at least
> >> > > >> >>> // one of the operand is a string literal but Clang doesn't
> allow it.
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/nullability.cpp
> b/clang/test/SemaCXX/nullability.cpp
> >> > > >> >>> index 91ecc447c5347..978b90564a2a8 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/nullability.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/nullability.cpp
> >> > > >> >>> @@ -126,11 +126,11 @@ void arraysInLambdas() {
> >> > > >> >>> simple(nullptr); // expected-warning {{null passed to a
> callee that requires a non-null argument}}
> >> > > >> >>> auto nested = [](void *_Nullable [_Nonnull 2]) {};
> >> > > >> >>> nested(nullptr); // expected-warning {{null passed to a
> callee that requires a non-null argument}}
> >> > > >> >>> - auto nestedBad = [](int [2][_Nonnull 2]) {}; //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int [2]'}}
> >> > > >> >>> + auto nestedBad = [](int [2][_Nonnull 2]) {}; //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'int[2]'}}
> >> > > >> >>>
> >> > > >> >>> auto withTypedef = [](INTS _Nonnull) {};
> >> > > >> >>> withTypedef(nullptr); // expected-warning {{null passed
> to a callee that requires a non-null argument}}
> >> > > >> >>> - auto withTypedefBad = [](INTS _Nonnull[2]) {}; //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'INTS' (aka 'int [4]')}}
> >> > > >> >>> + auto withTypedefBad = [](INTS _Nonnull[2]) {}; //
> expected-error {{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'INTS' (aka 'int[4]')}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> void testNullabilityCompletenessWithTemplate() {
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/overload-call.cpp
> b/clang/test/SemaCXX/overload-call.cpp
> >> > > >> >>> index a34bce5014ab5..0e5978e56f889 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/overload-call.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/overload-call.cpp
> >> > > >> >>> @@ -339,8 +339,8 @@ namespace PR5756 {
> >> > > >> >>> // Tests the exact text used to note the candidates
> >> > > >> >>> namespace test1 {
> >> > > >> >>> template <class T>
> >> > > >> >>> -void foo(T t, unsigned N); //
> expected-note {{candidate function template not viable: no known conversion
> from 'const char [6]' to 'unsigned int' for 2nd argument}}
> >> > > >> >>> -void foo(int n, char N); //
> expected-note {{candidate function not viable: no known conversion from
> 'const char [6]' to 'char' for 2nd argument}}
> >> > > >> >>> +void foo(T t, unsigned N); //
> expected-note {{candidate function template not viable: no known conversion
> from 'const char[6]' to 'unsigned int' for 2nd argument}}
> >> > > >> >>> +void foo(int n, char N); //
> expected-note {{candidate function not viable: no known conversion from
> 'const char[6]' to 'char' for 2nd argument}}
> >> > > >> >>> void foo(int n, const char *s, int t); //
> expected-note {{candidate function not viable: requires 3 arguments, but 2
> were provided}}
> >> > > >> >>> void foo(int n, const char *s, int t, ...); //
> expected-note {{candidate function not viable: requires at least 3
> arguments, but 2 were provided}}
> >> > > >> >>> void foo(int n, const char *s, int t, int u = 0); //
> expected-note {{candidate function not viable: requires at least 3
> arguments, but 2 were provided}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/overload-member-call.cpp
> b/clang/test/SemaCXX/overload-member-call.cpp
> >> > > >> >>> index 9d0fc519b0cc7..0cf32694a1caa 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/overload-member-call.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/overload-member-call.cpp
> >> > > >> >>> @@ -71,8 +71,8 @@ void test_X2(X2 *x2p, const X2 *cx2p) {
> >> > > >> >>> namespace test1 {
> >> > > >> >>> class A {
> >> > > >> >>> template <class T>
> >> > > >> >>> - void foo(T t, unsigned N); // expected-note {{candidate
> function template not viable: no known conversion from 'const char [6]' to
> 'unsigned int' for 2nd argument}}
> >> > > >> >>> - void foo(int n, char N); // expected-note {{candidate
> function not viable: no known conversion from 'const char [6]' to 'char'
> for 2nd argument}}
> >> > > >> >>> + void foo(T t, unsigned N); // expected-note {{candidate
> function template not viable: no known conversion from 'const char[6]' to
> 'unsigned int' for 2nd argument}}
> >> > > >> >>> + void foo(int n, char N); // expected-note {{candidate
> function not viable: no known conversion from 'const char[6]' to 'char' for
> 2nd argument}}
> >> > > >> >>> void foo(int n, const char *s, int t); // expected-note
> {{candidate function not viable: requires 3 arguments, but 2 were provided}}
> >> > > >> >>> void foo(int n, const char *s, int t, ...); //
> expected-note {{candidate function not viable: requires at least 3
> arguments, but 2 were provided}}
> >> > > >> >>> void foo(int n, const char *s, int t, int u = 0); //
> expected-note {{candidate function not viable: requires at least 3
> arguments, but 2 were provided}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/static-assert-cxx17.cpp
> b/clang/test/SemaCXX/static-assert-cxx17.cpp
> >> > > >> >>> index d5601839bdd3e..ce9826795d5de 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/static-assert-cxx17.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/static-assert-cxx17.cpp
> >> > > >> >>> @@ -46,7 +46,7 @@ template void foo3<S2<long>, int, float>();
> >> > > >> >>> template <typename T>
> >> > > >> >>> void foo4() {
> >> > > >> >>> static_assert(S1<T[sizeof(T)], int[4]>::value, "");
> >> > > >> >>> - // expected-error at -1{{static_assert failed due to
> requirement 'S1<float [4], int [4]>::value'}}
> >> > > >> >>> + // expected-error at -1{{static_assert failed due to
> requirement 'S1<float[4], int[4]>::value'}}
> >> > > >> >>> };
> >> > > >> >>> template void foo4<float>();
> >> > > >> >>> // expected-note at -1{{in instantiation of function template
> specialization 'foo4<float>' requested here}}
> >> > > >> >>> @@ -94,7 +94,7 @@ void foo6() {
> >> > > >> >>> static_assert(static_cast<const X<typename T::T>
> *>(nullptr));
> >> > > >> >>> // expected-error at -1{{static_assert failed due to
> requirement 'static_cast<const X<int> *>(nullptr)'}}
> >> > > >> >>> static_assert((const X<typename T::T>[]){} == nullptr);
> >> > > >> >>> - // expected-error at -1{{static_assert failed due to
> requirement '(const X<int> [0]){} == nullptr'}}
> >> > > >> >>> + // expected-error at -1{{static_assert failed due to
> requirement '(const X<int>[0]){} == nullptr'}}
> >> > > >> >>> static_assert(sizeof(X<decltype(X<typename
> T::T>().X<typename T::T>::~X())>) == 0);
> >> > > >> >>> // expected-error at -1{{static_assert failed due to
> requirement 'sizeof(X<void>) == 0'}}
> >> > > >> >>> static_assert(constexpr_return_false<typename T::T,
> typename T::U>());
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/typedef-redecl.cpp
> b/clang/test/SemaCXX/typedef-redecl.cpp
> >> > > >> >>> index 06883ffd4b5ef..adeda317c1f7b 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/typedef-redecl.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/typedef-redecl.cpp
> >> > > >> >>> @@ -68,7 +68,7 @@ namespace PR11630 {
> >> > > >> >>> static void f()
> >> > > >> >>> {
> >> > > >> >>> typedef int q[C == 1 ? 1 : -1]; //
> expected-note{{previous definition is here}}
> >> > > >> >>> - typedef int q[C >= 1 ? 2 : -2]; //
> expected-error{{typedef redefinition with
> >> > > >> >>> diff erent types ('int [2]' vs 'int [1]')}}
> >> > > >> >>> + typedef int q[C >= 1 ? 2 : -2]; //
> expected-error{{typedef redefinition with
> >> > > >> >>> diff erent types ('int[2]' vs 'int[1]')}}
> >> > > >> >>> typedef int n[C == 1 ? 1 : -1];
> >> > > >> >>> typedef int n[C >= 1 ? 1 : -1];
> >> > > >> >>> }
> >> > > >> >>> @@ -80,7 +80,7 @@ namespace PR11630 {
> >> > > >> >>> static void f()
> >> > > >> >>> {
> >> > > >> >>> typedef int q[1]; // expected-note{{previous
> definition is here}}
> >> > > >> >>> - typedef int q[T]; // expected-error{{typedef
> redefinition with
> >> > > >> >>> diff erent types ('int [2]' vs 'int [1]')}}
> >> > > >> >>> + typedef int q[T]; // expected-error{{typedef
> redefinition with
> >> > > >> >>> diff erent types ('int[2]' vs 'int[1]')}}
> >> > > >> >>> }
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/typeid.cpp
> b/clang/test/SemaCXX/typeid.cpp
> >> > > >> >>> index 4e696deee1317..26cad1c88f4d6 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/typeid.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/typeid.cpp
> >> > > >> >>> @@ -24,8 +24,8 @@ void g1(X &x) {
> >> > > >> >>>
> >> > > >> >>> void h(int i) {
> >> > > >> >>> char V[i];
> >> > > >> >>> - typeid(V); // expected-error{{'typeid' of variably
> modified type 'char [i]'}}
> >> > > >> >>> - typeid(char [i]); // expected-error{{'typeid' of variably
> modified type 'char [i]'}}
> >> > > >> >>> + typeid(V); // expected-error{{'typeid' of variably
> modified type 'char[i]'}}
> >> > > >> >>> + typeid(char [i]); // expected-error{{'typeid' of variably
> modified type 'char[i]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> // expected-note at +1 {{read of object 'typeid(int).name'
> whose value is not known}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaCXX/warn-string-conversion.cpp
> b/clang/test/SemaCXX/warn-string-conversion.cpp
> >> > > >> >>> index b26126f6c72f4..8a0042016532a 100644
> >> > > >> >>> --- a/clang/test/SemaCXX/warn-string-conversion.cpp
> >> > > >> >>> +++ b/clang/test/SemaCXX/warn-string-conversion.cpp
> >> > > >> >>> @@ -4,21 +4,21 @@
> >> > > >> >>> // An exception is made for this in logical and operators.
> >> > > >> >>> void assert(bool condition);
> >> > > >> >>> void test0() {
> >> > > >> >>> - bool b0 = "hi"; // expected-warning{{implicit conversion
> turns string literal into bool: 'const char [3]' to 'bool'}}
> >> > > >> >>> - b0 = ""; // expected-warning{{implicit conversion turns
> string literal into bool: 'const char [1]' to 'bool'}}
> >> > > >> >>> - b0 = 0 || ""; // expected-warning{{implicit conversion
> turns string literal into bool: 'const char [1]' to 'bool'}}
> >> > > >> >>> - b0 = "" || 0; // expected-warning{{implicit conversion
> turns string literal into bool: 'const char [1]' to 'bool'}}
> >> > > >> >>> + bool b0 = "hi"; // expected-warning{{implicit conversion
> turns string literal into bool: 'const char[3]' to 'bool'}}
> >> > > >> >>> + b0 = ""; // expected-warning{{implicit conversion turns
> string literal into bool: 'const char[1]' to 'bool'}}
> >> > > >> >>> + b0 = 0 || ""; // expected-warning{{implicit conversion
> turns string literal into bool: 'const char[1]' to 'bool'}}
> >> > > >> >>> + b0 = "" || 0; // expected-warning{{implicit conversion
> turns string literal into bool: 'const char[1]' to 'bool'}}
> >> > > >> >>> b0 = 0 && "";
> >> > > >> >>> b0 = "" && 0;
> >> > > >> >>> - assert("error"); // expected-warning{{implicit conversion
> turns string literal into bool: 'const char [6]' to 'bool'}}
> >> > > >> >>> - assert(0 || "error"); // expected-warning{{implicit
> conversion turns string literal into bool: 'const char [6]' to 'bool'}}
> >> > > >> >>> - assert("error" || 0); // expected-warning{{implicit
> conversion turns string literal into bool: 'const char [6]' to 'bool'}}
> >> > > >> >>> + assert("error"); // expected-warning{{implicit conversion
> turns string literal into bool: 'const char[6]' to 'bool'}}
> >> > > >> >>> + assert(0 || "error"); // expected-warning{{implicit
> conversion turns string literal into bool: 'const char[6]' to 'bool'}}
> >> > > >> >>> + assert("error" || 0); // expected-warning{{implicit
> conversion turns string literal into bool: 'const char[6]' to 'bool'}}
> >> > > >> >>> assert(0 && "error");
> >> > > >> >>> assert("error" && 0);
> >> > > >> >>>
> >> > > >> >>> - while("hi") {} // expected-warning{{implicit conversion
> turns string literal into bool: 'const char [3]' to 'bool'}}
> >> > > >> >>> - do {} while("hi"); // expected-warning{{implicit
> conversion turns string literal into bool: 'const char [3]' to 'bool'}}
> >> > > >> >>> - for (;"hi";); // expected-warning{{implicit conversion
> turns string literal into bool: 'const char [3]' to 'bool'}}
> >> > > >> >>> - if("hi") {} // expected-warning{{implicit conversion
> turns string literal into bool: 'const char [3]' to 'bool'}}
> >> > > >> >>> + while("hi") {} // expected-warning{{implicit conversion
> turns string literal into bool: 'const char[3]' to 'bool'}}
> >> > > >> >>> + do {} while("hi"); // expected-warning{{implicit
> conversion turns string literal into bool: 'const char[3]' to 'bool'}}
> >> > > >> >>> + for (;"hi";); // expected-warning{{implicit conversion
> turns string literal into bool: 'const char[3]' to 'bool'}}
> >> > > >> >>> + if("hi") {} // expected-warning{{implicit conversion
> turns string literal into bool: 'const char[3]' to 'bool'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaObjC/argument-checking.m
> b/clang/test/SemaObjC/argument-checking.m
> >> > > >> >>> index 9019a0fb24e4c..3639fcd51190f 100644
> >> > > >> >>> --- a/clang/test/SemaObjC/argument-checking.m
> >> > > >> >>> +++ b/clang/test/SemaObjC/argument-checking.m
> >> > > >> >>> @@ -18,7 +18,7 @@ void test() {
> >> > > >> >>> struct S sInst;
> >> > > >> >>>
> >> > > >> >>> charStarFunc(1); // expected-warning {{incompatible
> integer to pointer conversion passing 'int' to parameter of type 'char *'}}
> >> > > >> >>> - charFunc("abc"); // expected-warning {{incompatible
> pointer to integer conversion passing 'char [4]' to parameter of type
> 'char'}}
> >> > > >> >>> + charFunc("abc"); // expected-warning {{incompatible
> pointer to integer conversion passing 'char[4]' to parameter of type
> 'char'}}
> >> > > >> >>>
> >> > > >> >>> [obj charStarMeth:1]; // expected-warning {{incompatible
> integer to pointer conversion sending 'int'}}
> >> > > >> >>> [obj structMeth:1]; // expected-error {{sending 'int'}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaObjC/flexible-array.m
> b/clang/test/SemaObjC/flexible-array.m
> >> > > >> >>> index 68e32d851f628..ff3dc711e581e 100644
> >> > > >> >>> --- a/clang/test/SemaObjC/flexible-array.m
> >> > > >> >>> +++ b/clang/test/SemaObjC/flexible-array.m
> >> > > >> >>> @@ -8,7 +8,7 @@ @interface LastIvar {
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface NotLastIvar {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> int last; // expected-note {{next instance variable
> declaration is here}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>> @@ -17,28 +17,28 @@ @interface NotLastIvar {
> >> > > >> >>> @interface LastIvarInImpl
> >> > > >> >>> @end
> >> > > >> >>> @implementation LastIvarInImpl {
> >> > > >> >>> - char flexible[]; // expected-warning {{field 'flexible'
> with variable sized type 'char []' is not visible to subclasses and can
> conflict with their instance variables}}
> >> > > >> >>> + char flexible[]; // expected-warning {{field 'flexible'
> with variable sized type 'char[]' is not visible to subclasses and can
> conflict with their instance variables}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface NotLastIvarInImpl
> >> > > >> >>> @end
> >> > > >> >>> @implementation NotLastIvarInImpl {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> - // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char []' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> + // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char[]' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> int last; // expected-note {{next instance variable
> declaration is here}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @implementation NotLastIvarInImplWithoutInterface { //
> expected-warning {{cannot find interface declaration for
> 'NotLastIvarInImplWithoutInterface'}}
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> - // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char []' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> + // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char[]' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> int last; // expected-note {{next instance variable
> declaration is here}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface LastIvarInClass_OtherIvarInImpl {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>> @implementation LastIvarInClass_OtherIvarInImpl {
> >> > > >> >>> @@ -59,21 +59,21 @@ @implementation
> LastIvarInClass_UnrelatedVarInImpl
> >> > > >> >>> @interface LastIvarInExtension
> >> > > >> >>> @end
> >> > > >> >>> @interface LastIvarInExtension() {
> >> > > >> >>> - char flexible[]; // expected-warning {{field 'flexible'
> with variable sized type 'char []' is not visible to subclasses and can
> conflict with their instance variables}}
> >> > > >> >>> + char flexible[]; // expected-warning {{field 'flexible'
> with variable sized type 'char[]' is not visible to subclasses and can
> conflict with their instance variables}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface NotLastIvarInExtension
> >> > > >> >>> @end
> >> > > >> >>> @interface NotLastIvarInExtension() {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> - // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char []' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> + // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char[]' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> int last; // expected-note {{next instance variable
> declaration is here}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface LastIvarInClass_OtherIvarInExtension {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>> @interface LastIvarInClass_OtherIvarInExtension() {
> >> > > >> >>> @@ -91,16 +91,16 @@ @interface
> LastIvarInExtension_OtherIvarInExtension()
> >> > > >> >>> // Extension without ivars to test we see through such
> extensions.
> >> > > >> >>> @end
> >> > > >> >>> @interface LastIvarInExtension_OtherIvarInExtension() {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> - // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char []' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> + // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char[]' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface LastIvarInExtension_OtherIvarInImpl
> >> > > >> >>> @end
> >> > > >> >>> @interface LastIvarInExtension_OtherIvarInImpl() {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> - // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char []' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> + // expected-warning at -1 {{field 'flexible' with variable
> sized type 'char[]' is not visible to subclasses and can conflict with
> their instance variables}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>> @implementation LastIvarInExtension_OtherIvarInImpl {
> >> > > >> >>> @@ -120,7 +120,7 @@ @interface IvarInNamedCategory(Category)
> {
> >> > > >> >>> @interface LastIvarAndProperty {
> >> > > >> >>> char _flexible[];
> >> > > >> >>> }
> >> > > >> >>> - at property char flexible[]; // expected-error {{property
> cannot have array or function type 'char []'}}
> >> > > >> >>> + at property char flexible[]; // expected-error {{property
> cannot have array or function type 'char[]'}}
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> // ## Synthesize other instance variables.
> >> > > >> >>> @@ -145,7 +145,7 @@ @implementation
> LastIvar_ImplicitlyNamedPropertyBackingIvarPreceding
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface
> NotLastIvar_ExplicitlyNamedPropertyBackingIvarLast {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> }
> >> > > >> >>> @property int count;
> >> > > >> >>> @end
> >> > > >> >>> @@ -154,7 +154,7 @@ @implementation
> NotLastIvar_ExplicitlyNamedPropertyBackingIvarLast
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface
> NotLastIvar_ImplicitlyNamedPropertyBackingIvarLast {
> >> > > >> >>> - char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char []' is not at the end of class}}
> >> > > >> >>> + char flexible[]; // expected-error {{flexible array
> member 'flexible' with type 'char[]' is not at the end of class}}
> >> > > >> >>> }
> >> > > >> >>> @property int count; // expected-note {{next synthesized
> instance variable is here}}
> >> > > >> >>> @end
> >> > > >> >>> @@ -244,21 +244,21 @@ @implementation NoIvarAdditions
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface AddedIvarInInterface : FlexibleArrayMemberBase {
> >> > > >> >>> - int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char []'
> in superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> + int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char[]' in
> superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface AddedIvarInImplementation :
> FlexibleArrayMemberBase
> >> > > >> >>> @end
> >> > > >> >>> @implementation AddedIvarInImplementation {
> >> > > >> >>> - int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char []'
> in superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> + int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char[]' in
> superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface AddedIvarInExtension : FlexibleArrayMemberBase
> >> > > >> >>> @end
> >> > > >> >>> @interface AddedIvarInExtension() {
> >> > > >> >>> - int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char []'
> in superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> + int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char[]' in
> superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @@ -266,11 +266,11 @@ @interface SynthesizedIvar :
> FlexibleArrayMemberBase
> >> > > >> >>> @property int count;
> >> > > >> >>> @end
> >> > > >> >>> @implementation SynthesizedIvar
> >> > > >> >>> - at synthesize count; // expected-warning {{field 'count' can
> overwrite instance variable 'flexible' with variable sized type 'char []'
> in superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> + at synthesize count; // expected-warning {{field 'count' can
> overwrite instance variable 'flexible' with variable sized type 'char[]' in
> superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface WarnInSubclassOnlyOnce : FlexibleArrayMemberBase
> {
> >> > > >> >>> - int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char []'
> in superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> + int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char[]' in
> superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>> @interface WarnInSubclassOnlyOnce() {
> >> > > >> >>> @@ -283,6 +283,6 @@ @implementation WarnInSubclassOnlyOnce {
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface AddedIvarInSubSubClass : NoIvarAdditions {
> >> > > >> >>> - int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char []'
> in superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> + int last; // expected-warning {{field 'last' can
> overwrite instance variable 'flexible' with variable sized type 'char[]' in
> superclass 'FlexibleArrayMemberBase'}}
> >> > > >> >>> }
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaObjC/ivar-sem-check-1.m
> b/clang/test/SemaObjC/ivar-sem-check-1.m
> >> > > >> >>> index 48e0a54b628bd..9e28a380afbc6 100644
> >> > > >> >>> --- a/clang/test/SemaObjC/ivar-sem-check-1.m
> >> > > >> >>> +++ b/clang/test/SemaObjC/ivar-sem-check-1.m
> >> > > >> >>> @@ -6,7 +6,7 @@
> >> > > >> >>> @interface INTF
> >> > > >> >>> {
> >> > > >> >>> struct F {} JJ;
> >> > > >> >>> - int arr[]; // expected-error {{flexible array
> member 'arr' with type 'int []' is not at the end of class}}
> >> > > >> >>> + int arr[]; // expected-error {{flexible array
> member 'arr' with type 'int[]' is not at the end of class}}
> >> > > >> >>> struct S IC; // expected-error {{field has
> incomplete type}}
> >> > > >> >>> // expected-note at -1 {{next instance
> variable declaration is here}}
> >> > > >> >>> struct T { // expected-note {{previous definition is
> here}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaObjC/method-bad-param.m
> b/clang/test/SemaObjC/method-bad-param.m
> >> > > >> >>> index a7f0745ddbadf..f70f2cf853e51 100644
> >> > > >> >>> --- a/clang/test/SemaObjC/method-bad-param.m
> >> > > >> >>> +++ b/clang/test/SemaObjC/method-bad-param.m
> >> > > >> >>> @@ -49,7 +49,7 @@ - (void)crashMe:(enum bogus)p { //
> expected-error {{variable has incomplete type
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> @interface arrayfun
> >> > > >> >>> -- (int[6])arrayRet; // expected-error {{function cannot
> return array type 'int [6]'}}
> >> > > >> >>> +- (int[6])arrayRet; // expected-error {{function cannot
> return array type 'int[6]'}}
> >> > > >> >>> - (int())funcRet; // expected-error {{function cannot
> return function type 'int ()'}}
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaObjC/nullability.m
> b/clang/test/SemaObjC/nullability.m
> >> > > >> >>> index 93834942be799..3817289a79908 100644
> >> > > >> >>> --- a/clang/test/SemaObjC/nullability.m
> >> > > >> >>> +++ b/clang/test/SemaObjC/nullability.m
> >> > > >> >>> @@ -274,13 +274,13 @@ void conditional_expr(int c) {
> >> > > >> >>> @interface ArraysInMethods
> >> > > >> >>> - (void)simple:(int [_Nonnull 2])x;
> >> > > >> >>> - (void)nested:(void *_Nullable [_Nonnull 2])x;
> >> > > >> >>> -- (void)nestedBad:(int [2][_Nonnull 2])x; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'int [2]'}}
> >> > > >> >>> +- (void)nestedBad:(int [2][_Nonnull 2])x; // expected-error
> {{nullability specifier '_Nonnull' cannot be applied to non-pointer type
> 'int[2]'}}
> >> > > >> >>>
> >> > > >> >>> - (void)withTypedef:(INTS _Nonnull)x;
> >> > > >> >>> -- (void)withTypedefBad:(INTS _Nonnull[2])x; //
> expected-error{{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'INTS' (aka 'int [4]')}}
> >> > > >> >>> +- (void)withTypedefBad:(INTS _Nonnull[2])x; //
> expected-error{{nullability specifier '_Nonnull' cannot be applied to
> non-pointer type 'INTS' (aka 'int[4]')}}
> >> > > >> >>>
> >> > > >> >>> - (void)simpleSugar:(nonnull int [2])x;
> >> > > >> >>> -- (void)nestedSugar:(nonnull void *_Nullable [2])x; //
> expected-error {{nullability keyword 'nonnull' cannot be applied to
> multi-level pointer type 'void * _Nullable [2]'}} expected-note {{use
> nullability type specifier '_Nonnull' to affect the innermost pointer type
> of 'void * _Nullable [2]'}}
> >> > > >> >>> +- (void)nestedSugar:(nonnull void *_Nullable [2])x; //
> expected-error {{nullability keyword 'nonnull' cannot be applied to
> multi-level pointer type 'void * _Nullable[2]'}} expected-note {{use
> nullability type specifier '_Nonnull' to affect the innermost pointer type
> of 'void * _Nullable[2]'}}
> >> > > >> >>> - (void)sugarWithTypedef:(nonnull INTS)x;
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaObjC/rdr-6211479-array-property.m
> b/clang/test/SemaObjC/rdr-6211479-array-property.m
> >> > > >> >>> index 39c056c5ba617..f81bc6ca8cd83 100644
> >> > > >> >>> --- a/clang/test/SemaObjC/rdr-6211479-array-property.m
> >> > > >> >>> +++ b/clang/test/SemaObjC/rdr-6211479-array-property.m
> >> > > >> >>> @@ -4,5 +4,5 @@
> >> > > >> >>> typedef int T[2];
> >> > > >> >>>
> >> > > >> >>> @interface A
> >> > > >> >>> - at property(assign) T p2; // expected-error {{property cannot
> have array or function type 'T' (aka 'int [2]')}}
> >> > > >> >>> + at property(assign) T p2; // expected-error {{property cannot
> have array or function type 'T' (aka 'int[2]')}}
> >> > > >> >>> @end
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaObjC/warn-write-strings.m
> b/clang/test/SemaObjC/warn-write-strings.m
> >> > > >> >>> index 163c864257e9e..c9361f0818b7d 100644
> >> > > >> >>> --- a/clang/test/SemaObjC/warn-write-strings.m
> >> > > >> >>> +++ b/clang/test/SemaObjC/warn-write-strings.m
> >> > > >> >>> @@ -1,4 +1,4 @@
> >> > > >> >>> // RUN: %clang_cc1 -verify -fsyntax-only -fconst-strings %s
> >> > > >> >>>
> >> > > >> >>> // PR4804
> >> > > >> >>> -char* x = "foo"; // expected-warning {{initializing 'char
> *' with an expression of type 'const char [4]' discards qualifiers}}
> >> > > >> >>> +char* x = "foo"; // expected-warning {{initializing 'char
> *' with an expression of type 'const char[4]' discards qualifiers}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaObjCXX/message.mm
> b/clang/test/SemaObjCXX/message.mm
> >> > > >> >>> index aa364d5214737..87421f94677f3 100644
> >> > > >> >>> --- a/clang/test/SemaObjCXX/message.mm
> >> > > >> >>> +++ b/clang/test/SemaObjCXX/message.mm
> >> > > >> >>> @@ -103,7 +103,7 @@ @interface I5
> >> > > >> >>>
> >> > > >> >>> void test_I5(I5 *i5, String s) {
> >> > > >> >>> [i5 method:"hello" other:s];
> >> > > >> >>> - [i5 method:s other:"world"]; // expected-error{{non-const
> lvalue reference to type 'String' cannot bind to a value of unrelated type
> 'const char [6]'}}
> >> > > >> >>> + [i5 method:s other:"world"]; // expected-error{{non-const
> lvalue reference to type 'String' cannot bind to a value of unrelated type
> 'const char[6]'}}
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> // <rdar://problem/8483253>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaOpenCL/half.cl
> b/clang/test/SemaOpenCL/half.cl
> >> > > >> >>> index 50bbd745d2af3..e3e558995b21c 100644
> >> > > >> >>> --- a/clang/test/SemaOpenCL/half.cl
> >> > > >> >>> +++ b/clang/test/SemaOpenCL/half.cl
> >> > > >> >>> @@ -6,7 +6,7 @@ constant float f = 1.0h; //
> expected-error{{half precision constant requires cl_
> >> > > >> >>> half half_disabled(half *p, // expected-error{{declaring
> function return value of type 'half' is not allowed}}
> >> > > >> >>> half h) // expected-error{{declaring
> function parameter of type '__private half' is not allowed}}
> >> > > >> >>> {
> >> > > >> >>> - half a[2]; // expected-error{{declaring variable of type
> '__private half [2]' is not allowed}}
> >> > > >> >>> + half a[2]; // expected-error{{declaring variable of type
> '__private half[2]' is not allowed}}
> >> > > >> >>> half b; // expected-error{{declaring variable of type
> '__private half' is not allowed}}
> >> > > >> >>> *p; // expected-error{{loading directly from pointer to
> type '__private half' requires cl_khr_fp16. Use vector data load builtin
> functions instead}}
> >> > > >> >>> *p = 0; // expected-error{{assigning directly to pointer
> to type 'half' requires cl_khr_fp16. Use vector data store builtin
> functions instead}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaOpenCL/
> invalid-kernel-parameters.cl b/clang/test/SemaOpenCL/
> invalid-kernel-parameters.cl
> >> > > >> >>> index 96e6f7886b73e..de06b381605b4 100644
> >> > > >> >>> --- a/clang/test/SemaOpenCL/invalid-kernel-parameters.cl
> >> > > >> >>> +++ b/clang/test/SemaOpenCL/invalid-kernel-parameters.cl
> >> > > >> >>> @@ -207,6 +207,6 @@ kernel void array_of_ptr(struct
> ArrayOfPtr arr) {} // expected-error{{struct ker
> >> > > >> >>>
> >> > > >> >>> struct ArrayOfStruct // expected-note{{within field of type
> 'ArrayOfStruct' declared here}}
> >> > > >> >>> {
> >> > > >> >>> - struct ArrayOfPtr arr[3]; // expected-note{{within field
> of type 'struct ArrayOfPtr [3]' declared here}}
> >> > > >> >>> + struct ArrayOfPtr arr[3]; // expected-note{{within field
> of type 'struct ArrayOfPtr[3]' declared here}}
> >> > > >> >>> };
> >> > > >> >>> kernel void array_of_struct(struct ArrayOfStruct arr) {} //
> expected-error{{struct kernel parameters may not contain pointers}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaOpenCL/predefined-expr.cl
> b/clang/test/SemaOpenCL/predefined-expr.cl
> >> > > >> >>> index 182c9bda657fa..5b219d3009f08 100644
> >> > > >> >>> --- a/clang/test/SemaOpenCL/predefined-expr.cl
> >> > > >> >>> +++ b/clang/test/SemaOpenCL/predefined-expr.cl
> >> > > >> >>> @@ -3,6 +3,6 @@
> >> > > >> >>>
> >> > > >> >>> void f() {
> >> > > >> >>> char *f1 = __func__;
> //expected-error-re{{initializing '{{__generic|__private}} char *__private'
> with an expression of type 'const __constant char *' changes address space
> of pointer}}
> >> > > >> >>> - constant char *f2 = __func__;
> //expected-warning{{initializing '__constant char *__private' with an
> expression of type 'const __constant char [2]' discards qualifiers}}
> >> > > >> >>> + constant char *f2 = __func__;
> //expected-warning{{initializing '__constant char *__private' with an
> expression of type 'const __constant char[2]' discards qualifiers}}
> >> > > >> >>> constant const char *f3 = __func__;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaOpenCLCXX/address-space-deduction.clcpp
> b/clang/test/SemaOpenCLCXX/address-space-deduction.clcpp
> >> > > >> >>> index 1b757ca436871..15b3976930abf 100644
> >> > > >> >>> --- a/clang/test/SemaOpenCLCXX/address-space-deduction.clcpp
> >> > > >> >>> +++ b/clang/test/SemaOpenCLCXX/address-space-deduction.clcpp
> >> > > >> >>> @@ -51,7 +51,7 @@ struct x2 {
> >> > > >> >>> void foo(x1<T>* xx) {
> >> > > >> >>> m[0] = *xx;
> >> > > >> >>> }
> >> > > >> >>> -//CHECK: -FieldDecl {{.*}} m 'x1<int> [2]'
> >> > > >> >>> +//CHECK: -FieldDecl {{.*}} m 'x1<int>[2]'
> >> > > >> >>> x1<T> m[2];
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaTemplate/deduction-guide.cpp
> b/clang/test/SemaTemplate/deduction-guide.cpp
> >> > > >> >>> index 79418134d2fd0..3ec7e19220684 100644
> >> > > >> >>> --- a/clang/test/SemaTemplate/deduction-guide.cpp
> >> > > >> >>> +++ b/clang/test/SemaTemplate/deduction-guide.cpp
> >> > > >> >>> @@ -23,7 +23,7 @@ using AT = A<int[3], int, int, short>;
> >> > > >> >>> // CHECK: | |-ParmVarDecl {{.*}} 'X<Ps...>'
> >> > > >> >>> // CHECK: | `-ParmVarDecl {{.*}} 'Ts (*)[Ns]...' pack
> >> > > >> >>> // CHECK: `-CXXDeductionGuideDecl
> >> > > >> >>> -// CHECK: |-TemplateArgument type 'int [3]'
> >> > > >> >>> +// CHECK: |-TemplateArgument type 'int[3]'
> >> > > >> >>> // CHECK: |-TemplateArgument pack
> >> > > >> >>> // CHECK: | |-TemplateArgument type 'int'
> >> > > >> >>> // CHECK: | |-TemplateArgument type 'int'
> >> > > >> >>> @@ -34,9 +34,9 @@ using AT = A<int[3], int, int, short>;
> >> > > >> >>> // CHECK: | `-TemplateArgument integral 4
> >> > > >> >>> // CHECK: |-TemplateArgument pack
> >> > > >> >>> // CHECK: | |-TemplateArgument decl
> >> > > >> >>> -// CHECK: | | `-Var {{.*}} 'arr1' 'int [3]'
> >> > > >> >>> +// CHECK: | | `-Var {{.*}} 'arr1' 'int[3]'
> >> > > >> >>> // CHECK: | `-TemplateArgument decl
> >> > > >> >>> -// CHECK: | `-Var {{.*}} 'arr2' 'int [3]'
> >> > > >> >>> +// CHECK: | `-Var {{.*}} 'arr2' 'int[3]'
> >> > > >> >>> // CHECK: |-ParmVarDecl {{.*}} 'X<&arr1,
> &arr2>':'X<&arr1, &arr2>'
> >> > > >> >>> // CHECK: |-ParmVarDecl {{.*}} 'int (*)[3]'
> >> > > >> >>> // CHECK: |-ParmVarDecl {{.*}} 'int (*)[3]'
> >> > > >> >>> @@ -49,8 +49,8 @@ using AT = A<int[3], int, int, short>;
> >> > > >> >>> // CHECK: | `-DeclRefExpr {{.*}} 'T *'
> NonTypeTemplateParm {{.*}} 'Ps' 'T *'
> >> > > >> >>> // CHECK: `-PackExpansionType {{.*}} 'Ts (*)[Ns]...'
> dependent
> >> > > >> >>> // CHECK: `-PointerType {{.*}} 'Ts (*)[Ns]' dependent
> contains_unexpanded_pack
> >> > > >> >>> -// CHECK: `-ParenType {{.*}} 'Ts [Ns]' sugar dependent
> contains_unexpanded_pack
> >> > > >> >>> -// CHECK: `-DependentSizedArrayType {{.*}} 'Ts [Ns]'
> dependent contains_unexpanded_pack
> >> > > >> >>> +// CHECK: `-ParenType {{.*}} 'Ts[Ns]' sugar dependent
> contains_unexpanded_pack
> >> > > >> >>> +// CHECK: `-DependentSizedArrayType {{.*}} 'Ts[Ns]'
> dependent contains_unexpanded_pack
> >> > > >> >>> // CHECK: |-TemplateTypeParmType {{.*}} 'Ts'
> dependent contains_unexpanded_pack depth 0 index 1 pack
> >> > > >> >>> // CHECK: | `-TemplateTypeParm {{.*}} 'Ts'
> >> > > >> >>> // CHECK: `-DeclRefExpr {{.*}} 'Ts'
> NonTypeTemplateParm {{.*}} 'Ns' 'Ts...'
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaTemplate/instantiate-init.cpp
> b/clang/test/SemaTemplate/instantiate-init.cpp
> >> > > >> >>> index dee0f4422e91c..6db33a972f86d 100644
> >> > > >> >>> --- a/clang/test/SemaTemplate/instantiate-init.cpp
> >> > > >> >>> +++ b/clang/test/SemaTemplate/instantiate-init.cpp
> >> > > >> >>> @@ -86,7 +86,7 @@ namespace PR7985 {
> >> > > >> >>> template<int N> struct integral_c { };
> >> > > >> >>>
> >> > > >> >>> template <typename T, int N>
> >> > > >> >>> - integral_c<N> array_lengthof(T (&x)[N]) { return
> integral_c<N>(); } // expected-note 2{{candidate template ignored: could
> not match 'T [N]' against 'const Data<}}
> >> > > >> >>> + integral_c<N> array_lengthof(T (&x)[N]) { return
> integral_c<N>(); } // expected-note 2{{candidate template ignored: could
> not match 'T[N]' against 'const Data<}}
> >> > > >> >>>
> >> > > >> >>> template<typename T>
> >> > > >> >>> struct Data {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaTemplate/instantiate-local-class.cpp
> b/clang/test/SemaTemplate/instantiate-local-class.cpp
> >> > > >> >>> index ce986d98600e8..e51c7116ee74d 100644
> >> > > >> >>> --- a/clang/test/SemaTemplate/instantiate-local-class.cpp
> >> > > >> >>> +++ b/clang/test/SemaTemplate/instantiate-local-class.cpp
> >> > > >> >>> @@ -460,7 +460,7 @@ namespace rdar23721638 {
> >> > > >> >>>
> >> > > >> >>> template <typename T> void foo() {
> >> > > >> >>> struct Inner { // expected-note {{in instantiation}}
> >> > > >> >>> - void operator()(T a = "") {} // expected-error
> {{conversion function from 'const char [1]' to 'rdar23721638::A' invokes a
> deleted function}}
> >> > > >> >>> + void operator()(T a = "") {} // expected-error
> {{conversion function from 'const char[1]' to 'rdar23721638::A' invokes a
> deleted function}}
> >> > > >> >>> // expected-note at -1 {{passing argument to parameter
> 'a' here}}
> >> > > >> >>> };
> >> > > >> >>> Inner()(); // expected-error {{type 'Inner' does not
> provide a call operator}}
> >> > > >> >>> @@ -468,7 +468,7 @@ namespace rdar23721638 {
> >> > > >> >>> template void foo<A>(); // expected-note 2 {{in
> instantiation}}
> >> > > >> >>>
> >> > > >> >>> template <typename T> void bar() {
> >> > > >> >>> - auto lambda = [](T a = "") {}; // expected-error
> {{conversion function from 'const char [1]' to 'rdar23721638::A' invokes a
> deleted function}}
> >> > > >> >>> + auto lambda = [](T a = "") {}; // expected-error
> {{conversion function from 'const char[1]' to 'rdar23721638::A' invokes a
> deleted function}}
> >> > > >> >>> // expected-note at -1 {{passing argument to parameter
> 'a' here}}
> >> > > >> >>> lambda();
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/test/SemaTemplate/instantiate-static-var.cpp
> b/clang/test/SemaTemplate/instantiate-static-var.cpp
> >> > > >> >>> index 7a6de7896cba0..63d8366b617c1 100644
> >> > > >> >>> --- a/clang/test/SemaTemplate/instantiate-static-var.cpp
> >> > > >> >>> +++ b/clang/test/SemaTemplate/instantiate-static-var.cpp
> >> > > >> >>> @@ -154,8 +154,8 @@ namespace ArrayBound {
> >> > > >> >>> static const char kMessage[];
> >> > > >> >>> // Here, kMessage is type-dependent, so we don't
> diagnose until
> >> > > >> >>> // instantiation.
> >> > > >> >>> - static void g1() { const char (&ref)[4] = kMessage; }
> // expected-error {{could not bind to an lvalue of type 'const char [5]'}}
> >> > > >> >>> - static void g2() { const char (&ref)[5] = kMessage; }
> // expected-error {{could not bind to an lvalue of type 'const char [4]'}}
> >> > > >> >>> + static void g1() { const char (&ref)[4] = kMessage; }
> // expected-error {{could not bind to an lvalue of type 'const char[5]'}}
> >> > > >> >>> + static void g2() { const char (&ref)[5] = kMessage; }
> // expected-error {{could not bind to an lvalue of type 'const char[4]'}}
> >> > > >> >>> };
> >> > > >> >>> template<typename T> const char Bar<T>::kMessage[] =
> "foo";
> >> > > >> >>> template void Bar<int>::g1();
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaTemplate/pack-deduction.cpp
> b/clang/test/SemaTemplate/pack-deduction.cpp
> >> > > >> >>> index 6368f16ebe8ba..e42709820e9cf 100644
> >> > > >> >>> --- a/clang/test/SemaTemplate/pack-deduction.cpp
> >> > > >> >>> +++ b/clang/test/SemaTemplate/pack-deduction.cpp
> >> > > >> >>> @@ -141,7 +141,7 @@ namespace partial_full_mix {
> >> > > >> >>> // expected-note at -1 {{[with U = <char, double, long>]:
> pack expansion contains parameter pack 'U' that has a
> >> > > >> >>> diff erent length (2 vs. 3) from outer parameter packs}}
> >> > > >> >>>
> >> > > >> >>> template<typename ...U> static tuple<U...>
> h(tuple<pair<T, U>..., pair<int, int>>);
> >> > > >> >>> - // expected-note at -1 {{[with U = <int [2]>]: pack
> expansion contains parameter pack 'U' that has a
> >> > > >> >>> diff erent length (2 vs. 1) from outer parameter packs}}
> >> > > >> >>> + // expected-note at -1 {{[with U = <int[2]>]: pack
> expansion contains parameter pack 'U' that has a
> >> > > >> >>> diff erent length (2 vs. 1) from outer parameter packs}}
> >> > > >> >>> };
> >> > > >> >>>
> >> > > >> >>> pair<tuple<int, float>, tuple<char, double>> k1 = A<int,
> float>().f<char>(pair<int, char>(), pair<float, double>());
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/test/SemaTemplate/temp_arg_nontype.cpp
> b/clang/test/SemaTemplate/temp_arg_nontype.cpp
> >> > > >> >>> index a735e92a6c981..4ad15ae20d850 100644
> >> > > >> >>> --- a/clang/test/SemaTemplate/temp_arg_nontype.cpp
> >> > > >> >>> +++ b/clang/test/SemaTemplate/temp_arg_nontype.cpp
> >> > > >> >>> @@ -174,7 +174,7 @@ namespace pr6249 {
> >> > > >> >>>
> >> > > >> >>> namespace PR6723 {
> >> > > >> >>> template<unsigned char C> void f(int (&a)[C]); //
> expected-note 3{{candidate template ignored: substitution failure [with C =
> '\x00']}}
> >> > > >> >>> - // expected-note at -1 {{not viable: no known conversion
> from 'int [512]' to 'int (&)[0]'}}
> >> > > >> >>> + // expected-note at -1 {{not viable: no known conversion
> from 'int[512]' to 'int (&)[0]'}}
> >> > > >> >>> void g() {
> >> > > >> >>> int arr512[512];
> >> > > >> >>> f(arr512); // expected-error{{no matching function for
> call}}
> >> > > >> >>>
> >> > > >> >>> diff --git a/clang/unittests/AST/ASTImporterTest.cpp
> b/clang/unittests/AST/ASTImporterTest.cpp
> >> > > >> >>> index 3036b1c59d504..724de6c67f0f6 100644
> >> > > >> >>> --- a/clang/unittests/AST/ASTImporterTest.cpp
> >> > > >> >>> +++ b/clang/unittests/AST/ASTImporterTest.cpp
> >> > > >> >>> @@ -269,15 +269,15 @@ TEST_P(ImportExpr,
> ImportStringLiteral) {
> >> > > >> >>> testImport("void declToImport() { (void)\"foo\"; }",
> Lang_CXX03, "",
> >> > > >> >>> Lang_CXX03, Verifier,
> >> > > >> >>> functionDecl(hasDescendant(
> >> > > >> >>> - stringLiteral(hasType(asString("const char
> [4]"))))));
> >> > > >> >>> + stringLiteral(hasType(asString("const
> char[4]"))))));
> >> > > >> >>> testImport("void declToImport() { (void)L\"foo\"; }",
> Lang_CXX03, "",
> >> > > >> >>> Lang_CXX03, Verifier,
> >> > > >> >>> functionDecl(hasDescendant(
> >> > > >> >>> - stringLiteral(hasType(asString("const
> wchar_t [4]"))))));
> >> > > >> >>> + stringLiteral(hasType(asString("const
> wchar_t[4]"))))));
> >> > > >> >>> testImport("void declToImport() { (void) \"foo\" \"bar\";
> }", Lang_CXX03, "",
> >> > > >> >>> Lang_CXX03, Verifier,
> >> > > >> >>> functionDecl(hasDescendant(
> >> > > >> >>> - stringLiteral(hasType(asString("const char
> [7]"))))));
> >> > > >> >>> + stringLiteral(hasType(asString("const
> char[7]"))))));
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> TEST_P(ImportExpr, ImportChooseExpr) {
> >> > > >> >>> @@ -508,8 +508,8 @@ TEST_P(ImportExpr, ImportPredefinedExpr)
> {
> >> > > >> >>> testImport("void declToImport() { (void)__func__; }",
> Lang_CXX03, "",
> >> > > >> >>> Lang_CXX03, Verifier,
> >> > > >> >>> functionDecl(hasDescendant(predefinedExpr(
> >> > > >> >>> - hasType(asString("const char [13]")),
> >> > > >> >>> - has(stringLiteral(hasType(asString("const
> char [13]"))))))));
> >> > > >> >>> + hasType(asString("const char[13]")),
> >> > > >> >>> + has(stringLiteral(hasType(asString("const
> char[13]"))))))));
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> TEST_P(ImportExpr, ImportInitListExpr) {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> >> > > >> >>> index 92fd5306deb16..022f6ef8e5772 100644
> >> > > >> >>> --- a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> >> > > >> >>> +++ b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> >> > > >> >>> @@ -1049,7 +1049,7 @@ TEST_P(ASTMatchersTest, StmtExpr) {
> >> > > >> >>> TEST_P(ASTMatchersTest, PredefinedExpr) {
> >> > > >> >>> // __func__ expands as StringLiteral("foo")
> >> > > >> >>> EXPECT_TRUE(matches("void foo() { __func__; }",
> >> > > >> >>> -
> predefinedExpr(hasType(asString("const char [4]")),
> >> > > >> >>> +
> predefinedExpr(hasType(asString("const char[4]")),
> >> > > >> >>>
> has(stringLiteral()))));
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> @@ -1367,7 +1367,7 @@ TEST_P(ASTMatchersTest,
> ExprWithCleanups_MatchesExprWithCleanups) {
> >> > > >> >>>
> >> > > >> >>> TEST_P(ASTMatchersTest, InitListExpr) {
> >> > > >> >>> EXPECT_TRUE(matches("int a[] = { 1, 2 };",
> >> > > >> >>> - initListExpr(hasType(asString("int
> [2]")))));
> >> > > >> >>> +
> initListExpr(hasType(asString("int[2]")))));
> >> > > >> >>> EXPECT_TRUE(matches("struct B { int x, y; }; struct B b =
> { 5, 6 };",
> >> > > >> >>>
> initListExpr(hasType(recordDecl(hasName("B"))))));
> >> > > >> >>> EXPECT_TRUE(
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
> b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
> >> > > >> >>> index 7746c82f7ec52..f39d5ecbb095e 100644
> >> > > >> >>> ---
> a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
> >> > > >> >>> +++
> b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
> >> > > >> >>> @@ -430,8 +430,8 @@ TEST(HasTypeLoc,
> MatchesClassTemplateSpecializationDecl) {
> >> > > >> >>>
> >> > > >> >>> TEST(HasTypeLoc, MatchesCompoundLiteralExpr) {
> >> > > >> >>> EXPECT_TRUE(
> >> > > >> >>> - matches("int* x = (int [2]) { 0, 1 };",
> >> > > >> >>> -
> compoundLiteralExpr(hasTypeLoc(loc(asString("int [2]"))))));
> >> > > >> >>> + matches("int* x = (int[2]) { 0, 1 };",
> >> > > >> >>> +
> compoundLiteralExpr(hasTypeLoc(loc(asString("int[2]"))))));
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> TEST(HasTypeLoc, MatchesDeclaratorDecl) {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp
> b/compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp
> >> > > >> >>> index 9f890f290b349..03b2a9341f4da 100644
> >> > > >> >>> --- a/compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp
> >> > > >> >>> +++ b/compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp
> >> > > >> >>> @@ -25,7 +25,7 @@ int main(int argc, char **argv) {
> >> > > >> >>> int arr[2][3][4] = {};
> >> > > >> >>>
> >> > > >> >>> return arr[argv[1][0] - '0'][argv[2][0] - '0'][argv[3][0]
> - '0'];
> >> > > >> >>> - // CHECK-A-2: bounds.cpp:[[@LINE-1]]:10: runtime error:
> index 2 out of bounds for type 'int [2][3][4]'
> >> > > >> >>> - // CHECK-B-3: bounds.cpp:[[@LINE-2]]:10: runtime error:
> index 3 out of bounds for type 'int [3][4]'
> >> > > >> >>> - // CHECK-C-4: bounds.cpp:[[@LINE-3]]:10: runtime error:
> index 4 out of bounds for type 'int [4]'
> >> > > >> >>> + // CHECK-A-2: bounds.cpp:[[@LINE-1]]:10: runtime error:
> index 2 out of bounds for type 'int[2][3][4]'
> >> > > >> >>> + // CHECK-B-3: bounds.cpp:[[@LINE-2]]:10: runtime error:
> index 3 out of bounds for type 'int[3][4]'
> >> > > >> >>> + // CHECK-C-4: bounds.cpp:[[@LINE-3]]:10: runtime error:
> index 4 out of bounds for type 'int[4]'
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
> b/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
> >> > > >> >>> index ec98c3931a336..7f32f50d55ea2 100644
> >> > > >> >>> ---
> a/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
> >> > > >> >>> +++
> b/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
> >> > > >> >>> @@ -51,7 +51,7 @@ void test() {
> >> > > >> >>>
> LIBCPP_STATIC_ASSERT(!std::__default_initializable<const int>);
> >> > > >> >>> static_assert(!std::default_initializable<const int>);
> >> > > >> >>>
> >> > > >> >>> - const int x3[1]; // expected-error {{default
> initialization of an object of const type 'const int [1]'}}
> >> > > >> >>> + const int x3[1]; // expected-error {{default
> initialization of an object of const type 'const int[1]'}}
> >> > > >> >>> const int y3[1]{};
> >> > > >> >>> static_assert(std::constructible_from<const int[1]>);
> >> > > >> >>> static_assert(brace_initializable<const int[1]>);
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
> b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
> >> > > >> >>> index 8a5566b915c0f..c32a3ca15f4e8 100644
> >> > > >> >>> ---
> a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
> >> > > >> >>> +++
> b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
> >> > > >> >>> @@ -18,8 +18,8 @@
> >> > > >> >>> int main(int, char**) {
> >> > > >> >>> std::unique_ptr<int[]> p(new int(3));
> >> > > >> >>> const std::unique_ptr<int[]>& cp = p;
> >> > > >> >>> - TEST_IGNORE_NODISCARD (*p); // expected-error
> {{indirection requires pointer operand ('std::unique_ptr<int []>' invalid)}}
> >> > > >> >>> - TEST_IGNORE_NODISCARD (*cp); // expected-error
> {{indirection requires pointer operand ('const std::unique_ptr<int []>'
> invalid)}}
> >> > > >> >>> + TEST_IGNORE_NODISCARD (*p); // expected-error
> {{indirection requires pointer operand ('std::unique_ptr<int[]>' invalid)}}
> >> > > >> >>> + TEST_IGNORE_NODISCARD (*cp); // expected-error
> {{indirection requires pointer operand ('const std::unique_ptr<int[]>'
> invalid)}}
> >> > > >> >>>
> >> > > >> >>> return 0;
> >> > > >> >>> }
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
> b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
> >> > > >> >>> index 4fa94f137ce8e..c79fca62fd385 100644
> >> > > >> >>> ---
> a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
> >> > > >> >>> +++
> b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
> >> > > >> >>> @@ -23,10 +23,10 @@ int main(int, char**) {
> >> > > >> >>> std::unique_ptr<V[]> p;
> >> > > >> >>> std::unique_ptr<V[]> const& cp = p;
> >> > > >> >>>
> >> > > >> >>> - p->member; // expected-error {{member reference type
> 'std::unique_ptr<V []>' is not a pointer}}
> >> > > >> >>> + p->member; // expected-error {{member reference type
> 'std::unique_ptr<V[]>' is not a pointer}}
> >> > > >> >>> // expected-error at -1 {{no member named 'member'}}
> >> > > >> >>>
> >> > > >> >>> - cp->member; // expected-error {{member reference type
> 'const std::unique_ptr<V []>' is not a pointer}}
> >> > > >> >>> + cp->member; // expected-error {{member reference type
> 'const std::unique_ptr<V[]>' is not a pointer}}
> >> > > >> >>> // expected-error at -1 {{no member named
> 'member'}}
> >> > > >> >>>
> >> > > >> >>> return 0;
> >> > > >> >>>
> >> > > >> >>> diff --git a/lldb/source/Commands/CommandObjectType.cpp
> b/lldb/source/Commands/CommandObjectType.cpp
> >> > > >> >>> index 3bff844786f4e..0562b6be3cb5e 100644
> >> > > >> >>> --- a/lldb/source/Commands/CommandObjectType.cpp
> >> > > >> >>> +++ b/lldb/source/Commands/CommandObjectType.cpp
> >> > > >> >>> @@ -1598,7 +1598,7 @@ static bool
> FixArrayTypeNameWithRegex(ConstString &type_name) {
> >> > > >> >>> std::string type_name_str(type_name.GetCString());
> >> > > >> >>> type_name_str.resize(type_name_str.length() - 2);
> >> > > >> >>> if (type_name_str.back() != ' ')
> >> > > >> >>> - type_name_str.append(" \\[[0-9]+\\]");
> >> > > >> >>> + type_name_str.append(" ?\\[[0-9]+\\]");
> >> > > >> >>> else
> >> > > >> >>> type_name_str.append("\\[[0-9]+\\]");
> >> > > >> >>> type_name.SetCString(type_name_str.c_str());
> >> > > >> >>>
> >> > > >> >>> diff --git a/lldb/source/DataFormatters/FormatManager.cpp
> b/lldb/source/DataFormatters/FormatManager.cpp
> >> > > >> >>> index 2237fdd58a762..92171b67fe965 100644
> >> > > >> >>> --- a/lldb/source/DataFormatters/FormatManager.cpp
> >> > > >> >>> +++ b/lldb/source/DataFormatters/FormatManager.cpp
> >> > > >> >>> @@ -724,7 +724,7 @@ void
> FormatManager::LoadSystemFormatters() {
> >> > > >> >>> lldb::TypeSummaryImplSP string_array_format(
> >> > > >> >>> new StringSummaryFormat(string_array_flags,
> "${var%char[]}"));
> >> > > >> >>>
> >> > > >> >>> - RegularExpression any_size_char_arr(llvm::StringRef("char
> \\[[0-9]+\\]"));
> >> > > >> >>> + RegularExpression any_size_char_arr(llvm::StringRef("char
> ?\\[[0-9]+\\]"));
> >> > > >> >>>
> >> > > >> >>> TypeCategoryImpl::SharedPointer sys_category_sp =
> >> > > >> >>> GetCategory(m_system_category_name);
> >> > > >> >>> @@ -774,6 +774,8 @@ void
> FormatManager::LoadVectorFormatters() {
> >> > > >> >>> AddStringSummary(vectors_category_sp, "${var.uint128}",
> >> > > >> >>> ConstString("builtin_type_vec128"),
> vector_flags);
> >> > > >> >>>
> >> > > >> >>> + // FIXME: These probably need the space removed, or made
> optional - but are
> >> > > >> >>> + // they even tested?
> >> > > >> >>> AddStringSummary(vectors_category_sp, "",
> ConstString("float [4]"),
> >> > > >> >>> vector_flags);
> >> > > >> >>> AddStringSummary(vectors_category_sp, "",
> ConstString("int32_t [4]"),
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
> b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
> >> > > >> >>> index 2fabbff61c66b..4ef35eefaf32f 100644
> >> > > >> >>> ---
> a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
> >> > > >> >>> +++
> b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
> >> > > >> >>> @@ -1006,7 +1006,7 @@ static void
> LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
> >> > > >> >>> AddCXXSummary(cpp_category_sp,
> >> > > >> >>>
> lldb_private::formatters::Char8StringSummaryProvider,
> >> > > >> >>> "char8_t [] summary provider",
> >> > > >> >>> - ConstString("char8_t \\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>> + ConstString("char8_t ?\\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>>
> >> > > >> >>> AddCXXSummary(
> >> > > >> >>> cpp_category_sp,
> lldb_private::formatters::Char16StringSummaryProvider,
> >> > > >> >>> @@ -1014,7 +1014,7 @@ static void
> LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
> >> > > >> >>> AddCXXSummary(cpp_category_sp,
> >> > > >> >>>
> lldb_private::formatters::Char16StringSummaryProvider,
> >> > > >> >>> "char16_t [] summary provider",
> >> > > >> >>> - ConstString("char16_t \\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>> + ConstString("char16_t ?\\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>>
> >> > > >> >>> AddCXXSummary(
> >> > > >> >>> cpp_category_sp,
> lldb_private::formatters::Char32StringSummaryProvider,
> >> > > >> >>> @@ -1022,7 +1022,7 @@ static void
> LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
> >> > > >> >>> AddCXXSummary(cpp_category_sp,
> >> > > >> >>>
> lldb_private::formatters::Char32StringSummaryProvider,
> >> > > >> >>> "char32_t [] summary provider",
> >> > > >> >>> - ConstString("char32_t \\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>> + ConstString("char32_t ?\\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>>
> >> > > >> >>> AddCXXSummary(
> >> > > >> >>> cpp_category_sp,
> lldb_private::formatters::WCharStringSummaryProvider,
> >> > > >> >>> @@ -1030,7 +1030,7 @@ static void
> LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
> >> > > >> >>> AddCXXSummary(cpp_category_sp,
> >> > > >> >>>
> lldb_private::formatters::WCharStringSummaryProvider,
> >> > > >> >>> "wchar_t * summary provider",
> >> > > >> >>> - ConstString("wchar_t \\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>> + ConstString("wchar_t ?\\[[0-9]+\\]"),
> string_array_flags, true);
> >> > > >> >>>
> >> > > >> >>> AddCXXSummary(
> >> > > >> >>> cpp_category_sp,
> lldb_private::formatters::Char16StringSummaryProvider,
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py
> b/lldb/test/API/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py
> >> > > >> >>> index 42b31a10fb2c3..3906e48368054 100644
> >> > > >> >>> ---
> a/lldb/test/API/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py
> >> > > >> >>> +++
> b/lldb/test/API/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py
> >> > > >> >>> @@ -65,7 +65,7 @@ def cleanup():
> >> > > >> >>> self.runCmd("type summary clear")
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"${var[]}\"
> -x \"int \\[[0-9]\\]")
> >> > > >> >>> + "type summary add --summary-string \"${var[]}\"
> -x \"int\\[[0-9]\\]")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable int_array",
> >> > > >> >>> substrs=['1,2,3,4,5'])
> >> > > >> >>> @@ -124,27 +124,27 @@ def cleanup():
> >> > > >> >>> self.runCmd("type summary clear")
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - 'type summary add --summary-string
> \"${var[0-1]}\" -x \"int \[[0-9]\]\"')
> >> > > >> >>> + 'type summary add --summary-string
> \"${var[0-1]}\" -x \"int\[[0-9]\]\"')
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable int_array",
> >> > > >> >>> substrs=['1,2'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - 'type summary add --summary-string
> \"${var[0-1]}\" "int []"')
> >> > > >> >>> + 'type summary add --summary-string
> \"${var[0-1]}\" "int[]"')
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable int_array",
> >> > > >> >>> substrs=['1,2'])
> >> > > >> >>>
> >> > > >> >>> # Test the patterns are matched in
> reverse-chronological order.
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - 'type summary add --summary-string
> \"${var[2-3]}\" "int []"')
> >> > > >> >>> + 'type summary add --summary-string
> \"${var[2-3]}\" "int[]"')
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable int_array",
> >> > > >> >>> substrs=['3,4'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd("type summary clear")
> >> > > >> >>>
> >> > > >> >>> - self.runCmd("type summary add -c -x \"i_am_cool
> \[[0-9]\]\"")
> >> > > >> >>> + self.runCmd("type summary add -c -x
> \"i_am_cool\[[0-9]\]\"")
> >> > > >> >>> self.runCmd("type summary add -c i_am_cool")
> >> > > >> >>>
> >> > > >> >>> self.expect(
> >> > > >> >>> @@ -199,7 +199,7 @@ def cleanup():
> >> > > >> >>> self.runCmd("type summary clear")
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string
> \"${*var[].x[0-3]%hex} is a bitfield on a set of integers\" -x
> \"SimpleWithPointers \[[0-9]\]\"")
> >> > > >> >>> + "type summary add --summary-string
> \"${*var[].x[0-3]%hex} is a bitfield on a set of integers\" -x
> \"SimpleWithPointers\[[0-9]\]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable couple --summary-string
> \"${*var.sp.x[0-2]} are low bits of integer ${*var.sp.x}. If I pretend it
> is an array I get ${var.sp.x[0-5]}\"",
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
> b/lldb/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
> >> > > >> >>> index 7a82991a1c8b5..9d5c6ee262fee 100644
> >> > > >> >>> ---
> a/lldb/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
> >> > > >> >>> +++
> b/lldb/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
> >> > > >> >>> @@ -85,7 +85,7 @@ def cleanup():
> >> > > >> >>> substrs=['no custom formatter for
> Speed'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%s}\" -x \"char \\[[0-9]+\\]\" -v")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%s}\" -x \"char\\[[0-9]+\\]\" -v")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable strarr",
> >> > > >> >>> substrs=['arr = "Hello world!"'])
> >> > > >> >>> @@ -99,7 +99,7 @@ def cleanup():
> >> > > >> >>> substrs=['ptr = "Hello world!"'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%s}\" -x \"char \\[[0-9]+\\]\" -v")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%s}\" -x \"char\\[[0-9]+\\]\" -v")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable strarr",
> >> > > >> >>> substrs=['arr = "Hello world!'])
> >> > > >> >>> @@ -176,7 +176,7 @@ def cleanup():
> >> > > >> >>> matching=False)
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string
> \"${var[1-3]}\" \"int [5]\"")
> >> > > >> >>> + "type summary add --summary-string
> \"${var[1-3]}\" \"int[5]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable int_array",
> >> > > >> >>> substrs=['2',
> >> > > >> >>> @@ -188,7 +188,7 @@ def cleanup():
> >> > > >> >>> self.runCmd(
> >> > > >> >>> "type summary add --summary-string
> \"${var[0-2].integer}\" \"i_am_cool *\"")
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string
> \"${var[2-4].integer}\" \"i_am_cool [5]\"")
> >> > > >> >>> + "type summary add --summary-string
> \"${var[2-4].integer}\" \"i_am_cool[5]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable cool_array",
> >> > > >> >>> substrs=['1,1,6'])
> >> > > >> >>> @@ -199,7 +199,7 @@ def cleanup():
> >> > > >> >>> # test special symbols for formatting variables
> into summaries
> >> > > >> >>> self.runCmd(
> >> > > >> >>> "type summary add --summary-string \"cool
> object @ ${var%L}\" i_am_cool")
> >> > > >> >>> - self.runCmd("type summary delete \"i_am_cool [5]\"")
> >> > > >> >>> + self.runCmd("type summary delete \"i_am_cool[5]\"")
> >> > > >> >>>
> >> > > >> >>> # this test might fail if the compiler tries to
> store
> >> > > >> >>> # these values into registers.. hopefully this is
> not
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py
> b/lldb/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py
> >> > > >> >>> index b3c794f3f0c60..84fcc427106c8 100644
> >> > > >> >>> ---
> a/lldb/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py
> >> > > >> >>> +++
> b/lldb/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py
> >> > > >> >>> @@ -48,7 +48,7 @@ def cleanup():
> >> > > >> >>> self.addTearDownHook(cleanup)
> >> > > >> >>>
> >> > > >> >>> self.expect('p *(int (*)[3])foo',
> >> > > >> >>> - substrs=['(int [3]) $', '[0] = 1', '[1]
> = 2', '[2] = 3'])
> >> > > >> >>> + substrs=['(int[3]) $', '[0] = 1', '[1]
> = 2', '[2] = 3'])
> >> > > >> >>>
> >> > > >> >>> self.expect('p *(int (*)[3])foo', matching=False,
> >> > > >> >>> substrs=['01 00 00 00 02 00 00 00 03 00
> 00 00'])
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
> b/lldb/test/API/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
> >> > > >> >>> index 0f98eb34825cb..13953e40a377b 100644
> >> > > >> >>> ---
> a/lldb/test/API/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
> >> > > >> >>> +++
> b/lldb/test/API/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
> >> > > >> >>> @@ -68,7 +68,7 @@ def cleanup():
> >> > > >> >>> 'Nested Hello world!'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%s}\" -x \"char \\[[0-9]+\\]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%s}\" -x \"char\\[[0-9]+\\]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable strarr",
> >> > > >> >>> substrs=['arr = \"',
> >> > > >> >>> @@ -107,7 +107,7 @@ def cleanup():
> >> > > >> >>> 'Nested Hello world!'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%c}\" -x \"char \\[[0-9]+\\]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%c}\" -x \"char\\[[0-9]+\\]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable strarr",
> >> > > >> >>> substrs=['arr = \"',
> >> > > >> >>> @@ -127,7 +127,7 @@ def cleanup():
> >> > > >> >>>
> >> > > >> >>> # ${var%char[]}
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%char[]}\" -x \"char \\[[0-9]+\\]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%char[]}\" -x \"char\\[[0-9]+\\]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable strarr",
> >> > > >> >>> substrs=['arr = \"',
> >> > > >> >>> @@ -166,7 +166,7 @@ def cleanup():
> >> > > >> >>>
> >> > > >> >>> # ${var%a}
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%a}\" -x \"char \\[[0-9]+\\]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%a}\" -x \"char\\[[0-9]+\\]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable strarr",
> >> > > >> >>> substrs=['arr = \"',
> >> > > >> >>> @@ -255,7 +255,7 @@ def cleanup():
> >> > > >> >>>
> '0x00000009,0x00000008,0x00000007,0x00000006,0x00000005'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var[]%x}\" \"int [5]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var[]%x}\" \"int[5]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable intarr",
> >> > > >> >>> @@ -271,7 +271,7 @@ def cleanup():
> >> > > >> >>>
> >> > > >> >>> # printing each array item as an array
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var[]%uint32_t[]}\" \"int [5]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var[]%uint32_t[]}\" \"int[5]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable intarr",
> >> > > >> >>> @@ -287,7 +287,7 @@ def cleanup():
> >> > > >> >>>
> >> > > >> >>> # printing full array as an array
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%uint32_t[]}\" \"int [5]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%uint32_t[]}\" \"int[5]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable intarr",
> >> > > >> >>> @@ -303,7 +303,7 @@ def cleanup():
> >> > > >> >>>
> >> > > >> >>> # printing each array item as an array
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var[]%float32[]}\" \"float [7]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var[]%float32[]}\" \"float[7]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable flarr",
> >> > > >> >>> @@ -319,7 +319,7 @@ def cleanup():
> >> > > >> >>>
> >> > > >> >>> # printing full array as an array
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%float32[]}\" \"float [7]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%float32[]}\" \"float[7]\"")
> >> > > >> >>>
> >> > > >> >>> self.expect("frame variable flarr",
> >> > > >> >>> substrs=['flarr = arr =',
> >> > > >> >>> @@ -343,9 +343,9 @@ def cleanup():
> >> > > >> >>>
> >> > > >> >>> # use y and Y
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%y}\" \"float [7]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%y}\" \"float[7]\"")
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%y}\" \"int [5]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%y}\" \"int[5]\"")
> >> > > >> >>>
> >> > > >> >>> if process.GetByteOrder() == lldb.eByteOrderLittle:
> >> > > >> >>> self.expect(
> >> > > >> >>> @@ -400,9 +400,9 @@ def cleanup():
> >> > > >> >>> '00 00 00 09,00 00 00 08,00 00 00 07,00
> 00 00 06,00 00 00 05'])
> >> > > >> >>>
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%Y}\" \"float [7]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%Y}\" \"float[7]\"")
> >> > > >> >>> self.runCmd(
> >> > > >> >>> - "type summary add --summary-string \"arr =
> ${var%Y}\" \"int [5]\"")
> >> > > >> >>> + "type summary add --summary-string \"arr =
> ${var%Y}\" \"int[5]\"")
> >> > > >> >>>
> >> > > >> >>> if process.GetByteOrder() == lldb.eByteOrderLittle:
> >> > > >> >>> self.expect(
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/functionalities/data-formatter/typedef_array/main.cpp
> b/lldb/test/API/functionalities/data-formatter/typedef_array/main.cpp
> >> > > >> >>> index 7e4323c9bb7ce..1b073f8a29406 100644
> >> > > >> >>> ---
> a/lldb/test/API/functionalities/data-formatter/typedef_array/main.cpp
> >> > > >> >>> +++
> b/lldb/test/API/functionalities/data-formatter/typedef_array/main.cpp
> >> > > >> >>> @@ -1,7 +1,7 @@
> >> > > >> >>> typedef int Foo;
> >> > > >> >>>
> >> > > >> >>> int main() {
> >> > > >> >>> - // CHECK: (Foo [3]) array = {
> >> > > >> >>> + // CHECK: (Foo[3]) array = {
> >> > > >> >>> // CHECK-NEXT: (Foo) [0] = 1
> >> > > >> >>> // CHECK-NEXT: (Foo) [1] = 2
> >> > > >> >>> // CHECK-NEXT: (Foo) [2] = 3
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/lang/c/array_types/TestArrayTypes.py
> b/lldb/test/API/lang/c/array_types/TestArrayTypes.py
> >> > > >> >>> index 455b8708fb702..2adeb8346e5b2 100644
> >> > > >> >>> --- a/lldb/test/API/lang/c/array_types/TestArrayTypes.py
> >> > > >> >>> +++ b/lldb/test/API/lang/c/array_types/TestArrayTypes.py
> >> > > >> >>> @@ -71,12 +71,12 @@ def test_and_run_command(self):
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable --show-types ushort_matrix",
> >> > > >> >>> VARIABLES_DISPLAYED_CORRECTLY,
> >> > > >> >>> - startstr='(unsigned short [2][3])')
> >> > > >> >>> + startstr='(unsigned short[2][3])')
> >> > > >> >>>
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable --show-types long_6",
> >> > > >> >>> VARIABLES_DISPLAYED_CORRECTLY,
> >> > > >> >>> - startstr='(long [6])')
> >> > > >> >>> + startstr='(long[6])')
> >> > > >> >>>
> >> > > >> >>> @expectedFailureNetBSD
> >> > > >> >>> @add_test_categories(['pyapi'])
> >> > > >> >>>
> >> > > >> >>> diff --git a/lldb/test/API/lang/c/vla/TestVLA.py
> b/lldb/test/API/lang/c/vla/TestVLA.py
> >> > > >> >>> index aaf8767246e84..215eadc41a739 100644
> >> > > >> >>> --- a/lldb/test/API/lang/c/vla/TestVLA.py
> >> > > >> >>> +++ b/lldb/test/API/lang/c/vla/TestVLA.py
> >> > > >> >>> @@ -39,7 +39,7 @@ def test(a, array):
> >> > > >> >>> self.expect("fr v vla", substrs=array)
> >> > > >> >>> self.expect("expr vla", error=True,
> substrs=["incomplete"])
> >> > > >> >>>
> >> > > >> >>> - test(2, ["int []", "[0] = 2, [1] = 1"])
> >> > > >> >>> + test(2, ["int[]", "[0] = 2, [1] = 1"])
> >> > > >> >>> process.Continue()
> >> > > >> >>> - test(4, ["int []", "[0] = 4, [1] = 3, [2] = 2, [3]
> = 1"])
> >> > > >> >>> + test(4, ["int[]", "[0] = 4, [1] = 3, [2] = 2, [3] =
> 1"])
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/lang/cpp/bitfields/TestCppBitfields.py
> b/lldb/test/API/lang/cpp/bitfields/TestCppBitfields.py
> >> > > >> >>> index 480b680e792e6..c67446f478032 100644
> >> > > >> >>> --- a/lldb/test/API/lang/cpp/bitfields/TestCppBitfields.py
> >> > > >> >>> +++ b/lldb/test/API/lang/cpp/bitfields/TestCppBitfields.py
> >> > > >> >>> @@ -87,7 +87,7 @@ def test_and_run_command(self):
> >> > > >> >>> "frame variable --show-types lbd",
> >> > > >> >>> VARIABLES_DISPLAYED_CORRECTLY,
> >> > > >> >>> substrs=[
> >> > > >> >>> - '(char [3]) arr = "ab"',
> >> > > >> >>> + '(char[3]) arr = "ab"',
> >> > > >> >>> '(int:32) =',
> >> > > >> >>> '(unsigned int:20) a = 5',
> >> > > >> >>> ])
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/lang/cpp/char1632_t/TestChar1632T.py
> b/lldb/test/API/lang/cpp/char1632_t/TestChar1632T.py
> >> > > >> >>> index a32248f08e597..182302987ca9b 100644
> >> > > >> >>> --- a/lldb/test/API/lang/cpp/char1632_t/TestChar1632T.py
> >> > > >> >>> +++ b/lldb/test/API/lang/cpp/char1632_t/TestChar1632T.py
> >> > > >> >>> @@ -72,8 +72,8 @@ def test(self):
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable as16 as32",
> >> > > >> >>> patterns=[
> >> > > >> >>> - '\(char16_t \[[0-9]+\]\) as16 = ',
> >> > > >> >>> - '\(char32_t \[[0-9]+\]\) as32 = '],
> >> > > >> >>> + '\(char16_t\[[0-9]+\]\) as16 = ',
> >> > > >> >>> + '\(char32_t\[[0-9]+\]\) as32 = '],
> >> > > >> >>> substrs=[
> >> > > >> >>> 'u"ﺸﺵۻ"',
> >> > > >> >>> 'U"ЕЙРГЖО"'])
> >> > > >> >>> @@ -100,8 +100,8 @@ def test(self):
> >> > > >> >>> self.expect(
> >> > > >> >>> "frame variable as16 as32",
> >> > > >> >>> patterns=[
> >> > > >> >>> - '\(char16_t \[[0-9]+\]\) as16 = ',
> >> > > >> >>> - '\(char32_t \[[0-9]+\]\) as32 = '],
> >> > > >> >>> + '\(char16_t\[[0-9]+\]\) as16 = ',
> >> > > >> >>> + '\(char32_t\[[0-9]+\]\) as32 = '],
> >> > > >> >>> substrs=[
> >> > > >> >>> '"色ハ匂ヘト散リヌルヲ"',
> >> > > >> >>> '"෴"'])
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/lang/cpp/char8_t/TestCxxChar8_t.py
> b/lldb/test/API/lang/cpp/char8_t/TestCxxChar8_t.py
> >> > > >> >>> index b39a069f5f212..aed923bf3def6 100644
> >> > > >> >>> --- a/lldb/test/API/lang/cpp/char8_t/TestCxxChar8_t.py
> >> > > >> >>> +++ b/lldb/test/API/lang/cpp/char8_t/TestCxxChar8_t.py
> >> > > >> >>> @@ -22,4 +22,4 @@ def test(self):
> >> > > >> >>>
> >> > > >> >>> self.expect_expr("a", result_type="char8_t",
> result_summary="0x61 u8'a'")
> >> > > >> >>> self.expect_expr("ab", result_type="const char8_t
> *", result_summary='u8"你好"')
> >> > > >> >>> - self.expect_expr("abc", result_type="char8_t [9]",
> result_summary='u8"你好"')
> >> > > >> >>> + self.expect_expr("abc", result_type="char8_t[9]",
> result_summary='u8"你好"')
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/lang/cpp/class_static/TestStaticVariables.py
> b/lldb/test/API/lang/cpp/class_static/TestStaticVariables.py
> >> > > >> >>> index d5e2c8fdb2486..5d1a79ed24128 100644
> >> > > >> >>> ---
> a/lldb/test/API/lang/cpp/class_static/TestStaticVariables.py
> >> > > >> >>> +++
> b/lldb/test/API/lang/cpp/class_static/TestStaticVariables.py
> >> > > >> >>> @@ -40,9 +40,9 @@ def test_with_run_command(self):
> >> > > >> >>> self.expect(
> >> > > >> >>> 'target variable A::g_points',
> >> > > >> >>> VARIABLES_DISPLAYED_CORRECTLY,
> >> > > >> >>> - patterns=['\(PointType \[[1-9]*\]\) A::g_points
> = {'])
> >> > > >> >>> + patterns=['\(PointType\[[1-9]*\]\) A::g_points
> = {'])
> >> > > >> >>> self.expect('target variable g_points',
> VARIABLES_DISPLAYED_CORRECTLY,
> >> > > >> >>> - substrs=['(PointType [2]) g_points'])
> >> > > >> >>> + substrs=['(PointType[2]) g_points'])
> >> > > >> >>>
> >> > > >> >>> # On Mac OS X, gcc 4.2 emits the wrong debug info
> for A::g_points.
> >> > > >> >>> # A::g_points is an array of two elements.
> >> > > >> >>> @@ -74,7 +74,7 @@ def test_with_run_command_complete(self):
> >> > > >> >>> 'target variable A::g_points',
> >> > > >> >>> VARIABLES_DISPLAYED_CORRECTLY,
> >> > > >> >>> patterns=[
> >> > > >> >>> - '\(PointType \[[1-9]*\]\) A::g_points = {',
> '(x = 1, y = 2)',
> >> > > >> >>> + '\(PointType\[[1-9]*\]\) A::g_points = {',
> '(x = 1, y = 2)',
> >> > > >> >>> '(x = 11, y = 22)'
> >> > > >> >>> ])
> >> > > >> >>>
> >> > > >> >>> @@ -92,7 +92,7 @@ def test_with_run_command_complete(self):
> >> > > >> >>> 'target variable g_points',
> >> > > >> >>> VARIABLES_DISPLAYED_CORRECTLY,
> >> > > >> >>> substrs=[
> >> > > >> >>> - '(PointType [2]) g_points', '(x = 1, y =
> 2)',
> >> > > >> >>> + '(PointType[2]) g_points', '(x = 1, y = 2)',
> >> > > >> >>> '(x = 11, y = 22)', '(x = 3, y = 4)', '(x =
> 33, y = 44)'
> >> > > >> >>> ])
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/lang/cpp/non-type-template-param/TestCppNonTypeTemplateParam.py
> b/lldb/test/API/lang/cpp/non-type-template-param/TestCppNonTypeTemplateParam.py
> >> > > >> >>> index 12cf5bd3ec03a..4db94dae20acd 100644
> >> > > >> >>> ---
> a/lldb/test/API/lang/cpp/non-type-template-param/TestCppNonTypeTemplateParam.py
> >> > > >> >>> +++
> b/lldb/test/API/lang/cpp/non-type-template-param/TestCppNonTypeTemplateParam.py
> >> > > >> >>> @@ -13,5 +13,5 @@ def test(self):
> >> > > >> >>>
> self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
> >> > > >> >>>
> >> > > >> >>> self.expect_expr("myArray", result_type="array<3>",
> result_children=[
> >> > > >> >>> - ValueCheck(name="Arr", type="int [3]")
> >> > > >> >>> + ValueCheck(name="Arr", type="int[3]")
> >> > > >> >>> ])
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py
> b/lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py
> >> > > >> >>> index 092d96edf4eb6..30a85ec5eb28e 100644
> >> > > >> >>> ---
> a/lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py
> >> > > >> >>> +++
> b/lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py
> >> > > >> >>> @@ -178,8 +178,8 @@ def
> test_scopes_variables_setVariable_evaluate(self):
> >> > > >> >>> 'hasVariablesReference': True
> >> > > >> >>> },
> >> > > >> >>> 'pt.buffer': {
> >> > > >> >>> - 'equals': {'type': 'int [32]'},
> >> > > >> >>> - 'startswith': {'result': 'int [32] @ 0x'},
> >> > > >> >>> + 'equals': {'type': 'int[32]'},
> >> > > >> >>> + 'startswith': {'result': 'int[32] @ 0x'},
> >> > > >> >>> 'hasVariablesReference': True
> >> > > >> >>> },
> >> > > >> >>> 'argv': {
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_const_value.s
> b/lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_const_value.s
> >> > > >> >>> index 5753be3f3ba25..4bb7b2578a59d 100644
> >> > > >> >>> ---
> a/lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_const_value.s
> >> > > >> >>> +++
> b/lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_const_value.s
> >> > > >> >>> @@ -16,10 +16,10 @@
> >> > > >> >>> # CHECK: (unsigned long) data8 = 4742474247424742
> >> > > >> >>> ## Variables specified using string forms. This behavior
> purely speculative -- I
> >> > > >> >>> ## don't know of any compiler that would represent
> character strings this way.
> >> > > >> >>> -# CHECK: (char [7]) string = "string"
> >> > > >> >>> -# CHECK: (char [7]) strp = "strp\0\0"
> >> > > >> >>> +# CHECK: (char[7]) string = "string"
> >> > > >> >>> +# CHECK: (char[7]) strp = "strp\0\0"
> >> > > >> >>> ## Bogus attribute form. Let's make sure we don't crash at
> least.
> >> > > >> >>> -# CHECK: (char [7]) ref4 = <empty constant data>
> >> > > >> >>> +# CHECK: (char[7]) ref4 = <empty constant data>
> >> > > >> >>> ## A variable of pointer type.
> >> > > >> >>> # CHECK: (unsigned long *) udata_ptr = 0xdeadbeefbaadf00d
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/Shell/SymbolFile/DWARF/x86/array-sizes.s
> b/lldb/test/Shell/SymbolFile/DWARF/x86/array-sizes.s
> >> > > >> >>> index d70352d8531ea..dc86db055677d 100644
> >> > > >> >>> --- a/lldb/test/Shell/SymbolFile/DWARF/x86/array-sizes.s
> >> > > >> >>> +++ b/lldb/test/Shell/SymbolFile/DWARF/x86/array-sizes.s
> >> > > >> >>> @@ -10,7 +10,7 @@
> >> > > >> >>> # RUN: lldb-test symbols %t | FileCheck %s
> >> > > >> >>>
> >> > > >> >>> # CHECK: Variable{0x0000001e}, name = "X"
> >> > > >> >>> -# CHECK-SAME: type = {0000000000000033} 0x{{[0-9A-F]*}}
> (char [56])
> >> > > >> >>> +# CHECK-SAME: type = {0000000000000033} 0x{{[0-9A-F]*}}
> (char[56])
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> # Generated from "char X[47];"
> >> > > >> >>>
> >> > > >> >>> diff --git
> a/lldb/test/Shell/SymbolFile/NativePDB/global-classes.cpp
> b/lldb/test/Shell/SymbolFile/NativePDB/global-classes.cpp
> >> > > >> >>> index 226c47ce1c53f..30293a79c3b6c 100644
> >> > > >> >>> --- a/lldb/test/Shell/SymbolFile/NativePDB/global-classes.cpp
> >> > > >> >>> +++ b/lldb/test/Shell/SymbolFile/NativePDB/global-classes.cpp
> >> > > >> >>> @@ -153,14 +153,14 @@ constexpr ClassWithPadding
> ClassWithPaddingInstance;
> >> > > >> >>> // CHECK-NEXT: (const ClassWithPadding)
> ClassWithPaddingInstance = {
> >> > > >> >>> // CHECK-NEXT: (char) a = '0'
> >> > > >> >>> // CHECK-NEXT: (short) b = 50
> >> > > >> >>> -// CHECK-NEXT: (char [2]) c = "01"
> >> > > >> >>> +// CHECK-NEXT: (char[2]) c = "01"
> >> > > >> >>> // CHECK-NEXT: (int) d = 100
> >> > > >> >>> // CHECK-NEXT: (char) e = '0'
> >> > > >> >>> // CHECK-NEXT: (int) f = 200
> >> > > >> >>> // CHECK-NEXT: (long long) g = 300
> >> > > >> >>> -// CHECK-NEXT: (char [3]) h = "012"
> >> > > >> >>> +// CHECK-NEXT: (char[3]) h = "012"
> >> > > >> >>> // CHECK-NEXT: (long long) i = 400
> >> > > >> >>> -// CHECK-NEXT: (char [2]) j = "01"
> >> > > >> >>> +// CHECK-NEXT: (char[2]) j = "01"
> >> > > >> >>> // CHECK-NEXT: (long long) k = 500
> >> > > >> >>> // CHECK-NEXT: (char) l = '0'
> >> > > >> >>> // CHECK-NEXT: (long long) m = 600
> >> > > >> >>> @@ -184,7 +184,7 @@ constexpr ClassNoPadding
> ClassNoPaddingInstance;
> >> > > >> >>> // CHECK-NEXT: (double) m = 23890.897422999999
> >> > > >> >>> // CHECK-NEXT: (unsigned long long) n = 23490782
> >> > > >> >>> // CHECK-NEXT: (long long) o = -923409823
> >> > > >> >>> -// CHECK-NEXT: (int [5]) p = {
> >> > > >> >>> +// CHECK-NEXT: (int[5]) p = {
> >> > > >> >>> // CHECK-NEXT: (int) [0] = 2
> >> > > >> >>> // CHECK-NEXT: (int) [1] = 3
> >> > > >> >>> // CHECK-NEXT: (int) [2] = 5
> >> > > >> >>> @@ -276,14 +276,14 @@ constexpr References
> ReferencesInstance;
> >> > > >> >>> // CHECK: |-CXXRecordDecl {{.*}} class ClassWithPadding
> definition
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} a 'char'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} b 'short'
> >> > > >> >>> -// CHECK: | |-FieldDecl {{.*}} c 'char [2]'
> >> > > >> >>> +// CHECK: | |-FieldDecl {{.*}} c 'char[2]'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} d 'int'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} e 'char'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} f 'int'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} g 'long long'
> >> > > >> >>> -// CHECK: | |-FieldDecl {{.*}} h 'char [3]'
> >> > > >> >>> +// CHECK: | |-FieldDecl {{.*}} h 'char[3]'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} i 'long long'
> >> > > >> >>> -// CHECK: | |-FieldDecl {{.*}} j 'char [2]'
> >> > > >> >>> +// CHECK: | |-FieldDecl {{.*}} j 'char[2]'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} k 'long long'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} l 'char'
> >> > > >> >>> // CHECK: | `-FieldDecl {{.*}} m 'long long'
> >> > > >> >>> @@ -304,7 +304,7 @@ constexpr References ReferencesInstance;
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} m 'double'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} n 'unsigned long long'
> >> > > >> >>> // CHECK: | |-FieldDecl {{.*}} o 'long long'
> >> > > >> >>> -// CHECK: | `-FieldDecl {{.*}} p 'int [5]'
> >> > > >> >>> +// CHECK: | `-FieldDecl {{.*}} p 'int[5]'
> >> > > >> >>> // CHECK: |-VarDecl {{.*}} ClassNoPaddingInstance 'const
> ClassNoPadding'
> >> > > >> >>> // CHECK: |-EnumDecl {{.*}} EnumType
> >> > > >> >>> // CHECK: | |-EnumConstantDecl {{.*}} A 'EnumType'
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>>
> >> > > >> >>> _______________________________________________
> >> > > >> >>> lldb-commits mailing list
> >> > > >> >>> lldb-commits at lists.llvm.org
> >> > > >> >>> https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
> >> > > >> >
> >> > > >> > _______________________________________________
> >> > > >> > lldb-commits mailing list
> >> > > >> > lldb-commits at lists.llvm.org
> >> > > >> > https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
> >> > > _______________________________________________
> >> > > lldb-commits mailing list
> >> > > lldb-commits at lists.llvm.org
> >> > > https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
> >> >
> >>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20211026/297108c4/attachment-0001.html>
More information about the cfe-commits
mailing list