"Fancy" ARBs

[hfinkel]

Summary

When ARBs (arrays of runtime bound) were discussed in Lenexa last week, the idea that gained consensus to move forward was a "magic" class, one that could only be constructed on the stack, perhaps using an ARB(-like) syntax. We did not have a concrete proposal for such a facility, nor are there any implementations that follow that model. However, there is not consensus for ARBs as-is, nor particularly for dynarray, and some hybrid seems like the only viable path forward (aside from doing nothing). And I'd prefer we do something...

This patch implements a mode in Clang for "fancy" ARBs, controlled by a feature flag: -ffancy-arbs -- While still rough, I'd like early feedback on this. The basic idea is that declaring:

int x[n]

where n is not a constant, not only creates a stack array to hold n objects of type int, but also wraps that array in a container-like class. Here I've named it std::arb (I know this makes it a non-conforming extension; we can certainly name it something else), and it is kind of like std::initializer_list on steroids (it looks more like an array wrapper, has more of the standard typedefs, is convertable to a pointer type, etc.).

The implementation wraps the VarDecl creation and causes two variables to be declared: an internal variable (x.ARB) that actually manages the storage and object lifetimes, and an std::arb wrapper (which gets the declared name x), through which the surrounding code interacts with the storage. Some plumbing changes in Sema allow for the capturing of this additional declaration so it can be added to the DeclGroup with the primary one.

One of the design requirement of the design is that the class be "magic" (unable to be created manually), and to meet this requirement, the class is non-copyable, non-movable, and has no public constructors. A new "magic" init type is added, like CallInit, but bypassing access control checks, to cause the ARB syntax to trigger construction of std::arb via an otherwise inaccessible private constructor. I'm not sure if, from a standardization perspective, this access-control-overriding is necessary. If we don't do it, any code that uses the constructor would be implementation-specific and have UB.

This should, hopefully, satisfy the consensus requirements from EWG, while matching the current syntax for ARBs. While you can pass x to a function requiring int*, x will also support begin(), end(), size(), etc. and can be treated like a container. This using (pointer,size) on interface boundaries is not required (which is part of the reason I elected to make it a type with a "standardized" name).

Currently, the definition of std::arb is in an internal header that is included before normal source parsing. To limit expense, I did not include any features in std::arb that would be complicated to implement, or require pulling in other library headers (no reverse iterators, no at() because no exceptions, no fill()). An alternative design is to make the implementation more fully-featured but require the header be included in every TU in which ARBs are used.

The current implementation does not work with non-POD types because the underlying VLA support rejects them. That can be extended separately (from this patch), and then non-POD types should also work with this feature.

Please review.

[rsmith]

First off: I'm not happy about having this extension in upstream clang until we have a strong indication that this is the direction that will end up standardized. For now, I'd recommend maintaining this as a clang fork on github or similar. With that said, I'm going to review this as if for upstream clang.

I don't like that you create two variables here. We try to maintain as much source fidelity as we can, and I think we can do better here -- how about instead introducing a new form of expression that represents "stack-allocate a certain amount of memory" (with a subexpression for the initialization, if you allow these variables to have an initializer), much like MaterializeTemporaryExpr does for a SD_Automatic temporary, but parameterized by an expression specifying the array size? Then create just a single expression of the std::arb type, initialized by that expression.

You should also introduce a Type subclass to represent type sugar for the ARB type, so that we can model that int[n] desugars to std::arb<int> but should be pretty-printed as an array type.

[hfinkel]

In D9714#171408, @rsmith wrote:

First off: I'm not happy about having this extension in upstream clang until we have a strong indication that this is the direction that will end up standardized. For now, I'd recommend maintaining this as a clang fork on github or similar.

Will do.

With that said, I'm going to review this as if for upstream clang.

Thanks! (The point of doing this is to get feedback on implementation-related issues)

I don't like that you create two variables here. We try to maintain as much source fidelity as we can, and I think we can do better here -- how about instead introducing a new form of expression that represents "stack-allocate a certain amount of memory" (with a subexpression for the initialization, if you allow these variables to have an initializer), much like MaterializeTemporaryExpr does for a SD_Automatic temporary, but parameterized by an expression specifying the array size? Then create just a single expression of the std::arb type, initialized by that expression.

You should also introduce a Type subclass to represent type sugar for the ARB type, so that we can model that int[n] desugars to std::arb<int> but should be pretty-printed as an array type.

That makes sense (and this is very similar to how we currently handle std::initializer_list).

Any opinion on:

1. Should we bother with the access-control-overriding init type? We could just make the constructor public but make it UB if the user calls it (it would be implementation-specific anyhow).
2. Should I make std::arb manage the lifetime of the objects directly? If it just takes a special allocation expression maybe that's more natural? I'd like to not force extra work for POD types (but I imagine I could use some enable_if/is_pod logic to leave PODs uninitialized).
3. The automatically-included header (or similar) with a simpler class, or just requiring the header and making the class more fully-featured?

Thanks again!

[hfinkel]

In D9714#171426, @hfinkel wrote:

In D9714#171408, @rsmith wrote:

First off: I'm not happy about having this extension in upstream clang until we have a strong indication that this is the direction that will end up standardized. For now, I'd recommend maintaining this as a clang fork on github or similar.

Will do.

With that said, I'm going to review this as if for upstream clang.

Thanks! (The point of doing this is to get feedback on implementation-related issues)

I don't like that you create two variables here. We try to maintain as much source fidelity as we can, and I think we can do better here -- how about instead introducing a new form of expression that represents "stack-allocate a certain amount of memory" (with a subexpression for the initialization, if you allow these variables to have an initializer), much like MaterializeTemporaryExpr does for a SD_Automatic temporary, but parameterized by an expression specifying the array size? Then create just a single expression of the std::arb type, initialized by that expression.

