Lines Matching full:initialization
14 #include "clang/Sema/Initialization.h"
32 // Sema Initialization Checking
56 /// expression by means of string initialization. Returns SIF_None if so,
58 /// initialization would not work.
210 /// handle the initialization of a certain kind of entity, e.g.,
229 /// because they make the initialization "jump" into a specific
230 /// subobject and then continue the initialization from that
363 // does not have useful semantics for initialization from an init list.
364 // We treat this as copy-initialization, because aggregate initialization
365 // always performs copy-initialization on its elements.
505 // Empty initialization requires a constructor call, so
519 /// with expressions that perform value-initialization of the
556 // Only look at the first initialization of a union.
605 // For arrays, just set the expression used for value-initialization
612 // For arrays, just set the expression used for value-initialization
620 // Empty initialization requires a constructor call, so
682 /// onwards, with the fully-braced, desugared form of the initialization.
754 /// form of the initialization.
916 // C++ initialization is handled later.
941 // Fall through for subaggregate initialization.
969 // Fall through for subaggregate initialization
997 // Fall through for subaggregate initialization
1004 // considered for the initialization of the first member of
1827 // Check the actual initialization for the designated object type.
2352 // initialization that completely initialized the current
2575 // Initialization entity
2745 // Initialization sequence
3058 // Attempt initialization
3095 /// initialization of an object of type std::initializer_list<T>.
3097 /// \return true if we have handled initialization of an object of type
3156 // in the second step of a class copy-initialization,
3182 // context of direct-initialization, explicit conversion functions
3199 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3202 /// If InitListSyntax is true, this is list-initialization of a non-aggregate
3220 assert(DestRecordType && "Constructor initialization requires record type");
3224 // Build the candidate set directly in the initialization sequence
3291 // If a program calls for the default initialization of an object
3302 // In copy-list-initialization, if an explicit constructor is chosen, the
3310 // Add the constructor initialization step. Any cv-qualification conversion is
3311 // subsumed by the initialization.
3363 /// \brief Attempt list initialization of a reference.
3380 // Reference initialization via an initializer list works thus:
3430 /// \brief Attempt list initialization (C++0x [dcl.init.list])
3438 // C++ doesn't allow scalar initialization with more than one argument.
3456 // - If T is an aggregate, aggregate initialization is performed.
3493 // Per core-24034, this is direct-initialization if we were performing
3494 // direct-list-initialization and copy-initialization otherwise.
3496 // copy-initialization. This only matters if we might use an 'explicit'
3520 // Add the list initialization step with the built init list.
3524 /// \brief Try a reference initialization that involves calling a conversion
3550 // Build the candidate set directly in the initialization sequence
3660 // This is the overload that will be used for this initialization step if we
3661 // use this initialization. Mark it as referenced.
3723 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3749 /// Converts the target of reference initialization so that it has the
3800 /// \brief Reference initialization without resolving overloaded functions.
3843 // bit-field when we're determining whether the reference initialization
3980 // copy-initialization (8.5). The reference is then bound to the
3986 // copy-initialization?
4037 /// \brief Attempt character array initialization from a string literal
4047 /// \brief Attempt value initialization (C++ [dcl.init]p7).
4071 // initialization is ill-formed if T has no accessible default
4098 // [...] A program that calls for [...] value-initialization of an
4101 // C++11 doesn't need this handling, because value-initialization does not
4110 // If this is list-value-initialization, pass the empty init list on when
4125 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4138 // constructor for T is called (and the initialization is ill-formed if
4145 // - otherwise, no initialization is performed.
4147 // If a program calls for the default initialization of an object of
4177 // Build the candidate set directly in the initialization sequence
4290 // subsumed by the initialization. Per DR5, the created temporary is of the
4432 /// purposes of GNU by-copy array initialization.
4624 // Handle default initialization.
4660 // Note: as an GNU C extension, we allow initialization of an
4676 // Note: as a GNU C++ extension, we allow list-initialization of a
4714 // Handle initialization in C
4724 // - If the initialization is direct-initialization, or if it is
4725 // copy-initialization where the cv-unqualified version of the
4734 // - Otherwise (i.e., for the remaining copy-initialization cases),
4822 // Perform initialization
4899 /// created for that initialization, requires destruction.
4928 /// copying an object via direct-initialization (per C++11 [dcl.init]p16).
4976 /// \brief Get the location at which initialization diagnostics should appear.
5056 // of constructor initialization, while copy elision for exception handlers
5067 // C++0x [dcl.init]p16, second bullet to class types, this initialization
5068 // is direct-initialization.
5114 // binding purposes, just return the original initialization
5236 /// Returns true if the parameters describe a constructor initialization of
5299 // context of direct-initialization, explicit conversion functions
5344 // Only get the parenthesis or brace range if it is a list initialization or
5411 // Could not determine what the full initialization is. Assume it might not
5430 /// the initialization of \p Entity.
5481 // We can reach this case for aggregate initialization in a constructor:
5595 // This may be either aggregate-initialization of a member or
5596 // initialization of a std::initializer_list object. Either way,
5708 // No steps means no initialization.
5745 // For initialization steps that start with a single initializer,
5789 // Walk through the computed steps for the initialization sequence,
5985 // FIXME: Should we move this initialization into a separate
6179 // The need for zero-initialization is recorded directly into
6321 "Sampler initialization on non-sampler type.");
6337 "Event initialization on non-event type.");
6347 // Diagnose non-fatal problems with the completed initialization.
6393 // Diagnose initialization failures
6396 /// Emit notes associated with an initialization that failed due to a
6450 // If this is value-initialization, this could be nested some way within
6675 // This is implicit default initialization of a member or
6753 // This is implicit default-initialization of a const member in
6852 OS << "overload resolution for reference initialization failed";
6868 OS << "reference initialization drops qualifiers";
6872 OS << "reference initialization failed";
6904 OS << "default initialization of a const variable";
6908 OS << "initialization of incomplete type";
6912 OS << "list initialization checker failure";
6928 OS << "list copy initialization chose explicit constructor";
7011 OS << "list aggregate initialization";
7015 OS << "list initialization via constructor";
7027 OS << "constructor initialization";
7031 OS << "zero initialization";
7039 OS << "string initialization";
7047 OS << "array initialization";
7051 OS << "parenthesized array initialization";
7179 // Initialization helper functions
7188 assert(InitE && "No initialization expression");
7206 assert(InitE && "No initialization expression?");
