28 #include "clang/Sema/Initialization.h"
46 // Sema Initialization Checking
72 /// expression by means of string initialization. Returns SIF_None if so,
74 /// initialization would not work.
154     assert(false && "Unevaluated string literal in initialization");  in IsStringInit()
280 /// handle the initialization of a certain kind of entity, e.g.,
299 /// because they make the initialization "jump" into a specific
300 /// subobject and then continue the initialization from that
585     // does not have useful semantics for initialization from an init list.  in PerformEmptyInit()
586     // We treat this as copy-initialization, because aggregate initialization  in PerformEmptyInit()
587     // always performs copy-initialization on its elements.  in PerformEmptyInit()
796       // Empty initialization requires a constructor call, so  in FillInEmptyInitForField()
816 /// with expressions that perform value-initialization of the
849   // A transparent ILE is not performing aggregate initialization and should  in FillInEmptyInitializations()
899         // Only look at the first initialization of a union.  in FillInEmptyInitializations()
947       // In VerifyOnly mode, there's no point performing empty initialization  in FillInEmptyInitializations()
972         // For arrays, just set the expression used for value-initialization  in FillInEmptyInitializations()
979         // For arrays, just set the expression used for value-initialization  in FillInEmptyInitializations()
987           // Empty initialization requires a constructor call, so  in FillInEmptyInitializations()
1081 /// the braces in aggregate initialization.
1083   // Recursive initialization of the one and only field within an aggregate  in isIdiomaticBraceElisionEntity()
1085   // initialization of std::array, where the C++ standard suggests the idiom of  in isIdiomaticBraceElisionEntity()
1094   // Allows elide brace initialization for aggregates with empty base.  in isIdiomaticBraceElisionEntity()
1125 /// onwards, with the fully-braced, desugared form of the initialization.
1207   // Don't warn during template instantiation. If the initialization was  in warnBracedScalarInit()
1229     // Warn on aggregate initialization but not on ctor init list or  in warnBracedScalarInit()
1237     // No warning, might be direct-list-initialization.  in warnBracedScalarInit()
1238     // FIXME: Should we warn for copy-list-initialization in these cases?  in warnBracedScalarInit()
1273 /// form of the initialization.
1451     // Nested aggregate initialization and C++ initialization are handled later.  in CheckSubElementType()
1456            "found implicit initialization for the wrong type");  in CheckSubElementType()
1472     // we need initialization entity with a type of a vector (and not a vector  in CheckSubElementType()
1539     // Fall through for subaggregate initialization  in CheckSubElementType()
1562     // Fall through for subaggregate initialization.  in CheckSubElementType()
1592     // Fall through for subaggregate initialization  in CheckSubElementType()
1599   //   considered for the initialization of the first member of  in CheckSubElementType()
1625       // initialization will fail.  in CheckSubElementType()
1631              "expected non-aggregate initialization to fail");  in CheckSubElementType()
1976 /// Aggregate initialization requires a class element's destructor be
1980 /// (15.4 [class.dtor]) from the context where the aggregate initialization
2695     // C++20 designated initialization can result in direct-list-initialization  in CheckDesignatedInitializer()
2697     // performing direct initialization as part of aggregate initialization, so  in CheckDesignatedInitializer()
2702              "designator result in direct non-list initialization?");  in CheckDesignatedInitializer()
2720     // Check the actual initialization for the designated object type.  in CheckDesignatedInitializer()
2763         // initialization that completely initialized the current  in CheckDesignatedInitializer()
2954     // initialization, only on actually performing initialization,  in CheckDesignatedInitializer()
3345     // initialization that completely initialized the current  in getStructuredSubobjectInit()
3353     // from the prior initialization.  in getStructuredSubobjectInit()
3555 // Initialization entity
3747 // Initialization sequence
4114 // Attempt initialization
4175 /// initialization of an object of type std::initializer_list<T>.
4177 /// \return true if we have handled initialization of an object of type
4249     //     of a class copy-initialization, or  in ResolveConstructorOverload()
4271       //     argument in the context of direct-initialization, explicit  in ResolveConstructorOverload()
4287   // ([over.match.ctor]) or by list-initialization ([over.match.list])  in ResolveConstructorOverload()
4291   // direct-initialization.  in ResolveConstructorOverload()
4331 /// Attempt initialization by constructor (C++ [dcl.init]), which
4337 /// \param IsListInit     Is this list-initialization?
4338 /// \param IsInitListCopy Is this non-list-initialization resulting from a
4339 ///                       list-initialization from {x} where x is the same
4390   assert(DestRecordType && "Constructor initialization requires record type");  in TryConstructorInitialization()
4394   // Build the candidate set directly in the initialization sequence  in TryConstructorInitialization()
4476     //   If a program calls for the default initialization of an object  in TryConstructorInitialization()
4494     //   In copy-list-initialization, if an explicit constructor is chosen, the  in TryConstructorInitialization()
4503   // In some copy-initialization contexts, a two-stage overload resolution  in TryConstructorInitialization()
4506   // need the initialization sequence to decide whether to perform the second  in TryConstructorInitialization()
4509   // initialization sequence.  in TryConstructorInitialization()
4513   // Add the constructor initialization step. Any cv-qualification conversion is  in TryConstructorInitialization()
4514   // subsumed by the initialization.  in TryConstructorInitialization()
4565 /// Attempt list initialization of a reference.
4588   // Reference initialization via an initializer list works thus:  in TryReferenceListInitialization()
4650         // List-initialization of an object or reference of type T is defined as  in TryReferenceListInitialization()
4668 /// Attempt list initialization (C++0x [dcl.init.list])
4677   // C++ doesn't allow scalar initialization with more than one argument.  in TryListInitialization()
4698   //   be an aggregate class. [...] Aggregate initialization is performed.  in TryListInitialization()
4702   // FIXME: This check should precede the handling of reference initialization.  in TryListInitialization()
4715   //   initialized from that element (by copy-initialization for  in TryListInitialization()
4716   //   copy-list-initialization, or by direct-initialization for  in TryListInitialization()
4717   //   direct-list-initialization).  in TryListInitialization()
4720   //   (8.5.2 [dcl.init.string]), initialization is performed as described  in TryListInitialization()
4763   //   - If T is an aggregate, aggregate initialization is performed.  in TryListInitialization()
4799     //     the initializer-list has a single element v, and the initialization  in TryListInitialization()
4800     //     is direct-list-initialization, the object is initialized with the  in TryListInitialization()
4841     //     initialized from that element (by copy-initialization for  in TryListInitialization()
4842     //     copy-list-initialization, or by direct-initialization for  in TryListInitialization()
4843     //     direct-list-initialization); if a narrowing conversion is required  in TryListInitialization()
4846     // Per core-24034, this is direct-initialization if we were performing  in TryListInitialization()
4847     // direct-list-initialization and copy-initialization otherwise.  in TryListInitialization()
4849     // copy-initialization. This only matters if we might use an 'explicit'  in TryListInitialization()
4880   // Add the list initialization step with the built init list.  in TryListInitialization()
4884 /// Try a reference initialization that involves calling a conversion
4899   // Build the candidate set directly in the initialization sequence  in TryRefInitWithConversionFunction()
4907   // initializing a reference, not even for direct-initialization.  in TryRefInitWithConversionFunction()
4995   // This is the overload that will be used for this initialization step if we  in TryRefInitWithConversionFunction()
4996   // use this initialization. Mark it as referenced.  in TryRefInitWithConversionFunction()
5070 /// Attempt reference initialization (C++0x [dcl.init.ref])
5105 /// Reference initialization without resolving overloaded functions.
5354   //        copy-initialization (8.5). The reference is then bound to the  in TryReferenceInitializationCore()
5368   // copy-initialization?  in TryReferenceInitializationCore()
5431 /// Attempt character array initialization from a string literal
5441 /// Attempt value initialization (C++ [dcl.init]p7).
5464       //    initialization is ill-formed if T has no accessible default  in TryValueInitialization()
5490       // [...] A program that calls for [...] value-initialization of an  in TryValueInitialization()
5493       // C++11 doesn't need this handling, because value-initialization does not  in TryValueInitialization()
5502       // If this is list-value-initialization, pass the empty init list on when  in TryValueInitialization()
5519 /// Attempt default initialization (C++ [dcl.init]p6).
5532   //       constructor for T is called (and the initialization is ill-formed if  in TryDefaultInitialization()
5540   //     - otherwise, no initialization is performed.  in TryDefaultInitialization()
5542   //   If a program calls for the default initialization of an object of  in TryDefaultInitialization()
5615       // Braced-initialization of variable array types is not allowed, even if  in TryOrBuildParenListInitialization()
5617       // allow them to be initialized via parenthesized aggregate initialization  in TryOrBuildParenListInitialization()
5659       // We do the same for braced list initialization in  in TryOrBuildParenListInitialization()
5825   // Build the candidate set directly in the initialization sequence  in TryUserDefinedConversion()
5913     // In some copy-initialization contexts, a two-stage overload resolution  in TryUserDefinedConversion()
5916     // need the initialization sequence to decide whether to perform the second  in TryUserDefinedConversion()
5929     // subsumed by the initialization. Per DR5, the created temporary is of the  in TryUserDefinedConversion()
5940     //     copy-initialization.  in TryUserDefinedConversion()
5948     //     is the destination of the copy-initialization.  in TryUserDefinedConversion()
5966     //   destination of the copy-initialization.  in TryUserDefinedConversion()
6100 /// purposes of GNU by-copy array initialization.
6205   // We should allow zero initialization for all types defined in the  in TryOCLZeroOpaqueTypeInitialization()
6373   // Handle default initialization.  in InitializeFrom()
6385   //       non-array types for initialization.  in InitializeFrom()
6418     // Some kinds of initialization permit an array to be initialized from  in InitializeFrom()
6419     // another array of the same type, and perform elementwise initialization.  in InitializeFrom()
6446     // Note: as an GNU C extension, we allow initialization of an  in InitializeFrom()
6462     // Note: as a GNU C++ extension, we allow list-initialization of a  in InitializeFrom()
6505     // Handle initialization in C  in InitializeFrom()
6515     //     - If the initialization is direct-initialization, or if it is  in InitializeFrom()
6516     //       copy-initialization where the cv-unqualified version of the  in InitializeFrom()
6538         // Do not attempt paren list initialization if overload resolution  in InitializeFrom()
6544         // is implicitly deleted, so we need to prevent aggregate initialization  in InitializeFrom()
6545         // (otherwise, it'll attempt aggregate initialization by initializing  in InitializeFrom()
6561       //     - Otherwise (i.e., for the remaining copy-initialization cases),  in InitializeFrom()
6576   // For HLSL ext vector types we allow list initialization behavior for C++  in InitializeFrom()
6577   // constructor syntax. This is accomplished by converting initialization  in InitializeFrom()
6640   //    - Otherwise, if the initialization is direct-initialization, the source  in InitializeFrom()
6715 // Perform initialization
6751     // This is really initialization, but refer to it as conversion for  in getAssignmentAction()
6806 /// created for that initialization, requires destruction.
6839 /// Get the location at which initialization diagnostics should appear.
6920   // C++11 [dcl.init]p16, second bullet for class types, this initialization  in CopyObject()
6921   // is direct-initialization.  in CopyObject()
6976     // binding purposes, just return the original initialization  in CopyObject()
7020   // of constructor initialization, while copy elision for exception handlers  in CopyObject()
7123 /// Returns true if the parameters describe a constructor initialization of
7190   //     context of direct-initialization, explicit conversion functions  in PerformConstructorInitialization()
7248     // Only get the parenthesis or brace range if it is a list initialization or  in PerformConstructorInitialization()
7496     // The initialization would have succeeded with this fixit. Since the fixit  in Perform()
7569   // No steps means no initialization.  in Perform()
7618   // HLSL allows vector initialization to function like list initialization, but  in Perform()
7624   // For initialization steps that start with a single initializer,  in Perform()
7676   // C++11 list-initialization; we need to instantiate entities usable in  in Perform()
7693   // Walk through the computed steps for the initialization sequence,  in Perform()
7805       // If the overall initialization is initializing a temporary, we already  in Perform()
8094         // The need for zero-initialization is recorded directly into  in Perform()
8324       // Sampler initialization have 5 cases:  in Perform()
8329       //   2. variable initialization  in Perform()
8340              "Sampler initialization on non-sampler type.");  in Perform()
8419              "Wrong type for initialization of OpenCL opaque type.");  in Perform()
8447   // Diagnose non-fatal problems with the completed initialization.  in Perform()
8498 // Diagnose initialization failures
8501 /// Emit notes associated with an initialization that failed due to a
8551     // A list-initialization failure for a reference means that we tried to  in diagnoseListInit()
8553     // inner initialization failed.  in diagnoseListInit()
8608       // If this is value-initialization, this could be nested some way within  in Diagnose()
8919           // This is implicit default initialization of a member or  in Diagnose()
9007       // This is implicit default-initialization of a const member in  in Diagnose()
9138       OS << "overload resolution for reference initialization failed";  in dump()
9166       OS << "reference initialization drops qualifiers";  in dump()
9174       OS << "reference initialization failed";  in dump()
9210       OS << "default initialization of a const variable";  in dump()
9214       OS << "initialization of incomplete type";  in dump()
9218       OS << "list initialization checker failure";  in dump()
9234       OS << "list copy initialization chose explicit constructor";  in dump()
9238       OS << "parenthesized list initialization failed";  in dump()
9289       OS << "final copy in class direct-initialization";  in dump()
9333       OS << "list aggregate initialization";  in dump()
9345       OS << "constructor initialization";  in dump()
9349       OS << "list initialization via constructor";  in dump()
9353       OS << "zero initialization";  in dump()
9361       OS << "string initialization";  in dump()
9369       OS << "indexing for array initialization loop";  in dump()
9373       OS << "array initialization loop";  in dump()
9377       OS << "array initialization";  in dump()
9381       OS << "array initialization (GNU extension)";  in dump()
9385       OS << "parenthesized array initialization";  in dump()
9405       OS << "list initialization from std::initializer_list";  in dump()
9416       OS << "initialization from a parenthesized list of values";  in dump()
9598 // Initialization helper functions
9607   assert(InitE && "No initialization expression");  in CanPerformCopyInitialization()
9625   assert(InitE && "No initialization expression?");  in PerformCopyInitialization()
9634   // Prevent infinite recursion when performing parameter copy-initialization.  in PerformCopyInitialization()
9764   // Figure out if this is list-initialization.  in DeduceTemplateSpecializationFromInitializer()
9771   //   Initialization and overload resolution are performed as described in  in DeduceTemplateSpecializationFromInitializer()
9773   //   (as appropriate for the type of initialization performed) for an object  in DeduceTemplateSpecializationFromInitializer()
9791     // C++ [over.match.ctor]p1: (non-list copy-initialization from non-class)  in DeduceTemplateSpecializationFromInitializer()
9792     //   For copy-initialization, the candidate functions are all the  in DeduceTemplateSpecializationFromInitializer()
9794     // C++ [over.match.copy]p1: (non-list copy-initialization from class)  in DeduceTemplateSpecializationFromInitializer()
9808     // C++ [over.match.list]p1.1: (first phase list initialization)  in DeduceTemplateSpecializationFromInitializer()
9818     // C++ [over.match.list]p1.2: (second phase list initialization)  in DeduceTemplateSpecializationFromInitializer()
9947   // C++11 [over.match.list]p1, per DR1467: for list-initialization, first  in DeduceTemplateSpecializationFromInitializer()
9983   // If list-initialization fails, or if we're doing any other kind of  in DeduceTemplateSpecializationFromInitializer()
9984   // initialization, we (eventually) consider constructors.  in DeduceTemplateSpecializationFromInitializer()
9990     // FIXME: For list-initialization candidates, it'd usually be better to  in DeduceTemplateSpecializationFromInitializer()
10028     //   In copy-list-initialization, if an explicit constructor is chosen, the  in DeduceTemplateSpecializationFromInitializer()
10029     //   initialization is ill-formed.  in DeduceTemplateSpecializationFromInitializer()