You should also introduce a Type subclass to represent type sugar for the ARB type, so that we can model that int[n] desugars to std::arb<int> but should be pretty-printed as an array type.

That makes sense (and this is very similar to how we currently handle std::initializer_list).

Any opinion on:

1. Should we bother with the access-control-overriding init type? We could just make the constructor public but make it UB if the user calls it (it would be implementation-specific anyhow).
2. Should I make std::arb manage the lifetime of the objects directly? If it just takes a special allocation expression maybe that's more natural? I'd like to not force extra work for POD types (but I imagine I could use some enable_if/is_pod logic to leave PODs uninitialized).

Or to put it another way, should the aforementioned new "stack-allocate a certain amount of memory" expression also be responsible for calling the constructors of non-POD array elements and register calling their destructors as cleanup, or should that logic be embedded in std::arb?

2. The automatically-included header (or similar) with a simpler class, or just requiring the header and making the class more fully-featured?

Thanks again!

include/clang/AST/Decl.h

public:
   ///
   /// It is illegal to call this function with SC == None.
   static const char *getStorageClassSpecifierString(StorageClass SC);
 
   /// \brief Initialization styles.
   enum InitializationStyle {
     CInit,    ///< C-style initialization with assignment
     CallInit, ///< Call-style initialization (C++98)
-    ListInit  ///< Direct list-initialization (C++11)
+    ListInit,  ///< Direct list-initialization (C++11)
+    MagicInit ///< Call-style init without access checking
   };
 
   /// \brief Kinds of thread-local storage.
   enum TLSKind {
     TLS_None,   ///< Not a TLS variable.
     TLS_Static, ///< TLS with a known-constant initializer.
     TLS_Dynamic ///< TLS with a dynamic initializer.
   };
bool isInitICE() const {
     return Init.get<EvaluatedStmt *>()->IsICE;
   }
 
   /// \brief Determine whether the value of the initializer attached to this
   /// declaration is an integral constant expression.
   bool checkInitIsICE() const;
 
   void setInitStyle(InitializationStyle Style) {
+    if (getInitStyle() != MagicInit)
       VarDeclBits.InitStyle = Style;
   }
 
   /// \brief The style of initialization for this declaration.
   ///
   /// C-style initialization is "int x = 1;". Call-style initialization is
   /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
   /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
   /// expression for class types. List-style initialization is C++11 syntax,

include/clang/Basic/DiagnosticSemaKinds.td

def err_implied_std_initializer_list_not_found : Error<
   "cannot deduce type of initializer list because std::initializer_list was "
   "not found; include <initializer_list>">;
 def err_malformed_std_initializer_list : Error<
   "std::initializer_list must be a class template with a single type parameter">;
 def warn_dangling_std_initializer_list : Warning<
   "array backing the initializer list will be destroyed at the end of "
   "%select{the full-expression|the constructor}0">,
   InGroup<DiagGroup<"dangling-initializer-list">>;
+def err_implied_std_arb_not_found : Error<
+  "cannot deduce type of array because std::arb was not found">;
+def err_malformed_std_arb : Error<
+  "std::arb must be a class template with a single type parameter">;
 
 // C++1y decltype(auto) type
 def err_decltype_auto_cannot_be_combined : Error<
   "'decltype(auto)' cannot be combined with other type specifiers">;
 def err_decltype_auto_function_declarator_not_declaration : Error<
   "'decltype(auto)' can only be used as a return type "
   "in a function declaration">;
 def err_decltype_auto_compound_type : Error<

include/clang/Basic/LangOptions.def

 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(OpenMP            , 1, 0, "OpenMP support")
 LANGOPT(CUDAIsDevice      , 1, 0, "Compiling for CUDA device")
 LANGOPT(CUDAAllowHostCallsFromHostDevice, 1, 0, "Allow host device functions to call host functions")
 LANGOPT(CUDADisableTargetCallChecks, 1, 0, "Disable checks for call targets (host, device, etc.)")
 
 LANGOPT(AssumeSaneOperatorNew , 1, 1, "implicit __attribute__((malloc)) for C++'s new operators")
 LANGOPT(SizedDeallocation , 1, 0, "enable sized deallocation functions")
+LANGOPT(FancyARBs , 1, 0, "use std::arb to represent ARBs")
 BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision")
 BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records")
 BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form")
 BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables")
 LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings")
 BENIGN_LANGOPT(InlineVisibilityHidden , 1, 0, "hidden default visibility for inline C++ methods")
 BENIGN_LANGOPT(ParseUnknownAnytype, 1, 0, "__unknown_anytype")
 BENIGN_LANGOPT(DebuggerSupport , 1, 0, "debugger support")

include/clang/Driver/Options.td

 def fapplication_extension : Flag<["-"], "fapplication-extension">,
   Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Restrict code to those available for App Extensions">;
 def fno_application_extension : Flag<["-"], "fno-application-extension">,
   Group<f_Group>;
 def fsized_deallocation : Flag<["-"], "fsized-deallocation">, Flags<[CC1Option]>,
   HelpText<"Enable C++14 sized global deallocation functions">, Group<f_Group>;
 def fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">, Group<f_Group>;
+def ffancy_arbs : Flag<["-"], "ffancy-arbs">, Flags<[CC1Option]>,
+  HelpText<"Use std::arb for ARBs">, Group<f_Group>;
+def fno_fancy_arbs: Flag<["-"], "fno-fancy-arbs">, Group<f_Group>;
 
 def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use GC exclusively for Objective-C related memory management">;
 def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable Objective-C garbage collection">;
 def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>;
 def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>;
 def fobjc_infer_related_result_type : Flag<["-"], "fobjc-infer-related-result-type">, 

include/clang/Parse/Parser.h

