Lines Matching full:initialization
14 #include "clang/Sema/Initialization.h"
33 // Sema Initialization Checking
57 /// expression by means of string initialization. Returns SIF_None if so,
59 /// initialization would not work.
213 /// handle the initialization of a certain kind of entity, e.g.,
232 /// because they make the initialization "jump" into a specific
233 /// subobject and then continue the initialization from that
398 // does not have useful semantics for initialization from an init list.
399 // We treat this as copy-initialization, because aggregate initialization
400 // always performs copy-initialization on its elements.
594 // Empty initialization requires a constructor call, so
612 /// with expressions that perform value-initialization of the
673 // Only look at the first initialization of a union.
733 // For arrays, just set the expression used for value-initialization
740 // For arrays, just set the expression used for value-initialization
748 // Empty initialization requires a constructor call, so
821 /// onwards, with the fully-braced, desugared form of the initialization.
894 // Don't warn during template instantiation. If the initialization was
914 // Warn on aggregate initialization but not on ctor init list or
922 // No warning, might be direct-list-initialization.
923 // FIXME: Should we warn for copy-list-initialization in these cases?
955 /// form of the initialization.
1129 // C++ initialization is handled later.
1134 "found implicit initialization for the wrong type");
1173 // Fall through for subaggregate initialization
1193 // Fall through for subaggregate initialization.
1223 // Fall through for subaggregate initialization
1230 // considered for the initialization of the first member of
2054 // Check the actual initialization for the designated object type.
2123 // initialization that completely initialized the current
2620 // initialization that completely initialized the current
2852 // Initialization entity
3023 // Initialization sequence
3343 // Attempt initialization
3403 /// initialization of an object of type std::initializer_list<T>.
3405 /// \return true if we have handled initialization of an object of type
3459 // of a class copy-initialization, or
3487 // context of direct-initialization, explicit conversion functions
3504 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3507 /// \param IsListInit Is this list-initialization?
3508 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3509 /// list-initialization from {x} where x is the same
3528 assert(DestRecordType && "Constructor initialization requires record type");
3532 // Build the candidate set directly in the initialization sequence
3598 // If a program calls for the default initialization of an object
3616 // In copy-list-initialization, if an explicit constructor is chosen, the
3623 // Add the constructor initialization step. Any cv-qualification conversion is
3624 // subsumed by the initialization.
3675 /// \brief Attempt list initialization of a reference.
3698 // Reference initialization via an initializer list works thus:
3749 initialization (C++0x [dcl.init.list])
3758 // C++ doesn't allow scalar initialization with more than one argument.
3780 // initialized from that element (by copy-initialization for
3781 // copy-list-initialization, or by direct-initialization for
3782 // direct-list-initialization).
3785 // (8.5.2 [dcl.init.string]), initialization is performed as described
3826 // - If T is an aggregate, aggregate initialization is performed.
3862 // the initializer-list has a single element v, and the initialization
3863 // is direct-list-initialization, the object is initialized with the
3902 // initialized from that element (by copy-initialization for
3903 // copy-list-initialization, or by direct-initialization for
3904 // direct-list-initialization); if a narrowing conversion is required
3907 // Per core-24034, this is direct-initialization if we were performing
3908 // direct-list-initialization and copy-initialization otherwise.
3910 // copy-initialization. This only matters if we might use an 'explicit'
3937 // Add the list initialization step with the built init list.
3941 /// \brief Try a reference initialization that involves calling a conversion
3967 // Build the candidate set directly in the initialization sequence
4060 // This is the overload that will be used for this initialization step if we
4061 // use this initialization. Mark it as referenced.
4123 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
4149 /// Converts the target of reference initialization so that it has the
4199 /// \brief Reference initialization without resolving overloaded functions.
4242 // bit-field when we're determining whether the reference initialization
4379 // copy-initialization (8.5). The reference is then bound to the
4385 // copy-initialization?
4435 /// \brief Attempt character array initialization from a string literal
4445 /// \brief Attempt value initialization (C++ [dcl.init]p7).
4469 // initialization is ill-formed if T has no accessible default
4496 // [...] A program that calls for [...] value-initialization of an
4499 // C++11 doesn't need this handling, because value-initialization does not
4508 // If this is list-value-initialization, pass the empty init list on when
4523 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4536 // constructor for T is called (and the initialization is ill-formed if
4543 // - otherwise, no initialization is performed.
4545 // If a program calls for the default initialization of an object of
4575 // Build the candidate set directly in the initialization sequence
4678 // subsumed by the initialization. Per DR5, the created temporary is of the
4820 /// purposes of GNU by-copy array initialization.
5025 // Handle default initialization.
5061 // Note: as an GNU C extension, we allow initialization of an
5077 // Note: as a GNU C++ extension, we allow list-initialization of a
5115 // Handle initialization in C
5125 // - If the initialization is direct-initialization, or if it is
5126 // copy-initialization where the cv-unqualified version of the
5135 // - Otherwise (i.e., for the remaining copy-initialization cases),
5238 // Perform initialization
5315 /// created for that initialization, requires destruction.
5344 /// copying an object via direct-initialization (per C++11 [dcl.init]p16).
5387 /// \brief Get the location at which initialization diagnostics should appear.
5469 // of constructor initialization, while copy elision for exception handlers
5480 // C++0x [dcl.init]p16, second bullet to class types, this initialization
5481 // is direct-initialization.
5527 // binding purposes, just return the original initialization
5651 /// Returns true if the parameters describe a constructor initialization of
5715 // context of direct-initialization, explicit conversion functions
5768 // Only get the parenthesis or brace range if it is a list initialization or
5838 // Could not determine what the full initialization is. Assume it might not
5857 /// the initialization of \p Entity.
5913 // We can reach this case for aggregate initialization in a constructor:
6027 // This may be either aggregate-initialization of a member or
6028 // initialization of a std::initializer_list object. Either way,
6223 // The initialization would have succeeded with this fixit. Since the fixit
6285 // No steps means no initialization.
6322 // For initialization steps that start with a single initializer,
6368 // Walk through the computed steps for the initialization sequence,
6558 // FIXME: Should we move this initialization into a separate
6764 // The need for zero-initialization is recorded directly into
6908 "Sampler initialization on non-sampler type.");
6924 "Event initialization on non-event type.");
6934 // Diagnose non-fatal problems with the completed initialization.
6986 // Diagnose initialization failures
6989 /// Emit notes associated with an initialization that failed due to a
7025 // A list-initialization failure for a reference means that we tried to
7027 // inner initialization failed.
7057 // If this is value-initialization, this could be nested some way within
7299 // This is implicit default initialization of a member or
7380 // This is implicit default-initialization of a const member in
7483 OS << "overload resolution for reference initialization failed";
7499 OS << "reference initialization drops qualifiers";
7503 OS << "reference initialization failed";
7535 OS << "default initialization of a const variable";
7539 OS << "initialization of incomplete type";
7543 OS << "list initialization checker failure";
7559 OS << "list copy initialization chose explicit constructor";
7646 OS << "list aggregate initialization";
7658 OS << "constructor initialization";
7662 OS << "list initialization via constructor";
7666 OS << "zero initialization";
7674 OS << "string initialization";
7682 OS << "array initialization";
7686 OS << "parenthesized array initialization";
7706 OS << "list initialization from std::initializer_list";
7818 // Initialization helper functions
7827 assert(InitE && "No initialization expression");
7845 assert(InitE && "No initialization expression?");