DeclGroupPtrTy ParseSimpleDeclaration(unsigned Context,
                                         SourceLocation &DeclEnd,
                                         ParsedAttributesWithRange &attrs,
                                         bool RequireSemi,
                                         ForRangeInit *FRI = nullptr);
   bool MightBeDeclarator(unsigned Context);
   DeclGroupPtrTy ParseDeclGroup(ParsingDeclSpec &DS, unsigned Context,
                                 SourceLocation *DeclEnd = nullptr,
                                 ForRangeInit *FRI = nullptr);
-  Decl *ParseDeclarationAfterDeclarator(Declarator &D,
+  Decl *ParseDeclarationAfterDeclarator(Declarator &D, Decl *&AuxDecl,
                const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo());
   bool ParseAsmAttributesAfterDeclarator(Declarator &D);
   Decl *ParseDeclarationAfterDeclaratorAndAttributes(
-      Declarator &D,
+      Declarator &D, Decl *&AuxDecl,
       const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
       ForRangeInit *FRI = nullptr);
   Decl *ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope);
   Decl *ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope);
 
   /// \brief When in code-completion, skip parsing of the function/method body
   /// unless the body contains the code-completion point.
   ///

include/clang/Sema/Initialization.h

public:
   ///
   /// \returns an expression that performs the actual object initialization, if
   /// the initialization is well-formed. Otherwise, emits diagnostics
   /// and returns an invalid expression.
   ExprResult Perform(Sema &S,
                      const InitializedEntity &Entity,
                      const InitializationKind &Kind,
                      MultiExprArg Args,
-                     QualType *ResultType = nullptr);
+                     QualType *ResultType = nullptr,
+                     bool NoAccessCheck = false);
   
   /// \brief Diagnose an potentially-invalid initialization sequence.
   ///
   /// \returns true if the initialization sequence was ill-formed, 
   /// false otherwise.
   bool Diagnose(Sema &S, 
                 const InitializedEntity &Entity,
                 const InitializationKind &Kind,

include/clang/Sema/Sema.h

public:
   /// \brief The C++ "std::bad_alloc" class, which is defined by the C++
   /// standard library.
   LazyDeclPtr StdBadAlloc;
 
   /// \brief The C++ "std::initializer_list" template, which is defined in
   /// \<initializer_list>.
   ClassTemplateDecl *StdInitializerList;
 
+  /// \brief The C++ "std::arb" template, which is defined in \<arb>.
+  ClassTemplateDecl *StdARB;
+
   /// \brief The C++ "type_info" declaration, which is defined in \<typeinfo>.
   RecordDecl *CXXTypeInfoDecl;
 
   /// \brief The MSVC "_GUID" struct, which is defined in MSVC header files.
   RecordDecl *MSVCGuidDecl;
 
   /// \brief Caches identifiers/selectors for NSFoundation APIs.
   std::unique_ptr<NSAPI> NSAPIObj;
public:
   /// \param CCC The correction callback, if typo correction is desired.
   NameClassification
   ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
                SourceLocation NameLoc, const Token &NextToken,
                bool IsAddressOfOperand,
                std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr);
 
   Decl *ActOnDeclarator(Scope *S, Declarator &D);
+  Decl *ActOnDeclarator(Scope *S, Declarator &D, Decl *&AuxDecl);
 
   NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
                               MultiTemplateParamsArg TemplateParameterLists);
+  NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
+                              MultiTemplateParamsArg TemplateParameterLists,
+                              Decl *&AuxDecl);
   void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
   bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
   bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
                                     DeclarationName Name,
                                     SourceLocation Loc);
   void
   diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
                             SourceLocation FallbackLoc,
NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
                                     TypeSourceInfo *TInfo,
                                     LookupResult &Previous);
   NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
                                   LookupResult &Previous, bool &Redeclaration);
   NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
                                      TypeSourceInfo *TInfo,
                                      LookupResult &Previous,
                                      MultiTemplateParamsArg TemplateParamLists,
-                                     bool &AddToScope);
+                                     bool &AddToScope, Decl *&AuxDecl);
   // Returns true if the variable declaration is a redeclaration
   bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
   void CheckVariableDeclarationType(VarDecl *NewVD);
   void CheckCompleteVariableDeclaration(VarDecl *var);
   void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
 
   NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
                                      TypeSourceInfo *TInfo,
public:
   ///
   /// \returns The instantiated template, or null on error.
   QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
 
   /// \brief Determine whether Ctor is an initializer-list constructor, as
   /// defined in [dcl.init.list]p2.
   bool isInitListConstructor(const CXXConstructorDecl *Ctor);
 
+  /// \brief Looks for the std::arb template and instantiates it
+  /// with Element, or emits an error if it's not found.
+  ///
+  /// \returns The instantiated template, or null on error.
+  QualType BuildStdARB(QualType Element, SourceLocation Loc);
+
   Decl *ActOnUsingDirective(Scope *CurScope,
                             SourceLocation UsingLoc,
                             SourceLocation NamespcLoc,
                             CXXScopeSpec &SS,
                             SourceLocation IdentLoc,
                             IdentifierInfo *NamespcName,
                             AttributeList *AttrList);
 

lib/AST/ASTDumper.cpp

if (D->isModulePrivate())
     OS << " __module_private__";
   if (D->isNRVOVariable())
     OS << " nrvo";
   if (D->hasInit()) {
     switch (D->getInitStyle()) {
     case VarDecl::CInit: OS << " cinit"; break;
     case VarDecl::CallInit: OS << " callinit"; break;
     case VarDecl::ListInit: OS << " listinit"; break;
+    case VarDecl::MagicInit: OS << " magicinit"; break;
     }
     dumpStmt(D->getInit());
   }
 }
 
 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
   dumpStmt(D->getAsmString());
 }

lib/Driver/Tools.cpp

if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
     CmdArgs.push_back("-fno-assume-sane-operator-new");
 
   // -fsized-deallocation is off by default, as it is an ABI-breaking change for
   // most platforms.
   if (Args.hasFlag(options::OPT_fsized_deallocation,
                    options::OPT_fno_sized_deallocation, false))
     CmdArgs.push_back("-fsized-deallocation");
 
+  // Should we use std::arb for ARBs?
+  if (Args.hasFlag(options::OPT_ffancy_arbs,
+                   options::OPT_fno_fancy_arbs, false))
+    CmdArgs.push_back("-ffancy-arbs");
+
   // -fconstant-cfstrings is default, and may be subject to argument translation
   // on Darwin.
   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
                     options::OPT_fno_constant_cfstrings) ||
       !Args.hasFlag(options::OPT_mconstant_cfstrings,
                     options::OPT_mno_constant_cfstrings))
     CmdArgs.push_back("-fno-constant-cfstrings");
 

lib/Frontend/CompilerInvocation.cpp

#include "clang/Frontend/LangStandards.def"
   Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
   Opts.ShortWChar = Args.hasFlag(OPT_fshort_wchar, OPT_fno_short_wchar, false);
   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
   Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
   Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
   Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
+  Opts.FancyARBs = Args.hasArg(OPT_ffancy_arbs);
   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
   Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
   Opts.InstantiationDepth =
       getLastArgIntValue(Args, OPT_ftemplate_depth, 256, Diags);
   Opts.ArrowDepth =
       getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);

lib/Frontend/InitPreprocessor.cpp

void clang::InitializePreprocessor(Preprocessor &PP,
   }
   
   // Even with predefines off, some macros are still predefined.
   // These should all be defined in the preprocessor according to the
   // current language configuration.
   InitializeStandardPredefinedMacros(PP.getTargetInfo(), PP.getLangOpts(),
                                      FEOpts, Builder);
 
+  if (InitOpts.UsePredefines && LangOpts.FancyARBs)
+    AddImplicitInclude(Builder, "__arb.h");
+
   // Add on the predefines from the driver.  Wrap in a #line directive to report
   // that they come from the command line.
   if (!PP.getLangOpts().AsmPreprocessor)
     Builder.append("# 1 \"<command line>\" 1");
 
   // Process #define's and #undef's in the order they are given.
   for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
     if (InitOpts.Macros[i].second)  // isUndef

lib/Headers/CMakeLists.txt

 set(files
   adxintrin.h
   altivec.h
   ammintrin.h
+  __arb.h
   arm_acle.h
   avx2intrin.h
   avx512bwintrin.h
   avx512erintrin.h
   avx512fintrin.h
   avx512vlbwintrin.h
   avx512vlintrin.h
   avx512dqintrin.h

lib/Headers/__arb.h

+// -*- C++ -*-
+//===----------------------------- arb ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _ARB
+#define _ARB
+
+#pragma GCC system_header
+
+namespace std { inline namespace __clang_arb_v1 {
+
+template <class _Tp>
+struct arb final
+{
+public:
+    typedef _Tp                                   value_type;
+    typedef value_type&                           reference;
+    typedef const value_type&                     const_reference;
+    typedef value_type*                           iterator;
+    typedef const value_type*                     const_iterator;
+    typedef value_type*                           pointer;
+    typedef const value_type*                     const_pointer;
+    typedef __SIZE_TYPE__                         size_type;
+    typedef __PTRDIFF_TYPE__                      difference_type;
+
+public:
+    arb(arb&&) = delete;
+    arb(const arb&) = delete;
+    arb& operator=(const arb&) = delete;
+
+private:
+    value_type *            __base_;
+    size_type               __size_;
+
+private:
+    arb(pointer __p, size_type __s) noexcept : __base_(__p), __size_(__s) {}
+
+public:
+    inline iterator       begin()        noexcept { return iterator(data()); }
+    inline const_iterator begin()  const noexcept { return const_iterator(data()); }
+    inline const_iterator cbegin() const noexcept { return const_iterator(data()); }
+    inline iterator       end()          noexcept { return iterator(data() + __size_); }
+    inline const_iterator end()    const noexcept { return const_iterator(data() + __size_); }
+    inline const_iterator cend()   const noexcept { return const_iterator(data() + __size_); }
+
+    inline size_type size()     const noexcept { return __size_; }
+    inline size_type max_size() const noexcept { return __size_; }
+    inline bool      empty()    const noexcept { return __size_ == 0; }
+
+    inline reference       operator[](size_type __n)       { return data()[__n]; }
+    inline const_reference operator[](size_type __n) const { return data()[__n]; }
+
+    inline reference       front()       { return data()[0]; }
+    inline const_reference front() const { return data()[0]; }
+    inline reference       back()        { return data()[__size_-1]; }
+    inline const_reference back()  const { return data()[__size_-1]; }
+
+    inline _Tp*       data()       noexcept { return __base_; }
+    inline const _Tp* data() const noexcept { return __base_; }
+
+    inline operator _Tp*()             noexcept { return data(); }
+    inline operator const _Tp*() const noexcept { return data(); }
+};
+
+}}
+
+#endif // _ARB
+

lib/Parse/ParseDecl.cpp

if (FRI && (Tok.is(tok::colon) || isTokIdentifier_in())) {
     if (IsForRangeLoop)
       Actions.ActOnCXXForRangeDecl(ThisDecl);
     Actions.FinalizeDeclaration(ThisDecl);
     D.complete(ThisDecl);
     return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, ThisDecl);
   }
 
   SmallVector<Decl *, 8> DeclsInGroup;
+  Decl *AuxDecl = nullptr;
   Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(
-      D, ParsedTemplateInfo(), FRI);
+      D, AuxDecl, ParsedTemplateInfo(), FRI);
   if (LateParsedAttrs.size() > 0)
     ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
   D.complete(FirstDecl);
+  if (AuxDecl)
+    DeclsInGroup.push_back(AuxDecl);
   if (FirstDecl)
     DeclsInGroup.push_back(FirstDecl);
 
   bool ExpectSemi = Context != Declarator::ForContext;
   
   // If we don't have a comma, it is either the end of the list (a ';') or an
   // error, bail out.
   SourceLocation CommaLoc;
while (TryConsumeToken(tok::comma, CommaLoc)) {
     MaybeParseGNUAttributes(D);
 
     // MSVC parses but ignores qualifiers after the comma as an extension.
     if (getLangOpts().MicrosoftExt)
       DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
 
     ParseDeclarator(D);
     if (!D.isInvalidType()) {
-      Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
+      Decl *AuxDecl = nullptr;
+      Decl *ThisDecl = ParseDeclarationAfterDeclarator(D, AuxDecl);
       D.complete(ThisDecl);
+      if (AuxDecl)
+        DeclsInGroup.push_back(AuxDecl);
       if (ThisDecl)
         DeclsInGroup.push_back(ThisDecl);
     }
   }
 
   if (DeclEnd)
     *DeclEnd = Tok.getLocation();
 

 /// [C++0x] '=' 'default'                                                [TODO]
 /// [C++0x] '=' 'delete'
 /// [C++0x] braced-init-list
 ///
 /// According to the standard grammar, =default and =delete are function
 /// definitions, but that definitely doesn't fit with the parser here.
 ///
 Decl *Parser::ParseDeclarationAfterDeclarator(
-    Declarator &D, const ParsedTemplateInfo &TemplateInfo) {
+    Declarator &D, Decl *&AuxDecl, const ParsedTemplateInfo &TemplateInfo) {
   if (ParseAsmAttributesAfterDeclarator(D))
     return nullptr;
 
-  return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
+  return ParseDeclarationAfterDeclaratorAndAttributes(D, AuxDecl, TemplateInfo);
 }
 
 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
-    Declarator &D, const ParsedTemplateInfo &TemplateInfo, ForRangeInit *FRI) {
+    Declarator &D, Decl *&AuxDecl, const ParsedTemplateInfo &TemplateInfo,
+    ForRangeInit *FRI) {
   // Inform the current actions module that we just parsed this declarator.
   Decl *ThisDecl = nullptr;
   switch (TemplateInfo.Kind) {
   case ParsedTemplateInfo::NonTemplate:
-    ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
+    ThisDecl = Actions.ActOnDeclarator(getCurScope(), D, AuxDecl);
     break;
 
   case ParsedTemplateInfo::Template:
   case ParsedTemplateInfo::ExplicitSpecialization: {
     ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
                                                *TemplateInfo.TemplateParams,
                                                D);
     if (VarTemplateDecl *VT = dyn_cast_or_null<VarTemplateDecl>(ThisDecl))
if (isTokenEqualOrEqualTypo()) {
     }
 
     if (Init.isInvalid()) {
       Actions.ActOnInitializerError(ThisDecl);
     } else
       Actions.AddInitializerToDecl(ThisDecl, Init.get(),
                                    /*DirectInit=*/true, TypeContainsAuto);
 
-  } else {
+  } else if (!(ThisDecl && isa<VarDecl>(ThisDecl) &&
+               cast<VarDecl>(ThisDecl)->hasInit())) {
+    // Sema might have added an implicit initializer, but if not, this is an
+    // uninitialized decl.
     Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto);
   }
 
   Actions.FinalizeDeclaration(ThisDecl);
 
   return ThisDecl;
 }
 

lib/Parse/ParseTemplate.cpp

if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
             &LateParsedAttrs);
       }
     }
     return ParseFunctionDefinition(DeclaratorInfo, TemplateInfo,
                                    &LateParsedAttrs);
   }
 
   // Parse this declaration.
-  Decl *ThisDecl = ParseDeclarationAfterDeclarator(DeclaratorInfo,
+  Decl *AuxDecl = nullptr;
+  Decl *ThisDecl = ParseDeclarationAfterDeclarator(DeclaratorInfo, AuxDecl,
                                                    TemplateInfo);
+  assert(!AuxDecl && "Should not have an aux decl here!");
 
   if (Tok.is(tok::comma)) {
     Diag(Tok, diag::err_multiple_template_declarators)
       << (int)TemplateInfo.Kind;
     SkipUntil(tok::semi);
     return ThisDecl;
   }
 

lib/Sema/JumpDiagnostics.cpp

if (S.Context.getLangOpts().CPlusPlus && VD->hasLocalStorage() && Init) {
       InDiag = diag::note_protected_by_variable_init;
 
       // For a variable of (array of) class type declared without an
       // initializer, we will have call-style initialization and the initializer
       // will be the CXXConstructExpr with no intervening nodes.
       if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
         const CXXConstructorDecl *Ctor = CCE->getConstructor();
         if (Ctor->isTrivial() && Ctor->isDefaultConstructor() &&
-            VD->getInitStyle() == VarDecl::CallInit) {
+            (VD->getInitStyle() == VarDecl::CallInit ||
+             VD->getInitStyle() == VarDecl::MagicInit)) {
           if (OutDiag)
             InDiag = diag::note_protected_by_variable_nontriv_destructor;
           else if (!Ctor->getParent()->isPOD())
             InDiag = diag::note_protected_by_variable_non_pod;
           else
             InDiag = 0;
         }
       }

lib/Sema/Sema.cpp

MSPointerToMemberRepresentationMethod(
         LangOpts.getMSPointerToMemberRepresentationMethod()),
     VtorDispModeStack(1, MSVtorDispAttr::Mode(LangOpts.VtorDispMode)),
     DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
     CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
     IsBuildingRecoveryCallExpr(false),
     ExprNeedsCleanups(false), LateTemplateParser(nullptr),
     LateTemplateParserCleanup(nullptr),
     OpaqueParser(nullptr), IdResolver(pp), StdInitializerList(nullptr),
-    CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr),
+    StdARB(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr),
     NSNumberDecl(nullptr),
     NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
     NSArrayDecl(nullptr), ArrayWithObjectsMethod(nullptr),
     NSDictionaryDecl(nullptr), DictionaryWithObjectsMethod(nullptr),
     MSAsmLabelNameCounter(0),
     GlobalNewDeleteDeclared(false),
     TUKind(TUKind),
     NumSFINAEErrors(0),

lib/Sema/SemaDecl.cpp

for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
     if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
       return true;
   }
 
   return false;
 }
 
 Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
+  Decl *AuxDecl = nullptr;
+  Decl *Result = ActOnDeclarator(S, D, AuxDecl);
+  assert(!AuxDecl && "aux decl not expected here!");
+
+  return Result;
+}
+
+Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D, Decl *&AuxDecl) {
   D.setFunctionDefinitionKind(FDK_Declaration);
-  Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
+  Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg(), AuxDecl);
 
   if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
       Dcl && Dcl->getDeclContext()->isFileContext())
     Dcl->setTopLevelDeclInObjCContainer();
 
   return Dcl;
 }
 
if (dyn_cast_or_null<DecltypeType>(
     Diag(Loc, diag::err_decltype_in_declarator)
       << SpecLoc.getTypeLoc().getSourceRange();
 
   return false;
 }
 
 NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
                                   MultiTemplateParamsArg TemplateParamLists) {
+  Decl *AuxDecl = nullptr;
+  NamedDecl *ND = HandleDeclarator(S, D, TemplateParamLists, AuxDecl);
+  assert(!AuxDecl && "aux decl not expected here");
+
+  return ND;
+}
+
+NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
+                                  MultiTemplateParamsArg TemplateParamLists,
+                                  Decl *&AuxDecl) {
   // TODO: consider using NameInfo for diagnostic.
   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
   DeclarationName Name = NameInfo.getName();
 
   // All of these full declarators require an identifier.  If it doesn't have
   // one, the ParsedFreeStandingDeclSpec action should be used.
   if (!Name) {
     if (!D.isInvalidType())  // Reject this if we think it is valid.
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
 
     New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
   } else if (R->isFunctionType()) {
     New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
                                   TemplateParamLists,
                                   AddToScope);
   } else {
     New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
-                                  AddToScope);
+                                  AddToScope, AuxDecl);
   }
 
   if (!New)
     return nullptr;
 
   // If this has an identifier and is not an invalid redeclaration or 
   // function template specialization, add it to the scope stack.
   if (New->getDeclName() && AddToScope &&
bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) {
   //
   // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
   // semantically-enclosing namespace, not a lexically-enclosing one.
   while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
     DC = DC->getParent();
   return true;
 }
 
+static ClassTemplateDecl *LookupStdARB(Sema &S, SourceLocation Loc){
+  NamespaceDecl *Std = S.getStdNamespace();
+  if (!Std) {
+    S.Diag(Loc, diag::err_implied_std_arb_not_found);
+    return nullptr;
+  }
+
+  LookupResult Result(S, &S.PP.getIdentifierTable().get("arb"),
+                      Loc, Sema::LookupOrdinaryName);
+  if (!S.LookupQualifiedName(Result, Std)) {
+    S.Diag(Loc, diag::err_implied_std_arb_not_found);
+    return nullptr;
+  }
+  ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
+  if (!Template) {
+    Result.suppressDiagnostics();
+    // We found something weird. Complain about the first thing we found.
+    NamedDecl *Found = *Result.begin();
+    S.Diag(Found->getLocation(), diag::err_malformed_std_arb);
+    return nullptr;
+  }
+
+  // We found some template called std::arb. Now verify that it's
+  // correct.
+  TemplateParameterList *Params = Template->getTemplateParameters();
+  if (Params->getMinRequiredArguments() != 1 ||
+      !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
+    S.Diag(Template->getLocation(), diag::err_malformed_std_arb);
+    return nullptr;
+  }
+
+  return Template;
+}
+
+QualType Sema::BuildStdARB(QualType Element, SourceLocation Loc) {
+  if (!StdARB) {
+    StdARB = LookupStdARB(*this, Loc);
+    if (!StdARB)
+      return QualType();
+  }
+
+  TemplateArgumentListInfo Args(Loc, Loc);
+  Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
+                                       Context.getTrivialTypeSourceInfo(Element,
+                                                                        Loc)));
+  return Context.getCanonicalType(
+      CheckTemplateIdType(TemplateName(StdARB), Loc, Args));
+}
+
 NamedDecl *
 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
                               TypeSourceInfo *TInfo, LookupResult &Previous,
                               MultiTemplateParamsArg TemplateParamLists,
-                              bool &AddToScope) {
+                              bool &AddToScope, Decl *&AuxDecl) {
   QualType R = TInfo->getType();
   DeclarationName Name = GetNameForDeclarator(D).getName();
 
   DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
   StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
 
   // dllimport globals without explicit storage class are treated as extern. We
   // have to change the storage class this early to get the right DeclContext.
if (IsVariableTemplateSpecialization) {
               : SourceLocation();
       DeclResult Res = ActOnVarTemplateSpecialization(
           S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
           IsPartialSpecialization);
       if (Res.isInvalid())
         return nullptr;
       NewVD = cast<VarDecl>(Res.get());
       AddToScope = false;
+    } else if (getLangOpts().FancyARBs && R->isVariableArrayType()) {
+      // If we're using fancy ARBs, create a std::arb object for an ARB instead
+      // of a VLA.
+      const VariableArrayType *VAT = Context.getAsVariableArrayType(R);
+      QualType ARBTy = BuildStdARB(VAT->getElementType(), D.getLocStart());
+      if (!ARBTy.isNull()) {
+        // To get the pointer, we'll create an underlying VLA (this VLA will
+        // actually own the memory and be responsible for managing the lifetime
+        // of the contained objects).
+        UnqualifiedId ARBName;
+        ARBName.setIdentifier(PP.getIdentifierInfo(Name.getAsString() + ".ARB"),
+                              D.getIdentifierLoc());
+        VarDecl *ARBVD =
+          VarDecl::Create(Context, DC, D.getLocStart(), D.getIdentifierLoc(),
+                          PP.getIdentifierInfo(Name.getAsString() + ".ARB"),
+                          R, TInfo, SC);
+        ARBVD->setImplicit();
+        ActOnUninitializedDecl(ARBVD,
+                               D.getDeclSpec().containsPlaceholderType());
+        FinalizeDeclaration(ARBVD);
+
+        ARBVD->setReferenced();
+        ARBVD->markUsed(Context);
+
+        // This must also be attached to the parent group.
+        AuxDecl = ARBVD;
+
+        ExprResult ARBExpRef = BuildDeclRefExpr(ARBVD, R, VK_LValue,
+                                                D.getIdentifierLoc(),
+                                                &D.getCXXScopeSpec());
+
+        R = ARBTy;
+        TInfo = Context.getTrivialTypeSourceInfo(R);
+
+        NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
+                                D.getIdentifierLoc(), II, R, TInfo, SC);
+
+        // We're going to call a private constructor of std::arb.
+        NewVD->setInitStyle(VarDecl::MagicInit);
+
+        Expr *NumElementsExpr = VAT->getSizeExpr();
+
+        // We need to pass to the constructor a pointer to the allocated memory
+        // and the number of allocated elements.
+        SmallVector<Expr*, 2> Exprs(1, ARBExpRef.get());
+
+        // The second parameter is the size.
+        Exprs.push_back(NumElementsExpr);
+
+        ExprResult Initializer =
+          ActOnParenListExpr(D.getLocStart(), SourceLocation(), Exprs);
+        AddInitializerToDecl(NewVD, Initializer.get(), /*DirectInit=*/true,
+                             D.getDeclSpec().containsPlaceholderType());
+      } else
+        NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
+                                D.getIdentifierLoc(), II, R, TInfo, SC);
     } else
       NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
                               D.getIdentifierLoc(), II, R, TInfo, SC);
 
     // If this is supposed to be a variable template, create it as such.
     if (IsVariableTemplate) {
       NewTemplate =
           VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name,
for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
       } else if (Res.get() != Args[Idx]) {
         Args[Idx] = Res.get();
       }
     }
     if (VDecl->isInvalidDecl())
       return;
 
     InitializationSequence InitSeq(*this, Entity, Kind, Args);
-    ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
+    bool NoAccessCheck = VDecl->getInitStyle() == VarDecl::MagicInit;
+    ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT,
+                                        NoAccessCheck);
     if (Result.isInvalid()) {
       VDecl->setInvalidDecl();
       return;
     }
 
     Init = Result.getAs<Expr>();
   }
 

lib/Sema/SemaInit.cpp

 PerformConstructorInitialization(Sema &S,
                                  const InitializedEntity &Entity,
                                  const InitializationKind &Kind,
                                  MultiExprArg Args,
                                  const InitializationSequence::Step& Step,
                                  bool &ConstructorInitRequiresZeroInit,
                                  bool IsListInitialization,
                                  bool IsStdInitListInitialization,
+                                 bool NoAccessCheck,
                                  SourceLocation LBraceLoc,
                                  SourceLocation RBraceLoc) {
   unsigned NumArgs = Args.size();
   CXXConstructorDecl *Constructor
     = cast<CXXConstructorDecl>(Step.Function.Function);
   bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
 
   // Build a call to the selected constructor.
else
                                         ConstructorInitRequiresZeroInit,
                                         ConstructKind,
                                         ParenOrBraceRange);
   }
   if (CurInit.isInvalid())
     return ExprError();
 
   // Only check access if all of that succeeded.
+  if (!NoAccessCheck)
     S.CheckConstructorAccess(Loc, Constructor, Entity,
                              Step.Function.FoundDecl.getAccess());
   if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
     return ExprError();
 
   if (shouldBindAsTemporary(Entity))
     CurInit = S.MaybeBindToTemporary(CurInit.get());
 
   return CurInit;
 }
S.Diag(CE->getLocStart(), diag::note_remove_move)
       << FixItHint::CreateRemoval(SourceRange(RParen, RParen));
 }
 
 ExprResult
 InitializationSequence::Perform(Sema &S,
                                 const InitializedEntity &Entity,
                                 const InitializationKind &Kind,
                                 MultiExprArg Args,
-                                QualType *ResultType) {
+                                QualType *ResultType, bool NoAccessCheck) {
   if (Failed()) {
     Diagnose(S, Entity, Kind, Args);
     return ExprError();
   }
   if (!ZeroInitializationFixit.empty()) {
     unsigned DiagID = diag::err_default_init_const;
     if (Decl *D = Entity.getDecl())
       if (S.getLangOpts().MSVCCompat && D->hasAttr<SelectAnyAttr>())
case SK_ConstructorInitializationFromList: {
         << InitList->getSourceRange();
       MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
       CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
                                                                    Entity,
                                                  Kind, Arg, *Step,
                                                ConstructorInitRequiresZeroInit,
                                                /*IsListInitialization*/true,
                                                /*IsStdInitListInit*/false,
+                                               NoAccessCheck,
                                                InitList->getLBraceLoc(),
                                                InitList->getRBraceLoc());
       break;
     }
 
     case SK_UnwrapInitList:
       CurInit = cast<InitListExpr>(CurInit.get())->getInit(0);
       break;
case SK_StdInitializerListConstructorCall: {
       bool UseTemporary = Entity.getType()->isReferenceType();
       bool IsStdInitListInit =
           Step->Kind == SK_StdInitializerListConstructorCall;
       CurInit = PerformConstructorInitialization(
           S, UseTemporary ? TempEntity : Entity, Kind, Args, *Step,
           ConstructorInitRequiresZeroInit,
           /*IsListInitialization*/IsStdInitListInit,
           /*IsStdInitListInitialization*/IsStdInitListInit,
+          /*NoAccessCheck*/NoAccessCheck,
           /*LBraceLoc*/SourceLocation(),
           /*RBraceLoc*/SourceLocation());
       break;
     }
 
     case SK_ZeroInitialization: {
       step_iterator NextStep = Step;
       ++NextStep;

lib/Sema/SemaTemplateInstantiateDecl.cpp

if (OldVar->getInit()) {
     if (Var->isStaticDataMember() && !OldVar->isOutOfLine())
       PushExpressionEvaluationContext(Sema::ConstantEvaluated, OldVar);
     else
       PushExpressionEvaluationContext(Sema::PotentiallyEvaluated, OldVar);
 
     // Instantiate the initializer.
     ExprResult Init =
         SubstInitializer(OldVar->getInit(), TemplateArgs,
-                         OldVar->getInitStyle() == VarDecl::CallInit);
+                         OldVar->getInitStyle() == VarDecl::CallInit ||
+                         OldVar->getInitStyle() == VarDecl::MagicInit);
     if (!Init.isInvalid()) {
       bool TypeMayContainAuto = true;
       Expr *InitExpr = Init.get();
 
       if (Var->hasAttr<DLLImportAttr>() &&
           (!InitExpr ||
            !InitExpr->isConstantInitializer(getASTContext(), false))) {
         // Do not dynamically initialize dllimport variables.

lib/Sema/TreeTransform.h

for (LambdaExpr::capture_iterator C = E->capture_begin(),
                                     CEnd = E->capture_end();
        C != CEnd; ++C) {
     if (!E->isInitCapture(C))
       continue;
     EnterExpressionEvaluationContext EEEC(getSema(),
                                           Sema::PotentiallyEvaluated);
     ExprResult NewExprInitResult = getDerived().TransformInitializer(
         C->getCapturedVar()->getInit(),
-        C->getCapturedVar()->getInitStyle() == VarDecl::CallInit);
+        C->getCapturedVar()->getInitStyle() == VarDecl::CallInit ||
+        C->getCapturedVar()->getInitStyle() == VarDecl::MagicInit);
 
     if (NewExprInitResult.isInvalid())
       return ExprError();
     Expr *NewExprInit = NewExprInitResult.get();
 
     VarDecl *OldVD = C->getCapturedVar();
     QualType NewInitCaptureType =
         getSema().performLambdaInitCaptureInitialization(C->getLocation(),

test/CodeGen/fancy-arbs.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -std=c++14 -ffancy-arbs -emit-llvm -o - %s | FileCheck %s
+
+void bar(int *) {
+}
+
+template <typename T>
+int car(const T& c) {
+  return c.size();
+}
+
+void foo(int n) {
+  int q[n];
+  bar(q);
+  car(q);
+
+// CHECK-LABEL: define void @_Z3fooi
+// CHECK: [[ARB:%[0-9a-z]+]] = alloca %"struct.std::__clang_arb_v1::arb"
+// CHECK: [[VLA:%[0-9a-z]+]] = alloca i32, i64 %{{.*}}
+// CHECK: call void @_ZNSt14__clang_arb_v13arbIiEC1EPim(%"struct.std::__clang_arb_v1::arb"* [[ARB]], i32* [[VLA]]
+// CHECK: [[ARBP:%[0-9a-z]+]] = call i32* @_ZNSt14__clang_arb_v13arbIiEcvPiEv(%"struct.std::__clang_arb_v1::arb"* [[ARB]])
+// CHECK: call void @_Z3barPi(i32* [[ARBP]])
+// CHECK: call{{.*}} @_Z3carINSt14__clang_arb_v13arbIiEEEiRKT_(%"struct.std::__clang_arb_v1::arb"* dereferenceable({{[0-9]+}}) [[ARB]]
+}
+
+template <typename T>
+void too(int n) {
+  T q[n];
+  bar(q);
+  car(q);
+}
+
+// CHECK-LABEL: define linkonce_odr void @_Z3tooIiEvi
+// CHECK: [[ARB:%[0-9a-z]+]] = alloca %"struct.std::__clang_arb_v1::arb"
+// CHECK: [[VLA:%[0-9a-z]+]] = alloca i32, i64 %{{.*}}
+// CHECK: call void @_ZNSt14__clang_arb_v13arbIiEC1EPim(%"struct.std::__clang_arb_v1::arb"* [[ARB]], i32* [[VLA]]
+// CHECK: [[ARBP:%[0-9a-z]+]] = call i32* @_ZNSt14__clang_arb_v13arbIiEcvPiEv(%"struct.std::__clang_arb_v1::arb"* [[ARB]])
+// CHECK: call void @_Z3barPi(i32* [[ARBP]])
+// CHECK: call{{.*}} @_Z3carINSt14__clang_arb_v13arbIiEEEiRKT_(%"struct.std::__clang_arb_v1::arb"* dereferenceable({{[0-9]+}}) [[ARB]]
+
+void hello(int size) {
+  foo(size);
+  too<int>(size);
+}
+