forked from OSchip/llvm-project
4384 lines
171 KiB
C++
4384 lines
171 KiB
C++
//===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
|
||
//
|
||
// The LLVM Compiler Infrastructure
|
||
//
|
||
// This file is distributed under the University of Illinois Open Source
|
||
// License. See LICENSE.TXT for details.
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
//
|
||
// This file implements semantic analysis for initializers. The main entry
|
||
// point is Sema::CheckInitList(), but all of the work is performed
|
||
// within the InitListChecker class.
|
||
//
|
||
// This file also implements Sema::CheckInitializerTypes.
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#include "SemaInit.h"
|
||
#include "Lookup.h"
|
||
#include "Sema.h"
|
||
#include "clang/Lex/Preprocessor.h"
|
||
#include "clang/Parse/Designator.h"
|
||
#include "clang/AST/ASTContext.h"
|
||
#include "clang/AST/ExprCXX.h"
|
||
#include "clang/AST/ExprObjC.h"
|
||
#include "clang/AST/TypeLoc.h"
|
||
#include "llvm/Support/ErrorHandling.h"
|
||
#include <map>
|
||
using namespace clang;
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Sema Initialization Checking
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
static Expr *IsStringInit(Expr *Init, QualType DeclType, ASTContext &Context) {
|
||
const ArrayType *AT = Context.getAsArrayType(DeclType);
|
||
if (!AT) return 0;
|
||
|
||
if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
|
||
return 0;
|
||
|
||
// See if this is a string literal or @encode.
|
||
Init = Init->IgnoreParens();
|
||
|
||
// Handle @encode, which is a narrow string.
|
||
if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
|
||
return Init;
|
||
|
||
// Otherwise we can only handle string literals.
|
||
StringLiteral *SL = dyn_cast<StringLiteral>(Init);
|
||
if (SL == 0) return 0;
|
||
|
||
QualType ElemTy = Context.getCanonicalType(AT->getElementType());
|
||
// char array can be initialized with a narrow string.
|
||
// Only allow char x[] = "foo"; not char x[] = L"foo";
|
||
if (!SL->isWide())
|
||
return ElemTy->isCharType() ? Init : 0;
|
||
|
||
// wchar_t array can be initialized with a wide string: C99 6.7.8p15 (with
|
||
// correction from DR343): "An array with element type compatible with a
|
||
// qualified or unqualified version of wchar_t may be initialized by a wide
|
||
// string literal, optionally enclosed in braces."
|
||
if (Context.typesAreCompatible(Context.getWCharType(),
|
||
ElemTy.getUnqualifiedType()))
|
||
return Init;
|
||
|
||
return 0;
|
||
}
|
||
|
||
static void CheckStringInit(Expr *Str, QualType &DeclT, Sema &S) {
|
||
// Get the length of the string as parsed.
|
||
uint64_t StrLength =
|
||
cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue();
|
||
|
||
|
||
const ArrayType *AT = S.Context.getAsArrayType(DeclT);
|
||
if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
|
||
// C99 6.7.8p14. We have an array of character type with unknown size
|
||
// being initialized to a string literal.
|
||
llvm::APSInt ConstVal(32);
|
||
ConstVal = StrLength;
|
||
// Return a new array type (C99 6.7.8p22).
|
||
DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
|
||
ConstVal,
|
||
ArrayType::Normal, 0);
|
||
return;
|
||
}
|
||
|
||
const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
|
||
|
||
// C99 6.7.8p14. We have an array of character type with known size. However,
|
||
// the size may be smaller or larger than the string we are initializing.
|
||
// FIXME: Avoid truncation for 64-bit length strings.
|
||
if (StrLength-1 > CAT->getSize().getZExtValue())
|
||
S.Diag(Str->getSourceRange().getBegin(),
|
||
diag::warn_initializer_string_for_char_array_too_long)
|
||
<< Str->getSourceRange();
|
||
|
||
// Set the type to the actual size that we are initializing. If we have
|
||
// something like:
|
||
// char x[1] = "foo";
|
||
// then this will set the string literal's type to char[1].
|
||
Str->setType(DeclT);
|
||
}
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Semantic checking for initializer lists.
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
/// @brief Semantic checking for initializer lists.
|
||
///
|
||
/// The InitListChecker class contains a set of routines that each
|
||
/// handle the initialization of a certain kind of entity, e.g.,
|
||
/// arrays, vectors, struct/union types, scalars, etc. The
|
||
/// InitListChecker itself performs a recursive walk of the subobject
|
||
/// structure of the type to be initialized, while stepping through
|
||
/// the initializer list one element at a time. The IList and Index
|
||
/// parameters to each of the Check* routines contain the active
|
||
/// (syntactic) initializer list and the index into that initializer
|
||
/// list that represents the current initializer. Each routine is
|
||
/// responsible for moving that Index forward as it consumes elements.
|
||
///
|
||
/// Each Check* routine also has a StructuredList/StructuredIndex
|
||
/// arguments, which contains the current the "structured" (semantic)
|
||
/// initializer list and the index into that initializer list where we
|
||
/// are copying initializers as we map them over to the semantic
|
||
/// list. Once we have completed our recursive walk of the subobject
|
||
/// structure, we will have constructed a full semantic initializer
|
||
/// list.
|
||
///
|
||
/// C99 designators cause changes in the initializer list traversal,
|
||
/// because they make the initialization "jump" into a specific
|
||
/// subobject and then continue the initialization from that
|
||
/// point. CheckDesignatedInitializer() recursively steps into the
|
||
/// designated subobject and manages backing out the recursion to
|
||
/// initialize the subobjects after the one designated.
|
||
namespace {
|
||
class InitListChecker {
|
||
Sema &SemaRef;
|
||
bool hadError;
|
||
std::map<InitListExpr *, InitListExpr *> SyntacticToSemantic;
|
||
InitListExpr *FullyStructuredList;
|
||
|
||
void CheckImplicitInitList(const InitializedEntity &Entity,
|
||
InitListExpr *ParentIList, QualType T,
|
||
unsigned &Index, InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject = false);
|
||
void CheckExplicitInitList(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType &T,
|
||
unsigned &Index, InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject = false);
|
||
void CheckListElementTypes(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType &DeclType,
|
||
bool SubobjectIsDesignatorContext,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject = false);
|
||
void CheckSubElementType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType ElemType,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex);
|
||
void CheckScalarType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType DeclType,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex);
|
||
void CheckReferenceType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType DeclType,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex);
|
||
void CheckVectorType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType DeclType, unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex);
|
||
void CheckStructUnionTypes(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType DeclType,
|
||
RecordDecl::field_iterator Field,
|
||
bool SubobjectIsDesignatorContext, unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject = false);
|
||
void CheckArrayType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType &DeclType,
|
||
llvm::APSInt elementIndex,
|
||
bool SubobjectIsDesignatorContext, unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex);
|
||
bool CheckDesignatedInitializer(const InitializedEntity &Entity,
|
||
InitListExpr *IList, DesignatedInitExpr *DIE,
|
||
unsigned DesigIdx,
|
||
QualType &CurrentObjectType,
|
||
RecordDecl::field_iterator *NextField,
|
||
llvm::APSInt *NextElementIndex,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool FinishSubobjectInit,
|
||
bool TopLevelObject);
|
||
InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
|
||
QualType CurrentObjectType,
|
||
InitListExpr *StructuredList,
|
||
unsigned StructuredIndex,
|
||
SourceRange InitRange);
|
||
void UpdateStructuredListElement(InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
Expr *expr);
|
||
int numArrayElements(QualType DeclType);
|
||
int numStructUnionElements(QualType DeclType);
|
||
|
||
void FillInValueInitForField(unsigned Init, FieldDecl *Field,
|
||
const InitializedEntity &ParentEntity,
|
||
InitListExpr *ILE, bool &RequiresSecondPass);
|
||
void FillInValueInitializations(const InitializedEntity &Entity,
|
||
InitListExpr *ILE, bool &RequiresSecondPass);
|
||
public:
|
||
InitListChecker(Sema &S, const InitializedEntity &Entity,
|
||
InitListExpr *IL, QualType &T);
|
||
bool HadError() { return hadError; }
|
||
|
||
// @brief Retrieves the fully-structured initializer list used for
|
||
// semantic analysis and code generation.
|
||
InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
|
||
};
|
||
} // end anonymous namespace
|
||
|
||
void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field,
|
||
const InitializedEntity &ParentEntity,
|
||
InitListExpr *ILE,
|
||
bool &RequiresSecondPass) {
|
||
SourceLocation Loc = ILE->getSourceRange().getBegin();
|
||
unsigned NumInits = ILE->getNumInits();
|
||
InitializedEntity MemberEntity
|
||
= InitializedEntity::InitializeMember(Field, &ParentEntity);
|
||
if (Init >= NumInits || !ILE->getInit(Init)) {
|
||
// FIXME: We probably don't need to handle references
|
||
// specially here, since value-initialization of references is
|
||
// handled in InitializationSequence.
|
||
if (Field->getType()->isReferenceType()) {
|
||
// C++ [dcl.init.aggr]p9:
|
||
// If an incomplete or empty initializer-list leaves a
|
||
// member of reference type uninitialized, the program is
|
||
// ill-formed.
|
||
SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
|
||
<< Field->getType()
|
||
<< ILE->getSyntacticForm()->getSourceRange();
|
||
SemaRef.Diag(Field->getLocation(),
|
||
diag::note_uninit_reference_member);
|
||
hadError = true;
|
||
return;
|
||
}
|
||
|
||
InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
|
||
true);
|
||
InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, 0, 0);
|
||
if (!InitSeq) {
|
||
InitSeq.Diagnose(SemaRef, MemberEntity, Kind, 0, 0);
|
||
hadError = true;
|
||
return;
|
||
}
|
||
|
||
Sema::OwningExprResult MemberInit
|
||
= InitSeq.Perform(SemaRef, MemberEntity, Kind,
|
||
Sema::MultiExprArg(SemaRef, 0, 0));
|
||
if (MemberInit.isInvalid()) {
|
||
hadError = true;
|
||
return;
|
||
}
|
||
|
||
if (hadError) {
|
||
// Do nothing
|
||
} else if (Init < NumInits) {
|
||
ILE->setInit(Init, MemberInit.takeAs<Expr>());
|
||
} else if (InitSeq.getKind()
|
||
== InitializationSequence::ConstructorInitialization) {
|
||
// Value-initialization requires a constructor call, so
|
||
// extend the initializer list to include the constructor
|
||
// call and make a note that we'll need to take another pass
|
||
// through the initializer list.
|
||
ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs<Expr>());
|
||
RequiresSecondPass = true;
|
||
}
|
||
} else if (InitListExpr *InnerILE
|
||
= dyn_cast<InitListExpr>(ILE->getInit(Init)))
|
||
FillInValueInitializations(MemberEntity, InnerILE,
|
||
RequiresSecondPass);
|
||
}
|
||
|
||
/// Recursively replaces NULL values within the given initializer list
|
||
/// with expressions that perform value-initialization of the
|
||
/// appropriate type.
|
||
void
|
||
InitListChecker::FillInValueInitializations(const InitializedEntity &Entity,
|
||
InitListExpr *ILE,
|
||
bool &RequiresSecondPass) {
|
||
assert((ILE->getType() != SemaRef.Context.VoidTy) &&
|
||
"Should not have void type");
|
||
SourceLocation Loc = ILE->getSourceRange().getBegin();
|
||
if (ILE->getSyntacticForm())
|
||
Loc = ILE->getSyntacticForm()->getSourceRange().getBegin();
|
||
|
||
if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
|
||
if (RType->getDecl()->isUnion() &&
|
||
ILE->getInitializedFieldInUnion())
|
||
FillInValueInitForField(0, ILE->getInitializedFieldInUnion(),
|
||
Entity, ILE, RequiresSecondPass);
|
||
else {
|
||
unsigned Init = 0;
|
||
for (RecordDecl::field_iterator
|
||
Field = RType->getDecl()->field_begin(),
|
||
FieldEnd = RType->getDecl()->field_end();
|
||
Field != FieldEnd; ++Field) {
|
||
if (Field->isUnnamedBitfield())
|
||
continue;
|
||
|
||
if (hadError)
|
||
return;
|
||
|
||
FillInValueInitForField(Init, *Field, Entity, ILE, RequiresSecondPass);
|
||
if (hadError)
|
||
return;
|
||
|
||
++Init;
|
||
|
||
// Only look at the first initialization of a union.
|
||
if (RType->getDecl()->isUnion())
|
||
break;
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
QualType ElementType;
|
||
|
||
InitializedEntity ElementEntity = Entity;
|
||
unsigned NumInits = ILE->getNumInits();
|
||
unsigned NumElements = NumInits;
|
||
if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
|
||
ElementType = AType->getElementType();
|
||
if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
|
||
NumElements = CAType->getSize().getZExtValue();
|
||
ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
|
||
0, Entity);
|
||
} else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
|
||
ElementType = VType->getElementType();
|
||
NumElements = VType->getNumElements();
|
||
ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
|
||
0, Entity);
|
||
} else
|
||
ElementType = ILE->getType();
|
||
|
||
|
||
for (unsigned Init = 0; Init != NumElements; ++Init) {
|
||
if (hadError)
|
||
return;
|
||
|
||
if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
|
||
ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
|
||
ElementEntity.setElementIndex(Init);
|
||
|
||
if (Init >= NumInits || !ILE->getInit(Init)) {
|
||
InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
|
||
true);
|
||
InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, 0, 0);
|
||
if (!InitSeq) {
|
||
InitSeq.Diagnose(SemaRef, ElementEntity, Kind, 0, 0);
|
||
hadError = true;
|
||
return;
|
||
}
|
||
|
||
Sema::OwningExprResult ElementInit
|
||
= InitSeq.Perform(SemaRef, ElementEntity, Kind,
|
||
Sema::MultiExprArg(SemaRef, 0, 0));
|
||
if (ElementInit.isInvalid()) {
|
||
hadError = true;
|
||
return;
|
||
}
|
||
|
||
if (hadError) {
|
||
// Do nothing
|
||
} else if (Init < NumInits) {
|
||
ILE->setInit(Init, ElementInit.takeAs<Expr>());
|
||
} else if (InitSeq.getKind()
|
||
== InitializationSequence::ConstructorInitialization) {
|
||
// Value-initialization requires a constructor call, so
|
||
// extend the initializer list to include the constructor
|
||
// call and make a note that we'll need to take another pass
|
||
// through the initializer list.
|
||
ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs<Expr>());
|
||
RequiresSecondPass = true;
|
||
}
|
||
} else if (InitListExpr *InnerILE
|
||
= dyn_cast<InitListExpr>(ILE->getInit(Init)))
|
||
FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass);
|
||
}
|
||
}
|
||
|
||
|
||
InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
|
||
InitListExpr *IL, QualType &T)
|
||
: SemaRef(S) {
|
||
hadError = false;
|
||
|
||
unsigned newIndex = 0;
|
||
unsigned newStructuredIndex = 0;
|
||
FullyStructuredList
|
||
= getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange());
|
||
CheckExplicitInitList(Entity, IL, T, newIndex,
|
||
FullyStructuredList, newStructuredIndex,
|
||
/*TopLevelObject=*/true);
|
||
|
||
if (!hadError) {
|
||
bool RequiresSecondPass = false;
|
||
FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass);
|
||
if (RequiresSecondPass && !hadError)
|
||
FillInValueInitializations(Entity, FullyStructuredList,
|
||
RequiresSecondPass);
|
||
}
|
||
}
|
||
|
||
int InitListChecker::numArrayElements(QualType DeclType) {
|
||
// FIXME: use a proper constant
|
||
int maxElements = 0x7FFFFFFF;
|
||
if (const ConstantArrayType *CAT =
|
||
SemaRef.Context.getAsConstantArrayType(DeclType)) {
|
||
maxElements = static_cast<int>(CAT->getSize().getZExtValue());
|
||
}
|
||
return maxElements;
|
||
}
|
||
|
||
int InitListChecker::numStructUnionElements(QualType DeclType) {
|
||
RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
|
||
int InitializableMembers = 0;
|
||
for (RecordDecl::field_iterator
|
||
Field = structDecl->field_begin(),
|
||
FieldEnd = structDecl->field_end();
|
||
Field != FieldEnd; ++Field) {
|
||
if ((*Field)->getIdentifier() || !(*Field)->isBitField())
|
||
++InitializableMembers;
|
||
}
|
||
if (structDecl->isUnion())
|
||
return std::min(InitializableMembers, 1);
|
||
return InitializableMembers - structDecl->hasFlexibleArrayMember();
|
||
}
|
||
|
||
void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
|
||
InitListExpr *ParentIList,
|
||
QualType T, unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject) {
|
||
int maxElements = 0;
|
||
|
||
if (T->isArrayType())
|
||
maxElements = numArrayElements(T);
|
||
else if (T->isRecordType())
|
||
maxElements = numStructUnionElements(T);
|
||
else if (T->isVectorType())
|
||
maxElements = T->getAs<VectorType>()->getNumElements();
|
||
else
|
||
assert(0 && "CheckImplicitInitList(): Illegal type");
|
||
|
||
if (maxElements == 0) {
|
||
SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
|
||
diag::err_implicit_empty_initializer);
|
||
++Index;
|
||
hadError = true;
|
||
return;
|
||
}
|
||
|
||
// Build a structured initializer list corresponding to this subobject.
|
||
InitListExpr *StructuredSubobjectInitList
|
||
= getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
|
||
StructuredIndex,
|
||
SourceRange(ParentIList->getInit(Index)->getSourceRange().getBegin(),
|
||
ParentIList->getSourceRange().getEnd()));
|
||
unsigned StructuredSubobjectInitIndex = 0;
|
||
|
||
// Check the element types and build the structural subobject.
|
||
unsigned StartIndex = Index;
|
||
CheckListElementTypes(Entity, ParentIList, T,
|
||
/*SubobjectIsDesignatorContext=*/false, Index,
|
||
StructuredSubobjectInitList,
|
||
StructuredSubobjectInitIndex,
|
||
TopLevelObject);
|
||
unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
|
||
StructuredSubobjectInitList->setType(T);
|
||
|
||
// Update the structured sub-object initializer so that it's ending
|
||
// range corresponds with the end of the last initializer it used.
|
||
if (EndIndex < ParentIList->getNumInits()) {
|
||
SourceLocation EndLoc
|
||
= ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
|
||
StructuredSubobjectInitList->setRBraceLoc(EndLoc);
|
||
}
|
||
|
||
// Warn about missing braces.
|
||
if (T->isArrayType() || T->isRecordType()) {
|
||
SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
|
||
diag::warn_missing_braces)
|
||
<< StructuredSubobjectInitList->getSourceRange()
|
||
<< FixItHint::CreateInsertion(StructuredSubobjectInitList->getLocStart(),
|
||
"{")
|
||
<< FixItHint::CreateInsertion(SemaRef.PP.getLocForEndOfToken(
|
||
StructuredSubobjectInitList->getLocEnd()),
|
||
"}");
|
||
}
|
||
}
|
||
|
||
void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType &T,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject) {
|
||
assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
|
||
SyntacticToSemantic[IList] = StructuredList;
|
||
StructuredList->setSyntacticForm(IList);
|
||
CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
|
||
Index, StructuredList, StructuredIndex, TopLevelObject);
|
||
IList->setType(T.getNonReferenceType());
|
||
StructuredList->setType(T.getNonReferenceType());
|
||
if (hadError)
|
||
return;
|
||
|
||
if (Index < IList->getNumInits()) {
|
||
// We have leftover initializers
|
||
if (StructuredIndex == 1 &&
|
||
IsStringInit(StructuredList->getInit(0), T, SemaRef.Context)) {
|
||
unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
|
||
if (SemaRef.getLangOptions().CPlusPlus) {
|
||
DK = diag::err_excess_initializers_in_char_array_initializer;
|
||
hadError = true;
|
||
}
|
||
// Special-case
|
||
SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
|
||
<< IList->getInit(Index)->getSourceRange();
|
||
} else if (!T->isIncompleteType()) {
|
||
// Don't complain for incomplete types, since we'll get an error
|
||
// elsewhere
|
||
QualType CurrentObjectType = StructuredList->getType();
|
||
int initKind =
|
||
CurrentObjectType->isArrayType()? 0 :
|
||
CurrentObjectType->isVectorType()? 1 :
|
||
CurrentObjectType->isScalarType()? 2 :
|
||
CurrentObjectType->isUnionType()? 3 :
|
||
4;
|
||
|
||
unsigned DK = diag::warn_excess_initializers;
|
||
if (SemaRef.getLangOptions().CPlusPlus) {
|
||
DK = diag::err_excess_initializers;
|
||
hadError = true;
|
||
}
|
||
if (SemaRef.getLangOptions().OpenCL && initKind == 1) {
|
||
DK = diag::err_excess_initializers;
|
||
hadError = true;
|
||
}
|
||
|
||
SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
|
||
<< initKind << IList->getInit(Index)->getSourceRange();
|
||
}
|
||
}
|
||
|
||
if (T->isScalarType() && !TopLevelObject)
|
||
SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
|
||
<< IList->getSourceRange()
|
||
<< FixItHint::CreateRemoval(IList->getLocStart())
|
||
<< FixItHint::CreateRemoval(IList->getLocEnd());
|
||
}
|
||
|
||
void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
|
||
InitListExpr *IList,
|
||
QualType &DeclType,
|
||
bool SubobjectIsDesignatorContext,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject) {
|
||
if (DeclType->isScalarType()) {
|
||
CheckScalarType(Entity, IList, DeclType, Index,
|
||
StructuredList, StructuredIndex);
|
||
} else if (DeclType->isVectorType()) {
|
||
CheckVectorType(Entity, IList, DeclType, Index,
|
||
StructuredList, StructuredIndex);
|
||
} else if (DeclType->isAggregateType()) {
|
||
if (DeclType->isRecordType()) {
|
||
RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
|
||
CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
|
||
SubobjectIsDesignatorContext, Index,
|
||
StructuredList, StructuredIndex,
|
||
TopLevelObject);
|
||
} else if (DeclType->isArrayType()) {
|
||
llvm::APSInt Zero(
|
||
SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
|
||
false);
|
||
CheckArrayType(Entity, IList, DeclType, Zero,
|
||
SubobjectIsDesignatorContext, Index,
|
||
StructuredList, StructuredIndex);
|
||
} else
|
||
assert(0 && "Aggregate that isn't a structure or array?!");
|
||
} else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
|
||
// This type is invalid, issue a diagnostic.
|
||
++Index;
|
||
SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
|
||
<< DeclType;
|
||
hadError = true;
|
||
} else if (DeclType->isRecordType()) {
|
||
// C++ [dcl.init]p14:
|
||
// [...] If the class is an aggregate (8.5.1), and the initializer
|
||
// is a brace-enclosed list, see 8.5.1.
|
||
//
|
||
// Note: 8.5.1 is handled below; here, we diagnose the case where
|
||
// we have an initializer list and a destination type that is not
|
||
// an aggregate.
|
||
// FIXME: In C++0x, this is yet another form of initialization.
|
||
SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
|
||
<< DeclType << IList->getSourceRange();
|
||
hadError = true;
|
||
} else if (DeclType->isReferenceType()) {
|
||
CheckReferenceType(Entity, IList, DeclType, Index,
|
||
StructuredList, StructuredIndex);
|
||
} else if (DeclType->isObjCObjectType()) {
|
||
SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
|
||
<< DeclType;
|
||
hadError = true;
|
||
} else {
|
||
SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
|
||
<< DeclType;
|
||
hadError = true;
|
||
}
|
||
}
|
||
|
||
void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
|
||
InitListExpr *IList,
|
||
QualType ElemType,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex) {
|
||
Expr *expr = IList->getInit(Index);
|
||
if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
|
||
unsigned newIndex = 0;
|
||
unsigned newStructuredIndex = 0;
|
||
InitListExpr *newStructuredList
|
||
= getStructuredSubobjectInit(IList, Index, ElemType,
|
||
StructuredList, StructuredIndex,
|
||
SubInitList->getSourceRange());
|
||
CheckExplicitInitList(Entity, SubInitList, ElemType, newIndex,
|
||
newStructuredList, newStructuredIndex);
|
||
++StructuredIndex;
|
||
++Index;
|
||
} else if (Expr *Str = IsStringInit(expr, ElemType, SemaRef.Context)) {
|
||
CheckStringInit(Str, ElemType, SemaRef);
|
||
UpdateStructuredListElement(StructuredList, StructuredIndex, Str);
|
||
++Index;
|
||
} else if (ElemType->isScalarType()) {
|
||
CheckScalarType(Entity, IList, ElemType, Index,
|
||
StructuredList, StructuredIndex);
|
||
} else if (ElemType->isReferenceType()) {
|
||
CheckReferenceType(Entity, IList, ElemType, Index,
|
||
StructuredList, StructuredIndex);
|
||
} else {
|
||
if (SemaRef.getLangOptions().CPlusPlus) {
|
||
// C++ [dcl.init.aggr]p12:
|
||
// All implicit type conversions (clause 4) are considered when
|
||
// initializing the aggregate member with an ini- tializer from
|
||
// an initializer-list. If the initializer can initialize a
|
||
// member, the member is initialized. [...]
|
||
|
||
// FIXME: Better EqualLoc?
|
||
InitializationKind Kind =
|
||
InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
|
||
InitializationSequence Seq(SemaRef, Entity, Kind, &expr, 1);
|
||
|
||
if (Seq) {
|
||
Sema::OwningExprResult Result =
|
||
Seq.Perform(SemaRef, Entity, Kind,
|
||
Sema::MultiExprArg(SemaRef, (void **)&expr, 1));
|
||
if (Result.isInvalid())
|
||
hadError = true;
|
||
|
||
UpdateStructuredListElement(StructuredList, StructuredIndex,
|
||
Result.takeAs<Expr>());
|
||
++Index;
|
||
return;
|
||
}
|
||
|
||
// Fall through for subaggregate initialization
|
||
} else {
|
||
// C99 6.7.8p13:
|
||
//
|
||
// The initializer for a structure or union object that has
|
||
// automatic storage duration shall be either an initializer
|
||
// list as described below, or a single expression that has
|
||
// compatible structure or union type. In the latter case, the
|
||
// initial value of the object, including unnamed members, is
|
||
// that of the expression.
|
||
if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
|
||
SemaRef.Context.hasSameUnqualifiedType(expr->getType(), ElemType)) {
|
||
UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
|
||
++Index;
|
||
return;
|
||
}
|
||
|
||
// Fall through for subaggregate initialization
|
||
}
|
||
|
||
// C++ [dcl.init.aggr]p12:
|
||
//
|
||
// [...] Otherwise, if the member is itself a non-empty
|
||
// subaggregate, brace elision is assumed and the initializer is
|
||
// considered for the initialization of the first member of
|
||
// the subaggregate.
|
||
if (ElemType->isAggregateType() || ElemType->isVectorType()) {
|
||
CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
|
||
StructuredIndex);
|
||
++StructuredIndex;
|
||
} else {
|
||
// We cannot initialize this element, so let
|
||
// PerformCopyInitialization produce the appropriate diagnostic.
|
||
SemaRef.PerformCopyInitialization(Entity, SourceLocation(),
|
||
SemaRef.Owned(expr));
|
||
IList->setInit(Index, 0);
|
||
hadError = true;
|
||
++Index;
|
||
++StructuredIndex;
|
||
}
|
||
}
|
||
}
|
||
|
||
void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType DeclType,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex) {
|
||
if (Index < IList->getNumInits()) {
|
||
Expr *expr = IList->getInit(Index);
|
||
if (isa<InitListExpr>(expr)) {
|
||
SemaRef.Diag(IList->getLocStart(),
|
||
diag::err_many_braces_around_scalar_init)
|
||
<< IList->getSourceRange();
|
||
hadError = true;
|
||
++Index;
|
||
++StructuredIndex;
|
||
return;
|
||
} else if (isa<DesignatedInitExpr>(expr)) {
|
||
SemaRef.Diag(expr->getSourceRange().getBegin(),
|
||
diag::err_designator_for_scalar_init)
|
||
<< DeclType << expr->getSourceRange();
|
||
hadError = true;
|
||
++Index;
|
||
++StructuredIndex;
|
||
return;
|
||
}
|
||
|
||
Sema::OwningExprResult Result =
|
||
SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
|
||
SemaRef.Owned(expr));
|
||
|
||
Expr *ResultExpr = 0;
|
||
|
||
if (Result.isInvalid())
|
||
hadError = true; // types weren't compatible.
|
||
else {
|
||
ResultExpr = Result.takeAs<Expr>();
|
||
|
||
if (ResultExpr != expr) {
|
||
// The type was promoted, update initializer list.
|
||
IList->setInit(Index, ResultExpr);
|
||
}
|
||
}
|
||
if (hadError)
|
||
++StructuredIndex;
|
||
else
|
||
UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
|
||
++Index;
|
||
} else {
|
||
SemaRef.Diag(IList->getLocStart(), diag::err_empty_scalar_initializer)
|
||
<< IList->getSourceRange();
|
||
hadError = true;
|
||
++Index;
|
||
++StructuredIndex;
|
||
return;
|
||
}
|
||
}
|
||
|
||
void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType DeclType,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex) {
|
||
if (Index < IList->getNumInits()) {
|
||
Expr *expr = IList->getInit(Index);
|
||
if (isa<InitListExpr>(expr)) {
|
||
SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
|
||
<< DeclType << IList->getSourceRange();
|
||
hadError = true;
|
||
++Index;
|
||
++StructuredIndex;
|
||
return;
|
||
}
|
||
|
||
Sema::OwningExprResult Result =
|
||
SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
|
||
SemaRef.Owned(expr));
|
||
|
||
if (Result.isInvalid())
|
||
hadError = true;
|
||
|
||
expr = Result.takeAs<Expr>();
|
||
IList->setInit(Index, expr);
|
||
|
||
if (hadError)
|
||
++StructuredIndex;
|
||
else
|
||
UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
|
||
++Index;
|
||
} else {
|
||
// FIXME: It would be wonderful if we could point at the actual member. In
|
||
// general, it would be useful to pass location information down the stack,
|
||
// so that we know the location (or decl) of the "current object" being
|
||
// initialized.
|
||
SemaRef.Diag(IList->getLocStart(),
|
||
diag::err_init_reference_member_uninitialized)
|
||
<< DeclType
|
||
<< IList->getSourceRange();
|
||
hadError = true;
|
||
++Index;
|
||
++StructuredIndex;
|
||
return;
|
||
}
|
||
}
|
||
|
||
void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType DeclType,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex) {
|
||
if (Index < IList->getNumInits()) {
|
||
const VectorType *VT = DeclType->getAs<VectorType>();
|
||
unsigned maxElements = VT->getNumElements();
|
||
unsigned numEltsInit = 0;
|
||
QualType elementType = VT->getElementType();
|
||
|
||
if (!SemaRef.getLangOptions().OpenCL) {
|
||
InitializedEntity ElementEntity =
|
||
InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
|
||
|
||
for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
|
||
// Don't attempt to go past the end of the init list
|
||
if (Index >= IList->getNumInits())
|
||
break;
|
||
|
||
ElementEntity.setElementIndex(Index);
|
||
CheckSubElementType(ElementEntity, IList, elementType, Index,
|
||
StructuredList, StructuredIndex);
|
||
}
|
||
} else {
|
||
InitializedEntity ElementEntity =
|
||
InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
|
||
|
||
// OpenCL initializers allows vectors to be constructed from vectors.
|
||
for (unsigned i = 0; i < maxElements; ++i) {
|
||
// Don't attempt to go past the end of the init list
|
||
if (Index >= IList->getNumInits())
|
||
break;
|
||
|
||
ElementEntity.setElementIndex(Index);
|
||
|
||
QualType IType = IList->getInit(Index)->getType();
|
||
if (!IType->isVectorType()) {
|
||
CheckSubElementType(ElementEntity, IList, elementType, Index,
|
||
StructuredList, StructuredIndex);
|
||
++numEltsInit;
|
||
} else {
|
||
const VectorType *IVT = IType->getAs<VectorType>();
|
||
unsigned numIElts = IVT->getNumElements();
|
||
QualType VecType = SemaRef.Context.getExtVectorType(elementType,
|
||
numIElts);
|
||
CheckSubElementType(ElementEntity, IList, VecType, Index,
|
||
StructuredList, StructuredIndex);
|
||
numEltsInit += numIElts;
|
||
}
|
||
}
|
||
}
|
||
|
||
// OpenCL requires all elements to be initialized.
|
||
if (numEltsInit != maxElements)
|
||
if (SemaRef.getLangOptions().OpenCL)
|
||
SemaRef.Diag(IList->getSourceRange().getBegin(),
|
||
diag::err_vector_incorrect_num_initializers)
|
||
<< (numEltsInit < maxElements) << maxElements << numEltsInit;
|
||
}
|
||
}
|
||
|
||
void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
|
||
InitListExpr *IList, QualType &DeclType,
|
||
llvm::APSInt elementIndex,
|
||
bool SubobjectIsDesignatorContext,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex) {
|
||
// Check for the special-case of initializing an array with a string.
|
||
if (Index < IList->getNumInits()) {
|
||
if (Expr *Str = IsStringInit(IList->getInit(Index), DeclType,
|
||
SemaRef.Context)) {
|
||
CheckStringInit(Str, DeclType, SemaRef);
|
||
// We place the string literal directly into the resulting
|
||
// initializer list. This is the only place where the structure
|
||
// of the structured initializer list doesn't match exactly,
|
||
// because doing so would involve allocating one character
|
||
// constant for each string.
|
||
UpdateStructuredListElement(StructuredList, StructuredIndex, Str);
|
||
StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
|
||
++Index;
|
||
return;
|
||
}
|
||
}
|
||
if (const VariableArrayType *VAT =
|
||
SemaRef.Context.getAsVariableArrayType(DeclType)) {
|
||
// Check for VLAs; in standard C it would be possible to check this
|
||
// earlier, but I don't know where clang accepts VLAs (gcc accepts
|
||
// them in all sorts of strange places).
|
||
SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
|
||
diag::err_variable_object_no_init)
|
||
<< VAT->getSizeExpr()->getSourceRange();
|
||
hadError = true;
|
||
++Index;
|
||
++StructuredIndex;
|
||
return;
|
||
}
|
||
|
||
// We might know the maximum number of elements in advance.
|
||
llvm::APSInt maxElements(elementIndex.getBitWidth(),
|
||
elementIndex.isUnsigned());
|
||
bool maxElementsKnown = false;
|
||
if (const ConstantArrayType *CAT =
|
||
SemaRef.Context.getAsConstantArrayType(DeclType)) {
|
||
maxElements = CAT->getSize();
|
||
elementIndex.extOrTrunc(maxElements.getBitWidth());
|
||
elementIndex.setIsUnsigned(maxElements.isUnsigned());
|
||
maxElementsKnown = true;
|
||
}
|
||
|
||
QualType elementType = SemaRef.Context.getAsArrayType(DeclType)
|
||
->getElementType();
|
||
while (Index < IList->getNumInits()) {
|
||
Expr *Init = IList->getInit(Index);
|
||
if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
|
||
// If we're not the subobject that matches up with the '{' for
|
||
// the designator, we shouldn't be handling the
|
||
// designator. Return immediately.
|
||
if (!SubobjectIsDesignatorContext)
|
||
return;
|
||
|
||
// Handle this designated initializer. elementIndex will be
|
||
// updated to be the next array element we'll initialize.
|
||
if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
|
||
DeclType, 0, &elementIndex, Index,
|
||
StructuredList, StructuredIndex, true,
|
||
false)) {
|
||
hadError = true;
|
||
continue;
|
||
}
|
||
|
||
if (elementIndex.getBitWidth() > maxElements.getBitWidth())
|
||
maxElements.extend(elementIndex.getBitWidth());
|
||
else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
|
||
elementIndex.extend(maxElements.getBitWidth());
|
||
elementIndex.setIsUnsigned(maxElements.isUnsigned());
|
||
|
||
// If the array is of incomplete type, keep track of the number of
|
||
// elements in the initializer.
|
||
if (!maxElementsKnown && elementIndex > maxElements)
|
||
maxElements = elementIndex;
|
||
|
||
continue;
|
||
}
|
||
|
||
// If we know the maximum number of elements, and we've already
|
||
// hit it, stop consuming elements in the initializer list.
|
||
if (maxElementsKnown && elementIndex == maxElements)
|
||
break;
|
||
|
||
InitializedEntity ElementEntity =
|
||
InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
|
||
Entity);
|
||
// Check this element.
|
||
CheckSubElementType(ElementEntity, IList, elementType, Index,
|
||
StructuredList, StructuredIndex);
|
||
++elementIndex;
|
||
|
||
// If the array is of incomplete type, keep track of the number of
|
||
// elements in the initializer.
|
||
if (!maxElementsKnown && elementIndex > maxElements)
|
||
maxElements = elementIndex;
|
||
}
|
||
if (!hadError && DeclType->isIncompleteArrayType()) {
|
||
// If this is an incomplete array type, the actual type needs to
|
||
// be calculated here.
|
||
llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
|
||
if (maxElements == Zero) {
|
||
// Sizing an array implicitly to zero is not allowed by ISO C,
|
||
// but is supported by GNU.
|
||
SemaRef.Diag(IList->getLocStart(),
|
||
diag::ext_typecheck_zero_array_size);
|
||
}
|
||
|
||
DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
|
||
ArrayType::Normal, 0);
|
||
}
|
||
}
|
||
|
||
void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
|
||
InitListExpr *IList,
|
||
QualType DeclType,
|
||
RecordDecl::field_iterator Field,
|
||
bool SubobjectIsDesignatorContext,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool TopLevelObject) {
|
||
RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
|
||
|
||
// If the record is invalid, some of it's members are invalid. To avoid
|
||
// confusion, we forgo checking the intializer for the entire record.
|
||
if (structDecl->isInvalidDecl()) {
|
||
hadError = true;
|
||
return;
|
||
}
|
||
|
||
if (DeclType->isUnionType() && IList->getNumInits() == 0) {
|
||
// Value-initialize the first named member of the union.
|
||
RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
|
||
for (RecordDecl::field_iterator FieldEnd = RD->field_end();
|
||
Field != FieldEnd; ++Field) {
|
||
if (Field->getDeclName()) {
|
||
StructuredList->setInitializedFieldInUnion(*Field);
|
||
break;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
// If structDecl is a forward declaration, this loop won't do
|
||
// anything except look at designated initializers; That's okay,
|
||
// because an error should get printed out elsewhere. It might be
|
||
// worthwhile to skip over the rest of the initializer, though.
|
||
RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
|
||
RecordDecl::field_iterator FieldEnd = RD->field_end();
|
||
bool InitializedSomething = false;
|
||
bool CheckForMissingFields = true;
|
||
while (Index < IList->getNumInits()) {
|
||
Expr *Init = IList->getInit(Index);
|
||
|
||
if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
|
||
// If we're not the subobject that matches up with the '{' for
|
||
// the designator, we shouldn't be handling the
|
||
// designator. Return immediately.
|
||
if (!SubobjectIsDesignatorContext)
|
||
return;
|
||
|
||
// Handle this designated initializer. Field will be updated to
|
||
// the next field that we'll be initializing.
|
||
if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
|
||
DeclType, &Field, 0, Index,
|
||
StructuredList, StructuredIndex,
|
||
true, TopLevelObject))
|
||
hadError = true;
|
||
|
||
InitializedSomething = true;
|
||
|
||
// Disable check for missing fields when designators are used.
|
||
// This matches gcc behaviour.
|
||
CheckForMissingFields = false;
|
||
continue;
|
||
}
|
||
|
||
if (Field == FieldEnd) {
|
||
// We've run out of fields. We're done.
|
||
break;
|
||
}
|
||
|
||
// We've already initialized a member of a union. We're done.
|
||
if (InitializedSomething && DeclType->isUnionType())
|
||
break;
|
||
|
||
// If we've hit the flexible array member at the end, we're done.
|
||
if (Field->getType()->isIncompleteArrayType())
|
||
break;
|
||
|
||
if (Field->isUnnamedBitfield()) {
|
||
// Don't initialize unnamed bitfields, e.g. "int : 20;"
|
||
++Field;
|
||
continue;
|
||
}
|
||
|
||
InitializedEntity MemberEntity =
|
||
InitializedEntity::InitializeMember(*Field, &Entity);
|
||
CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
|
||
StructuredList, StructuredIndex);
|
||
InitializedSomething = true;
|
||
|
||
if (DeclType->isUnionType()) {
|
||
// Initialize the first field within the union.
|
||
StructuredList->setInitializedFieldInUnion(*Field);
|
||
}
|
||
|
||
++Field;
|
||
}
|
||
|
||
// Emit warnings for missing struct field initializers.
|
||
if (InitializedSomething && CheckForMissingFields && Field != FieldEnd &&
|
||
!Field->getType()->isIncompleteArrayType() && !DeclType->isUnionType()) {
|
||
// It is possible we have one or more unnamed bitfields remaining.
|
||
// Find first (if any) named field and emit warning.
|
||
for (RecordDecl::field_iterator it = Field, end = RD->field_end();
|
||
it != end; ++it) {
|
||
if (!it->isUnnamedBitfield()) {
|
||
SemaRef.Diag(IList->getSourceRange().getEnd(),
|
||
diag::warn_missing_field_initializers) << it->getName();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
|
||
Index >= IList->getNumInits())
|
||
return;
|
||
|
||
// Handle GNU flexible array initializers.
|
||
if (!TopLevelObject &&
|
||
(!isa<InitListExpr>(IList->getInit(Index)) ||
|
||
cast<InitListExpr>(IList->getInit(Index))->getNumInits() > 0)) {
|
||
SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(),
|
||
diag::err_flexible_array_init_nonempty)
|
||
<< IList->getInit(Index)->getSourceRange().getBegin();
|
||
SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
|
||
<< *Field;
|
||
hadError = true;
|
||
++Index;
|
||
return;
|
||
} else {
|
||
SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(),
|
||
diag::ext_flexible_array_init)
|
||
<< IList->getInit(Index)->getSourceRange().getBegin();
|
||
SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
|
||
<< *Field;
|
||
}
|
||
|
||
InitializedEntity MemberEntity =
|
||
InitializedEntity::InitializeMember(*Field, &Entity);
|
||
|
||
if (isa<InitListExpr>(IList->getInit(Index)))
|
||
CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
|
||
StructuredList, StructuredIndex);
|
||
else
|
||
CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
|
||
StructuredList, StructuredIndex);
|
||
}
|
||
|
||
/// \brief Expand a field designator that refers to a member of an
|
||
/// anonymous struct or union into a series of field designators that
|
||
/// refers to the field within the appropriate subobject.
|
||
///
|
||
/// Field/FieldIndex will be updated to point to the (new)
|
||
/// currently-designated field.
|
||
static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
|
||
DesignatedInitExpr *DIE,
|
||
unsigned DesigIdx,
|
||
FieldDecl *Field,
|
||
RecordDecl::field_iterator &FieldIter,
|
||
unsigned &FieldIndex) {
|
||
typedef DesignatedInitExpr::Designator Designator;
|
||
|
||
// Build the path from the current object to the member of the
|
||
// anonymous struct/union (backwards).
|
||
llvm::SmallVector<FieldDecl *, 4> Path;
|
||
SemaRef.BuildAnonymousStructUnionMemberPath(Field, Path);
|
||
|
||
// Build the replacement designators.
|
||
llvm::SmallVector<Designator, 4> Replacements;
|
||
for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator
|
||
FI = Path.rbegin(), FIEnd = Path.rend();
|
||
FI != FIEnd; ++FI) {
|
||
if (FI + 1 == FIEnd)
|
||
Replacements.push_back(Designator((IdentifierInfo *)0,
|
||
DIE->getDesignator(DesigIdx)->getDotLoc(),
|
||
DIE->getDesignator(DesigIdx)->getFieldLoc()));
|
||
else
|
||
Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(),
|
||
SourceLocation()));
|
||
Replacements.back().setField(*FI);
|
||
}
|
||
|
||
// Expand the current designator into the set of replacement
|
||
// designators, so we have a full subobject path down to where the
|
||
// member of the anonymous struct/union is actually stored.
|
||
DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
|
||
&Replacements[0] + Replacements.size());
|
||
|
||
// Update FieldIter/FieldIndex;
|
||
RecordDecl *Record = cast<RecordDecl>(Path.back()->getDeclContext());
|
||
FieldIter = Record->field_begin();
|
||
FieldIndex = 0;
|
||
for (RecordDecl::field_iterator FEnd = Record->field_end();
|
||
FieldIter != FEnd; ++FieldIter) {
|
||
if (FieldIter->isUnnamedBitfield())
|
||
continue;
|
||
|
||
if (*FieldIter == Path.back())
|
||
return;
|
||
|
||
++FieldIndex;
|
||
}
|
||
|
||
assert(false && "Unable to find anonymous struct/union field");
|
||
}
|
||
|
||
/// @brief Check the well-formedness of a C99 designated initializer.
|
||
///
|
||
/// Determines whether the designated initializer @p DIE, which
|
||
/// resides at the given @p Index within the initializer list @p
|
||
/// IList, is well-formed for a current object of type @p DeclType
|
||
/// (C99 6.7.8). The actual subobject that this designator refers to
|
||
/// within the current subobject is returned in either
|
||
/// @p NextField or @p NextElementIndex (whichever is appropriate).
|
||
///
|
||
/// @param IList The initializer list in which this designated
|
||
/// initializer occurs.
|
||
///
|
||
/// @param DIE The designated initializer expression.
|
||
///
|
||
/// @param DesigIdx The index of the current designator.
|
||
///
|
||
/// @param DeclType The type of the "current object" (C99 6.7.8p17),
|
||
/// into which the designation in @p DIE should refer.
|
||
///
|
||
/// @param NextField If non-NULL and the first designator in @p DIE is
|
||
/// a field, this will be set to the field declaration corresponding
|
||
/// to the field named by the designator.
|
||
///
|
||
/// @param NextElementIndex If non-NULL and the first designator in @p
|
||
/// DIE is an array designator or GNU array-range designator, this
|
||
/// will be set to the last index initialized by this designator.
|
||
///
|
||
/// @param Index Index into @p IList where the designated initializer
|
||
/// @p DIE occurs.
|
||
///
|
||
/// @param StructuredList The initializer list expression that
|
||
/// describes all of the subobject initializers in the order they'll
|
||
/// actually be initialized.
|
||
///
|
||
/// @returns true if there was an error, false otherwise.
|
||
bool
|
||
InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
|
||
InitListExpr *IList,
|
||
DesignatedInitExpr *DIE,
|
||
unsigned DesigIdx,
|
||
QualType &CurrentObjectType,
|
||
RecordDecl::field_iterator *NextField,
|
||
llvm::APSInt *NextElementIndex,
|
||
unsigned &Index,
|
||
InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
bool FinishSubobjectInit,
|
||
bool TopLevelObject) {
|
||
if (DesigIdx == DIE->size()) {
|
||
// Check the actual initialization for the designated object type.
|
||
bool prevHadError = hadError;
|
||
|
||
// Temporarily remove the designator expression from the
|
||
// initializer list that the child calls see, so that we don't try
|
||
// to re-process the designator.
|
||
unsigned OldIndex = Index;
|
||
IList->setInit(OldIndex, DIE->getInit());
|
||
|
||
CheckSubElementType(Entity, IList, CurrentObjectType, Index,
|
||
StructuredList, StructuredIndex);
|
||
|
||
// Restore the designated initializer expression in the syntactic
|
||
// form of the initializer list.
|
||
if (IList->getInit(OldIndex) != DIE->getInit())
|
||
DIE->setInit(IList->getInit(OldIndex));
|
||
IList->setInit(OldIndex, DIE);
|
||
|
||
return hadError && !prevHadError;
|
||
}
|
||
|
||
bool IsFirstDesignator = (DesigIdx == 0);
|
||
assert((IsFirstDesignator || StructuredList) &&
|
||
"Need a non-designated initializer list to start from");
|
||
|
||
DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
|
||
// Determine the structural initializer list that corresponds to the
|
||
// current subobject.
|
||
StructuredList = IsFirstDesignator? SyntacticToSemantic[IList]
|
||
: getStructuredSubobjectInit(IList, Index, CurrentObjectType,
|
||
StructuredList, StructuredIndex,
|
||
SourceRange(D->getStartLocation(),
|
||
DIE->getSourceRange().getEnd()));
|
||
assert(StructuredList && "Expected a structured initializer list");
|
||
|
||
if (D->isFieldDesignator()) {
|
||
// C99 6.7.8p7:
|
||
//
|
||
// If a designator has the form
|
||
//
|
||
// . identifier
|
||
//
|
||
// then the current object (defined below) shall have
|
||
// structure or union type and the identifier shall be the
|
||
// name of a member of that type.
|
||
const RecordType *RT = CurrentObjectType->getAs<RecordType>();
|
||
if (!RT) {
|
||
SourceLocation Loc = D->getDotLoc();
|
||
if (Loc.isInvalid())
|
||
Loc = D->getFieldLoc();
|
||
SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
|
||
<< SemaRef.getLangOptions().CPlusPlus << CurrentObjectType;
|
||
++Index;
|
||
return true;
|
||
}
|
||
|
||
// Note: we perform a linear search of the fields here, despite
|
||
// the fact that we have a faster lookup method, because we always
|
||
// need to compute the field's index.
|
||
FieldDecl *KnownField = D->getField();
|
||
IdentifierInfo *FieldName = D->getFieldName();
|
||
unsigned FieldIndex = 0;
|
||
RecordDecl::field_iterator
|
||
Field = RT->getDecl()->field_begin(),
|
||
FieldEnd = RT->getDecl()->field_end();
|
||
for (; Field != FieldEnd; ++Field) {
|
||
if (Field->isUnnamedBitfield())
|
||
continue;
|
||
|
||
if (KnownField == *Field || Field->getIdentifier() == FieldName)
|
||
break;
|
||
|
||
++FieldIndex;
|
||
}
|
||
|
||
if (Field == FieldEnd) {
|
||
// There was no normal field in the struct with the designated
|
||
// name. Perform another lookup for this name, which may find
|
||
// something that we can't designate (e.g., a member function),
|
||
// may find nothing, or may find a member of an anonymous
|
||
// struct/union.
|
||
DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
|
||
FieldDecl *ReplacementField = 0;
|
||
if (Lookup.first == Lookup.second) {
|
||
// Name lookup didn't find anything. Determine whether this
|
||
// was a typo for another field name.
|
||
LookupResult R(SemaRef, FieldName, D->getFieldLoc(),
|
||
Sema::LookupMemberName);
|
||
if (SemaRef.CorrectTypo(R, /*Scope=*/0, /*SS=*/0, RT->getDecl(), false,
|
||
Sema::CTC_NoKeywords) &&
|
||
(ReplacementField = R.getAsSingle<FieldDecl>()) &&
|
||
ReplacementField->getDeclContext()->getLookupContext()
|
||
->Equals(RT->getDecl())) {
|
||
SemaRef.Diag(D->getFieldLoc(),
|
||
diag::err_field_designator_unknown_suggest)
|
||
<< FieldName << CurrentObjectType << R.getLookupName()
|
||
<< FixItHint::CreateReplacement(D->getFieldLoc(),
|
||
R.getLookupName().getAsString());
|
||
SemaRef.Diag(ReplacementField->getLocation(),
|
||
diag::note_previous_decl)
|
||
<< ReplacementField->getDeclName();
|
||
} else {
|
||
SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
|
||
<< FieldName << CurrentObjectType;
|
||
++Index;
|
||
return true;
|
||
}
|
||
} else if (!KnownField) {
|
||
// Determine whether we found a field at all.
|
||
ReplacementField = dyn_cast<FieldDecl>(*Lookup.first);
|
||
}
|
||
|
||
if (!ReplacementField) {
|
||
// Name lookup found something, but it wasn't a field.
|
||
SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
|
||
<< FieldName;
|
||
SemaRef.Diag((*Lookup.first)->getLocation(),
|
||
diag::note_field_designator_found);
|
||
++Index;
|
||
return true;
|
||
}
|
||
|
||
if (!KnownField &&
|
||
cast<RecordDecl>((ReplacementField)->getDeclContext())
|
||
->isAnonymousStructOrUnion()) {
|
||
// Handle an field designator that refers to a member of an
|
||
// anonymous struct or union.
|
||
ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx,
|
||
ReplacementField,
|
||
Field, FieldIndex);
|
||
D = DIE->getDesignator(DesigIdx);
|
||
} else if (!KnownField) {
|
||
// The replacement field comes from typo correction; find it
|
||
// in the list of fields.
|
||
FieldIndex = 0;
|
||
Field = RT->getDecl()->field_begin();
|
||
for (; Field != FieldEnd; ++Field) {
|
||
if (Field->isUnnamedBitfield())
|
||
continue;
|
||
|
||
if (ReplacementField == *Field ||
|
||
Field->getIdentifier() == ReplacementField->getIdentifier())
|
||
break;
|
||
|
||
++FieldIndex;
|
||
}
|
||
}
|
||
} else if (!KnownField &&
|
||
cast<RecordDecl>((*Field)->getDeclContext())
|
||
->isAnonymousStructOrUnion()) {
|
||
ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, *Field,
|
||
Field, FieldIndex);
|
||
D = DIE->getDesignator(DesigIdx);
|
||
}
|
||
|
||
// All of the fields of a union are located at the same place in
|
||
// the initializer list.
|
||
if (RT->getDecl()->isUnion()) {
|
||
FieldIndex = 0;
|
||
StructuredList->setInitializedFieldInUnion(*Field);
|
||
}
|
||
|
||
// Update the designator with the field declaration.
|
||
D->setField(*Field);
|
||
|
||
// Make sure that our non-designated initializer list has space
|
||
// for a subobject corresponding to this field.
|
||
if (FieldIndex >= StructuredList->getNumInits())
|
||
StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
|
||
|
||
// This designator names a flexible array member.
|
||
if (Field->getType()->isIncompleteArrayType()) {
|
||
bool Invalid = false;
|
||
if ((DesigIdx + 1) != DIE->size()) {
|
||
// We can't designate an object within the flexible array
|
||
// member (because GCC doesn't allow it).
|
||
DesignatedInitExpr::Designator *NextD
|
||
= DIE->getDesignator(DesigIdx + 1);
|
||
SemaRef.Diag(NextD->getStartLocation(),
|
||
diag::err_designator_into_flexible_array_member)
|
||
<< SourceRange(NextD->getStartLocation(),
|
||
DIE->getSourceRange().getEnd());
|
||
SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
|
||
<< *Field;
|
||
Invalid = true;
|
||
}
|
||
|
||
if (!hadError && !isa<InitListExpr>(DIE->getInit())) {
|
||
// The initializer is not an initializer list.
|
||
SemaRef.Diag(DIE->getInit()->getSourceRange().getBegin(),
|
||
diag::err_flexible_array_init_needs_braces)
|
||
<< DIE->getInit()->getSourceRange();
|
||
SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
|
||
<< *Field;
|
||
Invalid = true;
|
||
}
|
||
|
||
// Handle GNU flexible array initializers.
|
||
if (!Invalid && !TopLevelObject &&
|
||
cast<InitListExpr>(DIE->getInit())->getNumInits() > 0) {
|
||
SemaRef.Diag(DIE->getSourceRange().getBegin(),
|
||
diag::err_flexible_array_init_nonempty)
|
||
<< DIE->getSourceRange().getBegin();
|
||
SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
|
||
<< *Field;
|
||
Invalid = true;
|
||
}
|
||
|
||
if (Invalid) {
|
||
++Index;
|
||
return true;
|
||
}
|
||
|
||
// Initialize the array.
|
||
bool prevHadError = hadError;
|
||
unsigned newStructuredIndex = FieldIndex;
|
||
unsigned OldIndex = Index;
|
||
IList->setInit(Index, DIE->getInit());
|
||
|
||
InitializedEntity MemberEntity =
|
||
InitializedEntity::InitializeMember(*Field, &Entity);
|
||
CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
|
||
StructuredList, newStructuredIndex);
|
||
|
||
IList->setInit(OldIndex, DIE);
|
||
if (hadError && !prevHadError) {
|
||
++Field;
|
||
++FieldIndex;
|
||
if (NextField)
|
||
*NextField = Field;
|
||
StructuredIndex = FieldIndex;
|
||
return true;
|
||
}
|
||
} else {
|
||
// Recurse to check later designated subobjects.
|
||
QualType FieldType = (*Field)->getType();
|
||
unsigned newStructuredIndex = FieldIndex;
|
||
|
||
InitializedEntity MemberEntity =
|
||
InitializedEntity::InitializeMember(*Field, &Entity);
|
||
if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
|
||
FieldType, 0, 0, Index,
|
||
StructuredList, newStructuredIndex,
|
||
true, false))
|
||
return true;
|
||
}
|
||
|
||
// Find the position of the next field to be initialized in this
|
||
// subobject.
|
||
++Field;
|
||
++FieldIndex;
|
||
|
||
// If this the first designator, our caller will continue checking
|
||
// the rest of this struct/class/union subobject.
|
||
if (IsFirstDesignator) {
|
||
if (NextField)
|
||
*NextField = Field;
|
||
StructuredIndex = FieldIndex;
|
||
return false;
|
||
}
|
||
|
||
if (!FinishSubobjectInit)
|
||
return false;
|
||
|
||
// We've already initialized something in the union; we're done.
|
||
if (RT->getDecl()->isUnion())
|
||
return hadError;
|
||
|
||
// Check the remaining fields within this class/struct/union subobject.
|
||
bool prevHadError = hadError;
|
||
|
||
CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
|
||
StructuredList, FieldIndex);
|
||
return hadError && !prevHadError;
|
||
}
|
||
|
||
// C99 6.7.8p6:
|
||
//
|
||
// If a designator has the form
|
||
//
|
||
// [ constant-expression ]
|
||
//
|
||
// then the current object (defined below) shall have array
|
||
// type and the expression shall be an integer constant
|
||
// expression. If the array is of unknown size, any
|
||
// nonnegative value is valid.
|
||
//
|
||
// Additionally, cope with the GNU extension that permits
|
||
// designators of the form
|
||
//
|
||
// [ constant-expression ... constant-expression ]
|
||
const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
|
||
if (!AT) {
|
||
SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
|
||
<< CurrentObjectType;
|
||
++Index;
|
||
return true;
|
||
}
|
||
|
||
Expr *IndexExpr = 0;
|
||
llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
|
||
if (D->isArrayDesignator()) {
|
||
IndexExpr = DIE->getArrayIndex(*D);
|
||
DesignatedStartIndex = IndexExpr->EvaluateAsInt(SemaRef.Context);
|
||
DesignatedEndIndex = DesignatedStartIndex;
|
||
} else {
|
||
assert(D->isArrayRangeDesignator() && "Need array-range designator");
|
||
|
||
|
||
DesignatedStartIndex =
|
||
DIE->getArrayRangeStart(*D)->EvaluateAsInt(SemaRef.Context);
|
||
DesignatedEndIndex =
|
||
DIE->getArrayRangeEnd(*D)->EvaluateAsInt(SemaRef.Context);
|
||
IndexExpr = DIE->getArrayRangeEnd(*D);
|
||
|
||
if (DesignatedStartIndex.getZExtValue() !=DesignatedEndIndex.getZExtValue())
|
||
FullyStructuredList->sawArrayRangeDesignator();
|
||
}
|
||
|
||
if (isa<ConstantArrayType>(AT)) {
|
||
llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
|
||
DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
|
||
DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
|
||
DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
|
||
DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
|
||
if (DesignatedEndIndex >= MaxElements) {
|
||
SemaRef.Diag(IndexExpr->getSourceRange().getBegin(),
|
||
diag::err_array_designator_too_large)
|
||
<< DesignatedEndIndex.toString(10) << MaxElements.toString(10)
|
||
<< IndexExpr->getSourceRange();
|
||
++Index;
|
||
return true;
|
||
}
|
||
} else {
|
||
// Make sure the bit-widths and signedness match.
|
||
if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
|
||
DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
|
||
else if (DesignatedStartIndex.getBitWidth() <
|
||
DesignatedEndIndex.getBitWidth())
|
||
DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
|
||
DesignatedStartIndex.setIsUnsigned(true);
|
||
DesignatedEndIndex.setIsUnsigned(true);
|
||
}
|
||
|
||
// Make sure that our non-designated initializer list has space
|
||
// for a subobject corresponding to this array element.
|
||
if (DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
|
||
StructuredList->resizeInits(SemaRef.Context,
|
||
DesignatedEndIndex.getZExtValue() + 1);
|
||
|
||
// Repeatedly perform subobject initializations in the range
|
||
// [DesignatedStartIndex, DesignatedEndIndex].
|
||
|
||
// Move to the next designator
|
||
unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
|
||
unsigned OldIndex = Index;
|
||
|
||
InitializedEntity ElementEntity =
|
||
InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
|
||
|
||
while (DesignatedStartIndex <= DesignatedEndIndex) {
|
||
// Recurse to check later designated subobjects.
|
||
QualType ElementType = AT->getElementType();
|
||
Index = OldIndex;
|
||
|
||
ElementEntity.setElementIndex(ElementIndex);
|
||
if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
|
||
ElementType, 0, 0, Index,
|
||
StructuredList, ElementIndex,
|
||
(DesignatedStartIndex == DesignatedEndIndex),
|
||
false))
|
||
return true;
|
||
|
||
// Move to the next index in the array that we'll be initializing.
|
||
++DesignatedStartIndex;
|
||
ElementIndex = DesignatedStartIndex.getZExtValue();
|
||
}
|
||
|
||
// If this the first designator, our caller will continue checking
|
||
// the rest of this array subobject.
|
||
if (IsFirstDesignator) {
|
||
if (NextElementIndex)
|
||
*NextElementIndex = DesignatedStartIndex;
|
||
StructuredIndex = ElementIndex;
|
||
return false;
|
||
}
|
||
|
||
if (!FinishSubobjectInit)
|
||
return false;
|
||
|
||
// Check the remaining elements within this array subobject.
|
||
bool prevHadError = hadError;
|
||
CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
|
||
/*SubobjectIsDesignatorContext=*/false, Index,
|
||
StructuredList, ElementIndex);
|
||
return hadError && !prevHadError;
|
||
}
|
||
|
||
// Get the structured initializer list for a subobject of type
|
||
// @p CurrentObjectType.
|
||
InitListExpr *
|
||
InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
|
||
QualType CurrentObjectType,
|
||
InitListExpr *StructuredList,
|
||
unsigned StructuredIndex,
|
||
SourceRange InitRange) {
|
||
Expr *ExistingInit = 0;
|
||
if (!StructuredList)
|
||
ExistingInit = SyntacticToSemantic[IList];
|
||
else if (StructuredIndex < StructuredList->getNumInits())
|
||
ExistingInit = StructuredList->getInit(StructuredIndex);
|
||
|
||
if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
|
||
return Result;
|
||
|
||
if (ExistingInit) {
|
||
// We are creating an initializer list that initializes the
|
||
// subobjects of the current object, but there was already an
|
||
// initialization that completely initialized the current
|
||
// subobject, e.g., by a compound literal:
|
||
//
|
||
// struct X { int a, b; };
|
||
// struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
|
||
//
|
||
// Here, xs[0].a == 0 and xs[0].b == 3, since the second,
|
||
// designated initializer re-initializes the whole
|
||
// subobject [0], overwriting previous initializers.
|
||
SemaRef.Diag(InitRange.getBegin(),
|
||
diag::warn_subobject_initializer_overrides)
|
||
<< InitRange;
|
||
SemaRef.Diag(ExistingInit->getSourceRange().getBegin(),
|
||
diag::note_previous_initializer)
|
||
<< /*FIXME:has side effects=*/0
|
||
<< ExistingInit->getSourceRange();
|
||
}
|
||
|
||
InitListExpr *Result
|
||
= new (SemaRef.Context) InitListExpr(SemaRef.Context,
|
||
InitRange.getBegin(), 0, 0,
|
||
InitRange.getEnd());
|
||
|
||
Result->setType(CurrentObjectType.getNonReferenceType());
|
||
|
||
// Pre-allocate storage for the structured initializer list.
|
||
unsigned NumElements = 0;
|
||
unsigned NumInits = 0;
|
||
if (!StructuredList)
|
||
NumInits = IList->getNumInits();
|
||
else if (Index < IList->getNumInits()) {
|
||
if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index)))
|
||
NumInits = SubList->getNumInits();
|
||
}
|
||
|
||
if (const ArrayType *AType
|
||
= SemaRef.Context.getAsArrayType(CurrentObjectType)) {
|
||
if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
|
||
NumElements = CAType->getSize().getZExtValue();
|
||
// Simple heuristic so that we don't allocate a very large
|
||
// initializer with many empty entries at the end.
|
||
if (NumInits && NumElements > NumInits)
|
||
NumElements = 0;
|
||
}
|
||
} else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
|
||
NumElements = VType->getNumElements();
|
||
else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
|
||
RecordDecl *RDecl = RType->getDecl();
|
||
if (RDecl->isUnion())
|
||
NumElements = 1;
|
||
else
|
||
NumElements = std::distance(RDecl->field_begin(),
|
||
RDecl->field_end());
|
||
}
|
||
|
||
if (NumElements < NumInits)
|
||
NumElements = IList->getNumInits();
|
||
|
||
Result->reserveInits(SemaRef.Context, NumElements);
|
||
|
||
// Link this new initializer list into the structured initializer
|
||
// lists.
|
||
if (StructuredList)
|
||
StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
|
||
else {
|
||
Result->setSyntacticForm(IList);
|
||
SyntacticToSemantic[IList] = Result;
|
||
}
|
||
|
||
return Result;
|
||
}
|
||
|
||
/// Update the initializer at index @p StructuredIndex within the
|
||
/// structured initializer list to the value @p expr.
|
||
void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
|
||
unsigned &StructuredIndex,
|
||
Expr *expr) {
|
||
// No structured initializer list to update
|
||
if (!StructuredList)
|
||
return;
|
||
|
||
if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
|
||
StructuredIndex, expr)) {
|
||
// This initializer overwrites a previous initializer. Warn.
|
||
SemaRef.Diag(expr->getSourceRange().getBegin(),
|
||
diag::warn_initializer_overrides)
|
||
<< expr->getSourceRange();
|
||
SemaRef.Diag(PrevInit->getSourceRange().getBegin(),
|
||
diag::note_previous_initializer)
|
||
<< /*FIXME:has side effects=*/0
|
||
<< PrevInit->getSourceRange();
|
||
}
|
||
|
||
++StructuredIndex;
|
||
}
|
||
|
||
/// Check that the given Index expression is a valid array designator
|
||
/// value. This is essentailly just a wrapper around
|
||
/// VerifyIntegerConstantExpression that also checks for negative values
|
||
/// and produces a reasonable diagnostic if there is a
|
||
/// failure. Returns true if there was an error, false otherwise. If
|
||
/// everything went okay, Value will receive the value of the constant
|
||
/// expression.
|
||
static bool
|
||
CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
|
||
SourceLocation Loc = Index->getSourceRange().getBegin();
|
||
|
||
// Make sure this is an integer constant expression.
|
||
if (S.VerifyIntegerConstantExpression(Index, &Value))
|
||
return true;
|
||
|
||
if (Value.isSigned() && Value.isNegative())
|
||
return S.Diag(Loc, diag::err_array_designator_negative)
|
||
<< Value.toString(10) << Index->getSourceRange();
|
||
|
||
Value.setIsUnsigned(true);
|
||
return false;
|
||
}
|
||
|
||
Sema::OwningExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
|
||
SourceLocation Loc,
|
||
bool GNUSyntax,
|
||
OwningExprResult Init) {
|
||
typedef DesignatedInitExpr::Designator ASTDesignator;
|
||
|
||
bool Invalid = false;
|
||
llvm::SmallVector<ASTDesignator, 32> Designators;
|
||
llvm::SmallVector<Expr *, 32> InitExpressions;
|
||
|
||
// Build designators and check array designator expressions.
|
||
for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
|
||
const Designator &D = Desig.getDesignator(Idx);
|
||
switch (D.getKind()) {
|
||
case Designator::FieldDesignator:
|
||
Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
|
||
D.getFieldLoc()));
|
||
break;
|
||
|
||
case Designator::ArrayDesignator: {
|
||
Expr *Index = static_cast<Expr *>(D.getArrayIndex());
|
||
llvm::APSInt IndexValue;
|
||
if (!Index->isTypeDependent() &&
|
||
!Index->isValueDependent() &&
|
||
CheckArrayDesignatorExpr(*this, Index, IndexValue))
|
||
Invalid = true;
|
||
else {
|
||
Designators.push_back(ASTDesignator(InitExpressions.size(),
|
||
D.getLBracketLoc(),
|
||
D.getRBracketLoc()));
|
||
InitExpressions.push_back(Index);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case Designator::ArrayRangeDesignator: {
|
||
Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
|
||
Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
|
||
llvm::APSInt StartValue;
|
||
llvm::APSInt EndValue;
|
||
bool StartDependent = StartIndex->isTypeDependent() ||
|
||
StartIndex->isValueDependent();
|
||
bool EndDependent = EndIndex->isTypeDependent() ||
|
||
EndIndex->isValueDependent();
|
||
if ((!StartDependent &&
|
||
CheckArrayDesignatorExpr(*this, StartIndex, StartValue)) ||
|
||
(!EndDependent &&
|
||
CheckArrayDesignatorExpr(*this, EndIndex, EndValue)))
|
||
Invalid = true;
|
||
else {
|
||
// Make sure we're comparing values with the same bit width.
|
||
if (StartDependent || EndDependent) {
|
||
// Nothing to compute.
|
||
} else if (StartValue.getBitWidth() > EndValue.getBitWidth())
|
||
EndValue.extend(StartValue.getBitWidth());
|
||
else if (StartValue.getBitWidth() < EndValue.getBitWidth())
|
||
StartValue.extend(EndValue.getBitWidth());
|
||
|
||
if (!StartDependent && !EndDependent && EndValue < StartValue) {
|
||
Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
|
||
<< StartValue.toString(10) << EndValue.toString(10)
|
||
<< StartIndex->getSourceRange() << EndIndex->getSourceRange();
|
||
Invalid = true;
|
||
} else {
|
||
Designators.push_back(ASTDesignator(InitExpressions.size(),
|
||
D.getLBracketLoc(),
|
||
D.getEllipsisLoc(),
|
||
D.getRBracketLoc()));
|
||
InitExpressions.push_back(StartIndex);
|
||
InitExpressions.push_back(EndIndex);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (Invalid || Init.isInvalid())
|
||
return ExprError();
|
||
|
||
// Clear out the expressions within the designation.
|
||
Desig.ClearExprs(*this);
|
||
|
||
DesignatedInitExpr *DIE
|
||
= DesignatedInitExpr::Create(Context,
|
||
Designators.data(), Designators.size(),
|
||
InitExpressions.data(), InitExpressions.size(),
|
||
Loc, GNUSyntax, Init.takeAs<Expr>());
|
||
return Owned(DIE);
|
||
}
|
||
|
||
bool Sema::CheckInitList(const InitializedEntity &Entity,
|
||
InitListExpr *&InitList, QualType &DeclType) {
|
||
InitListChecker CheckInitList(*this, Entity, InitList, DeclType);
|
||
if (!CheckInitList.HadError())
|
||
InitList = CheckInitList.getFullyStructuredList();
|
||
|
||
return CheckInitList.HadError();
|
||
}
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Initialization entity
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
|
||
const InitializedEntity &Parent)
|
||
: Parent(&Parent), Index(Index)
|
||
{
|
||
if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
|
||
Kind = EK_ArrayElement;
|
||
Type = AT->getElementType();
|
||
} else {
|
||
Kind = EK_VectorElement;
|
||
Type = Parent.getType()->getAs<VectorType>()->getElementType();
|
||
}
|
||
}
|
||
|
||
InitializedEntity InitializedEntity::InitializeBase(ASTContext &Context,
|
||
CXXBaseSpecifier *Base,
|
||
bool IsInheritedVirtualBase)
|
||
{
|
||
InitializedEntity Result;
|
||
Result.Kind = EK_Base;
|
||
Result.Base = reinterpret_cast<uintptr_t>(Base);
|
||
if (IsInheritedVirtualBase)
|
||
Result.Base |= 0x01;
|
||
|
||
Result.Type = Base->getType();
|
||
return Result;
|
||
}
|
||
|
||
DeclarationName InitializedEntity::getName() const {
|
||
switch (getKind()) {
|
||
case EK_Parameter:
|
||
if (!VariableOrMember)
|
||
return DeclarationName();
|
||
// Fall through
|
||
|
||
case EK_Variable:
|
||
case EK_Member:
|
||
return VariableOrMember->getDeclName();
|
||
|
||
case EK_Result:
|
||
case EK_Exception:
|
||
case EK_New:
|
||
case EK_Temporary:
|
||
case EK_Base:
|
||
case EK_ArrayElement:
|
||
case EK_VectorElement:
|
||
case EK_BlockElement:
|
||
return DeclarationName();
|
||
}
|
||
|
||
// Silence GCC warning
|
||
return DeclarationName();
|
||
}
|
||
|
||
DeclaratorDecl *InitializedEntity::getDecl() const {
|
||
switch (getKind()) {
|
||
case EK_Variable:
|
||
case EK_Parameter:
|
||
case EK_Member:
|
||
return VariableOrMember;
|
||
|
||
case EK_Result:
|
||
case EK_Exception:
|
||
case EK_New:
|
||
case EK_Temporary:
|
||
case EK_Base:
|
||
case EK_ArrayElement:
|
||
case EK_VectorElement:
|
||
case EK_BlockElement:
|
||
return 0;
|
||
}
|
||
|
||
// Silence GCC warning
|
||
return 0;
|
||
}
|
||
|
||
bool InitializedEntity::allowsNRVO() const {
|
||
switch (getKind()) {
|
||
case EK_Result:
|
||
case EK_Exception:
|
||
return LocAndNRVO.NRVO;
|
||
|
||
case EK_Variable:
|
||
case EK_Parameter:
|
||
case EK_Member:
|
||
case EK_New:
|
||
case EK_Temporary:
|
||
case EK_Base:
|
||
case EK_ArrayElement:
|
||
case EK_VectorElement:
|
||
case EK_BlockElement:
|
||
break;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Initialization sequence
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
void InitializationSequence::Step::Destroy() {
|
||
switch (Kind) {
|
||
case SK_ResolveAddressOfOverloadedFunction:
|
||
case SK_CastDerivedToBaseRValue:
|
||
case SK_CastDerivedToBaseLValue:
|
||
case SK_BindReference:
|
||
case SK_BindReferenceToTemporary:
|
||
case SK_ExtraneousCopyToTemporary:
|
||
case SK_UserConversion:
|
||
case SK_QualificationConversionRValue:
|
||
case SK_QualificationConversionLValue:
|
||
case SK_ListInitialization:
|
||
case SK_ConstructorInitialization:
|
||
case SK_ZeroInitialization:
|
||
case SK_CAssignment:
|
||
case SK_StringInit:
|
||
break;
|
||
|
||
case SK_ConversionSequence:
|
||
delete ICS;
|
||
}
|
||
}
|
||
|
||
bool InitializationSequence::isDirectReferenceBinding() const {
|
||
return getKind() == ReferenceBinding && Steps.back().Kind == SK_BindReference;
|
||
}
|
||
|
||
bool InitializationSequence::isAmbiguous() const {
|
||
if (getKind() != FailedSequence)
|
||
return false;
|
||
|
||
switch (getFailureKind()) {
|
||
case FK_TooManyInitsForReference:
|
||
case FK_ArrayNeedsInitList:
|
||
case FK_ArrayNeedsInitListOrStringLiteral:
|
||
case FK_AddressOfOverloadFailed: // FIXME: Could do better
|
||
case FK_NonConstLValueReferenceBindingToTemporary:
|
||
case FK_NonConstLValueReferenceBindingToUnrelated:
|
||
case FK_RValueReferenceBindingToLValue:
|
||
case FK_ReferenceInitDropsQualifiers:
|
||
case FK_ReferenceInitFailed:
|
||
case FK_ConversionFailed:
|
||
case FK_TooManyInitsForScalar:
|
||
case FK_ReferenceBindingToInitList:
|
||
case FK_InitListBadDestinationType:
|
||
case FK_DefaultInitOfConst:
|
||
case FK_Incomplete:
|
||
return false;
|
||
|
||
case FK_ReferenceInitOverloadFailed:
|
||
case FK_UserConversionOverloadFailed:
|
||
case FK_ConstructorOverloadFailed:
|
||
return FailedOverloadResult == OR_Ambiguous;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool InitializationSequence::isConstructorInitialization() const {
|
||
return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
|
||
}
|
||
|
||
void InitializationSequence::AddAddressOverloadResolutionStep(
|
||
FunctionDecl *Function,
|
||
DeclAccessPair Found) {
|
||
Step S;
|
||
S.Kind = SK_ResolveAddressOfOverloadedFunction;
|
||
S.Type = Function->getType();
|
||
S.Function.Function = Function;
|
||
S.Function.FoundDecl = Found;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
|
||
bool IsLValue) {
|
||
Step S;
|
||
S.Kind = IsLValue? SK_CastDerivedToBaseLValue : SK_CastDerivedToBaseRValue;
|
||
S.Type = BaseType;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddReferenceBindingStep(QualType T,
|
||
bool BindingTemporary) {
|
||
Step S;
|
||
S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
|
||
S.Type = T;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
|
||
Step S;
|
||
S.Kind = SK_ExtraneousCopyToTemporary;
|
||
S.Type = T;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
|
||
DeclAccessPair FoundDecl,
|
||
QualType T) {
|
||
Step S;
|
||
S.Kind = SK_UserConversion;
|
||
S.Type = T;
|
||
S.Function.Function = Function;
|
||
S.Function.FoundDecl = FoundDecl;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddQualificationConversionStep(QualType Ty,
|
||
bool IsLValue) {
|
||
Step S;
|
||
S.Kind = IsLValue? SK_QualificationConversionLValue
|
||
: SK_QualificationConversionRValue;
|
||
S.Type = Ty;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddConversionSequenceStep(
|
||
const ImplicitConversionSequence &ICS,
|
||
QualType T) {
|
||
Step S;
|
||
S.Kind = SK_ConversionSequence;
|
||
S.Type = T;
|
||
S.ICS = new ImplicitConversionSequence(ICS);
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddListInitializationStep(QualType T) {
|
||
Step S;
|
||
S.Kind = SK_ListInitialization;
|
||
S.Type = T;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void
|
||
InitializationSequence::AddConstructorInitializationStep(
|
||
CXXConstructorDecl *Constructor,
|
||
AccessSpecifier Access,
|
||
QualType T) {
|
||
Step S;
|
||
S.Kind = SK_ConstructorInitialization;
|
||
S.Type = T;
|
||
S.Function.Function = Constructor;
|
||
S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddZeroInitializationStep(QualType T) {
|
||
Step S;
|
||
S.Kind = SK_ZeroInitialization;
|
||
S.Type = T;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddCAssignmentStep(QualType T) {
|
||
Step S;
|
||
S.Kind = SK_CAssignment;
|
||
S.Type = T;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::AddStringInitStep(QualType T) {
|
||
Step S;
|
||
S.Kind = SK_StringInit;
|
||
S.Type = T;
|
||
Steps.push_back(S);
|
||
}
|
||
|
||
void InitializationSequence::SetOverloadFailure(FailureKind Failure,
|
||
OverloadingResult Result) {
|
||
SequenceKind = FailedSequence;
|
||
this->Failure = Failure;
|
||
this->FailedOverloadResult = Result;
|
||
}
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Attempt initialization
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
/// \brief Attempt list initialization (C++0x [dcl.init.list])
|
||
static void TryListInitialization(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
InitListExpr *InitList,
|
||
InitializationSequence &Sequence) {
|
||
// FIXME: We only perform rudimentary checking of list
|
||
// initializations at this point, then assume that any list
|
||
// initialization of an array, aggregate, or scalar will be
|
||
// well-formed. We we actually "perform" list initialization, we'll
|
||
// do all of the necessary checking. C++0x initializer lists will
|
||
// force us to perform more checking here.
|
||
Sequence.setSequenceKind(InitializationSequence::ListInitialization);
|
||
|
||
QualType DestType = Entity.getType();
|
||
|
||
// C++ [dcl.init]p13:
|
||
// If T is a scalar type, then a declaration of the form
|
||
//
|
||
// T x = { a };
|
||
//
|
||
// is equivalent to
|
||
//
|
||
// T x = a;
|
||
if (DestType->isScalarType()) {
|
||
if (InitList->getNumInits() > 1 && S.getLangOptions().CPlusPlus) {
|
||
Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
|
||
return;
|
||
}
|
||
|
||
// Assume scalar initialization from a single value works.
|
||
} else if (DestType->isAggregateType()) {
|
||
// Assume aggregate initialization works.
|
||
} else if (DestType->isVectorType()) {
|
||
// Assume vector initialization works.
|
||
} else if (DestType->isReferenceType()) {
|
||
// FIXME: C++0x defines behavior for this.
|
||
Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
|
||
return;
|
||
} else if (DestType->isRecordType()) {
|
||
// FIXME: C++0x defines behavior for this
|
||
Sequence.SetFailed(InitializationSequence::FK_InitListBadDestinationType);
|
||
}
|
||
|
||
// Add a general "list initialization" step.
|
||
Sequence.AddListInitializationStep(DestType);
|
||
}
|
||
|
||
/// \brief Try a reference initialization that involves calling a conversion
|
||
/// function.
|
||
///
|
||
/// FIXME: look intos DRs 656, 896
|
||
static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Expr *Initializer,
|
||
bool AllowRValues,
|
||
InitializationSequence &Sequence) {
|
||
QualType DestType = Entity.getType();
|
||
QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
|
||
QualType T1 = cv1T1.getUnqualifiedType();
|
||
QualType cv2T2 = Initializer->getType();
|
||
QualType T2 = cv2T2.getUnqualifiedType();
|
||
|
||
bool DerivedToBase;
|
||
assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
|
||
T1, T2, DerivedToBase) &&
|
||
"Must have incompatible references when binding via conversion");
|
||
(void)DerivedToBase;
|
||
|
||
// Build the candidate set directly in the initialization sequence
|
||
// structure, so that it will persist if we fail.
|
||
OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
|
||
CandidateSet.clear();
|
||
|
||
// Determine whether we are allowed to call explicit constructors or
|
||
// explicit conversion operators.
|
||
bool AllowExplicit = Kind.getKind() == InitializationKind::IK_Direct;
|
||
|
||
const RecordType *T1RecordType = 0;
|
||
if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
|
||
!S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
|
||
// The type we're converting to is a class type. Enumerate its constructors
|
||
// to see if there is a suitable conversion.
|
||
CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
|
||
DeclarationName ConstructorName
|
||
= S.Context.DeclarationNames.getCXXConstructorName(
|
||
S.Context.getCanonicalType(T1).getUnqualifiedType());
|
||
DeclContext::lookup_iterator Con, ConEnd;
|
||
for (llvm::tie(Con, ConEnd) = T1RecordDecl->lookup(ConstructorName);
|
||
Con != ConEnd; ++Con) {
|
||
NamedDecl *D = *Con;
|
||
DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
|
||
|
||
// Find the constructor (which may be a template).
|
||
CXXConstructorDecl *Constructor = 0;
|
||
FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
|
||
if (ConstructorTmpl)
|
||
Constructor = cast<CXXConstructorDecl>(
|
||
ConstructorTmpl->getTemplatedDecl());
|
||
else
|
||
Constructor = cast<CXXConstructorDecl>(D);
|
||
|
||
if (!Constructor->isInvalidDecl() &&
|
||
Constructor->isConvertingConstructor(AllowExplicit)) {
|
||
if (ConstructorTmpl)
|
||
S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
|
||
/*ExplicitArgs*/ 0,
|
||
&Initializer, 1, CandidateSet);
|
||
else
|
||
S.AddOverloadCandidate(Constructor, FoundDecl,
|
||
&Initializer, 1, CandidateSet);
|
||
}
|
||
}
|
||
}
|
||
|
||
const RecordType *T2RecordType = 0;
|
||
if ((T2RecordType = T2->getAs<RecordType>()) &&
|
||
!S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
|
||
// The type we're converting from is a class type, enumerate its conversion
|
||
// functions.
|
||
CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
|
||
|
||
// Determine the type we are converting to. If we are allowed to
|
||
// convert to an rvalue, take the type that the destination type
|
||
// refers to.
|
||
QualType ToType = AllowRValues? cv1T1 : DestType;
|
||
|
||
const UnresolvedSetImpl *Conversions
|
||
= T2RecordDecl->getVisibleConversionFunctions();
|
||
for (UnresolvedSetImpl::const_iterator I = Conversions->begin(),
|
||
E = Conversions->end(); I != E; ++I) {
|
||
NamedDecl *D = *I;
|
||
CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
|
||
if (isa<UsingShadowDecl>(D))
|
||
D = cast<UsingShadowDecl>(D)->getTargetDecl();
|
||
|
||
FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
|
||
CXXConversionDecl *Conv;
|
||
if (ConvTemplate)
|
||
Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
|
||
else
|
||
Conv = cast<CXXConversionDecl>(*I);
|
||
|
||
// If the conversion function doesn't return a reference type,
|
||
// it can't be considered for this conversion unless we're allowed to
|
||
// consider rvalues.
|
||
// FIXME: Do we need to make sure that we only consider conversion
|
||
// candidates with reference-compatible results? That might be needed to
|
||
// break recursion.
|
||
if ((AllowExplicit || !Conv->isExplicit()) &&
|
||
(AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
|
||
if (ConvTemplate)
|
||
S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
|
||
ActingDC, Initializer,
|
||
ToType, CandidateSet);
|
||
else
|
||
S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
|
||
Initializer, ToType, CandidateSet);
|
||
}
|
||
}
|
||
}
|
||
|
||
SourceLocation DeclLoc = Initializer->getLocStart();
|
||
|
||
// Perform overload resolution. If it fails, return the failed result.
|
||
OverloadCandidateSet::iterator Best;
|
||
if (OverloadingResult Result
|
||
= S.BestViableFunction(CandidateSet, DeclLoc, Best))
|
||
return Result;
|
||
|
||
FunctionDecl *Function = Best->Function;
|
||
|
||
// Compute the returned type of the conversion.
|
||
if (isa<CXXConversionDecl>(Function))
|
||
T2 = Function->getResultType();
|
||
else
|
||
T2 = cv1T1;
|
||
|
||
// Add the user-defined conversion step.
|
||
Sequence.AddUserConversionStep(Function, Best->FoundDecl,
|
||
T2.getNonReferenceType());
|
||
|
||
// Determine whether we need to perform derived-to-base or
|
||
// cv-qualification adjustments.
|
||
bool NewDerivedToBase = false;
|
||
Sema::ReferenceCompareResult NewRefRelationship
|
||
= S.CompareReferenceRelationship(DeclLoc, T1, T2.getNonReferenceType(),
|
||
NewDerivedToBase);
|
||
if (NewRefRelationship == Sema::Ref_Incompatible) {
|
||
// If the type we've converted to is not reference-related to the
|
||
// type we're looking for, then there is another conversion step
|
||
// we need to perform to produce a temporary of the right type
|
||
// that we'll be binding to.
|
||
ImplicitConversionSequence ICS;
|
||
ICS.setStandard();
|
||
ICS.Standard = Best->FinalConversion;
|
||
T2 = ICS.Standard.getToType(2);
|
||
Sequence.AddConversionSequenceStep(ICS, T2);
|
||
} else if (NewDerivedToBase)
|
||
Sequence.AddDerivedToBaseCastStep(
|
||
S.Context.getQualifiedType(T1,
|
||
T2.getNonReferenceType().getQualifiers()),
|
||
/*isLValue=*/true);
|
||
|
||
if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
|
||
Sequence.AddQualificationConversionStep(cv1T1, T2->isReferenceType());
|
||
|
||
Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
|
||
return OR_Success;
|
||
}
|
||
|
||
/// \brief Attempt reference initialization (C++0x [dcl.init.list])
|
||
static void TryReferenceInitialization(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Expr *Initializer,
|
||
InitializationSequence &Sequence) {
|
||
Sequence.setSequenceKind(InitializationSequence::ReferenceBinding);
|
||
|
||
QualType DestType = Entity.getType();
|
||
QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
|
||
Qualifiers T1Quals;
|
||
QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
|
||
QualType cv2T2 = Initializer->getType();
|
||
Qualifiers T2Quals;
|
||
QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
|
||
SourceLocation DeclLoc = Initializer->getLocStart();
|
||
|
||
// If the initializer is the address of an overloaded function, try
|
||
// to resolve the overloaded function. If all goes well, T2 is the
|
||
// type of the resulting function.
|
||
if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
|
||
DeclAccessPair Found;
|
||
FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Initializer,
|
||
T1,
|
||
false,
|
||
Found);
|
||
if (!Fn) {
|
||
Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
|
||
return;
|
||
}
|
||
|
||
Sequence.AddAddressOverloadResolutionStep(Fn, Found);
|
||
cv2T2 = Fn->getType();
|
||
T2 = cv2T2.getUnqualifiedType();
|
||
}
|
||
|
||
// Compute some basic properties of the types and the initializer.
|
||
bool isLValueRef = DestType->isLValueReferenceType();
|
||
bool isRValueRef = !isLValueRef;
|
||
bool DerivedToBase = false;
|
||
Expr::isLvalueResult InitLvalue = Initializer->isLvalue(S.Context);
|
||
Sema::ReferenceCompareResult RefRelationship
|
||
= S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase);
|
||
|
||
// C++0x [dcl.init.ref]p5:
|
||
// A reference to type "cv1 T1" is initialized by an expression of type
|
||
// "cv2 T2" as follows:
|
||
//
|
||
// - If the reference is an lvalue reference and the initializer
|
||
// expression
|
||
OverloadingResult ConvOvlResult = OR_Success;
|
||
if (isLValueRef) {
|
||
if (InitLvalue == Expr::LV_Valid &&
|
||
RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) {
|
||
// - is an lvalue (but is not a bit-field), and "cv1 T1" is
|
||
// reference-compatible with "cv2 T2," or
|
||
//
|
||
// Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
|
||
// bit-field when we're determining whether the reference initialization
|
||
// can occur. However, we do pay attention to whether it is a bit-field
|
||
// to decide whether we're actually binding to a temporary created from
|
||
// the bit-field.
|
||
if (DerivedToBase)
|
||
Sequence.AddDerivedToBaseCastStep(
|
||
S.Context.getQualifiedType(T1, T2Quals),
|
||
/*isLValue=*/true);
|
||
if (T1Quals != T2Quals)
|
||
Sequence.AddQualificationConversionStep(cv1T1, /*IsLValue=*/true);
|
||
bool BindingTemporary = T1Quals.hasConst() && !T1Quals.hasVolatile() &&
|
||
(Initializer->getBitField() || Initializer->refersToVectorElement());
|
||
Sequence.AddReferenceBindingStep(cv1T1, BindingTemporary);
|
||
return;
|
||
}
|
||
|
||
// - has a class type (i.e., T2 is a class type), where T1 is not
|
||
// reference-related to T2, and can be implicitly converted to an
|
||
// lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
|
||
// with "cv3 T3" (this conversion is selected by enumerating the
|
||
// applicable conversion functions (13.3.1.6) and choosing the best
|
||
// one through overload resolution (13.3)),
|
||
if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType()) {
|
||
ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, Kind,
|
||
Initializer,
|
||
/*AllowRValues=*/false,
|
||
Sequence);
|
||
if (ConvOvlResult == OR_Success)
|
||
return;
|
||
if (ConvOvlResult != OR_No_Viable_Function) {
|
||
Sequence.SetOverloadFailure(
|
||
InitializationSequence::FK_ReferenceInitOverloadFailed,
|
||
ConvOvlResult);
|
||
}
|
||
}
|
||
}
|
||
|
||
// - Otherwise, the reference shall be an lvalue reference to a
|
||
// non-volatile const type (i.e., cv1 shall be const), or the reference
|
||
// shall be an rvalue reference and the initializer expression shall
|
||
// be an rvalue.
|
||
if (!((isLValueRef && T1Quals.hasConst() && !T1Quals.hasVolatile()) ||
|
||
(isRValueRef && InitLvalue != Expr::LV_Valid))) {
|
||
if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
|
||
Sequence.SetOverloadFailure(
|
||
InitializationSequence::FK_ReferenceInitOverloadFailed,
|
||
ConvOvlResult);
|
||
else if (isLValueRef)
|
||
Sequence.SetFailed(InitLvalue == Expr::LV_Valid
|
||
? (RefRelationship == Sema::Ref_Related
|
||
? InitializationSequence::FK_ReferenceInitDropsQualifiers
|
||
: InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
|
||
: InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
|
||
else
|
||
Sequence.SetFailed(
|
||
InitializationSequence::FK_RValueReferenceBindingToLValue);
|
||
|
||
return;
|
||
}
|
||
|
||
// - If T1 and T2 are class types and
|
||
if (T1->isRecordType() && T2->isRecordType()) {
|
||
// - the initializer expression is an rvalue and "cv1 T1" is
|
||
// reference-compatible with "cv2 T2", or
|
||
if (InitLvalue != Expr::LV_Valid &&
|
||
RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) {
|
||
// The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
|
||
// compiler the freedom to perform a copy here or bind to the
|
||
// object, while C++0x requires that we bind directly to the
|
||
// object. Hence, we always bind to the object without making an
|
||
// extra copy. However, in C++03 requires that we check for the
|
||
// presence of a suitable copy constructor:
|
||
//
|
||
// The constructor that would be used to make the copy shall
|
||
// be callable whether or not the copy is actually done.
|
||
if (!S.getLangOptions().CPlusPlus0x)
|
||
Sequence.AddExtraneousCopyToTemporary(cv2T2);
|
||
|
||
if (DerivedToBase)
|
||
Sequence.AddDerivedToBaseCastStep(
|
||
S.Context.getQualifiedType(T1, T2Quals),
|
||
/*isLValue=*/false);
|
||
if (T1Quals != T2Quals)
|
||
Sequence.AddQualificationConversionStep(cv1T1, /*IsLValue=*/false);
|
||
Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
|
||
return;
|
||
}
|
||
|
||
// - T1 is not reference-related to T2 and the initializer expression
|
||
// can be implicitly converted to an rvalue of type "cv3 T3" (this
|
||
// conversion is selected by enumerating the applicable conversion
|
||
// functions (13.3.1.6) and choosing the best one through overload
|
||
// resolution (13.3)),
|
||
if (RefRelationship == Sema::Ref_Incompatible) {
|
||
ConvOvlResult = TryRefInitWithConversionFunction(S, Entity,
|
||
Kind, Initializer,
|
||
/*AllowRValues=*/true,
|
||
Sequence);
|
||
if (ConvOvlResult)
|
||
Sequence.SetOverloadFailure(
|
||
InitializationSequence::FK_ReferenceInitOverloadFailed,
|
||
ConvOvlResult);
|
||
|
||
return;
|
||
}
|
||
|
||
Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
|
||
return;
|
||
}
|
||
|
||
// - If the initializer expression is an rvalue, with T2 an array type,
|
||
// and "cv1 T1" is reference-compatible with "cv2 T2," the reference
|
||
// is bound to the object represented by the rvalue (see 3.10).
|
||
// FIXME: How can an array type be reference-compatible with anything?
|
||
// Don't we mean the element types of T1 and T2?
|
||
|
||
// - Otherwise, a temporary of type “cv1 T1” is created and initialized
|
||
// from the initializer expression using the rules for a non-reference
|
||
// copy initialization (8.5). The reference is then bound to the
|
||
// temporary. [...]
|
||
|
||
// Determine whether we are allowed to call explicit constructors or
|
||
// explicit conversion operators.
|
||
bool AllowExplicit = (Kind.getKind() == InitializationKind::IK_Direct);
|
||
|
||
InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
|
||
|
||
if (S.TryImplicitConversion(Sequence, TempEntity, Initializer,
|
||
/*SuppressUserConversions*/ false,
|
||
AllowExplicit,
|
||
/*FIXME:InOverloadResolution=*/false)) {
|
||
// FIXME: Use the conversion function set stored in ICS to turn
|
||
// this into an overloading ambiguity diagnostic. However, we need
|
||
// to keep that set as an OverloadCandidateSet rather than as some
|
||
// other kind of set.
|
||
if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
|
||
Sequence.SetOverloadFailure(
|
||
InitializationSequence::FK_ReferenceInitOverloadFailed,
|
||
ConvOvlResult);
|
||
else
|
||
Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
|
||
return;
|
||
}
|
||
|
||
// [...] If T1 is reference-related to T2, cv1 must be the
|
||
// same cv-qualification as, or greater cv-qualification
|
||
// than, cv2; otherwise, the program is ill-formed.
|
||
unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
|
||
unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
|
||
if (RefRelationship == Sema::Ref_Related &&
|
||
(T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
|
||
Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
|
||
return;
|
||
}
|
||
|
||
Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
|
||
return;
|
||
}
|
||
|
||
/// \brief Attempt character array initialization from a string literal
|
||
/// (C++ [dcl.init.string], C99 6.7.8).
|
||
static void TryStringLiteralInitialization(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Expr *Initializer,
|
||
InitializationSequence &Sequence) {
|
||
Sequence.setSequenceKind(InitializationSequence::StringInit);
|
||
Sequence.AddStringInitStep(Entity.getType());
|
||
}
|
||
|
||
/// \brief Attempt initialization by constructor (C++ [dcl.init]), which
|
||
/// enumerates the constructors of the initialized entity and performs overload
|
||
/// resolution to select the best.
|
||
static void TryConstructorInitialization(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Expr **Args, unsigned NumArgs,
|
||
QualType DestType,
|
||
InitializationSequence &Sequence) {
|
||
Sequence.setSequenceKind(InitializationSequence::ConstructorInitialization);
|
||
|
||
// Build the candidate set directly in the initialization sequence
|
||
// structure, so that it will persist if we fail.
|
||
OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
|
||
CandidateSet.clear();
|
||
|
||
// Determine whether we are allowed to call explicit constructors or
|
||
// explicit conversion operators.
|
||
bool AllowExplicit = (Kind.getKind() == InitializationKind::IK_Direct ||
|
||
Kind.getKind() == InitializationKind::IK_Value ||
|
||
Kind.getKind() == InitializationKind::IK_Default);
|
||
|
||
// The type we're constructing needs to be complete.
|
||
if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
|
||
Sequence.SetFailed(InitializationSequence::FK_Incomplete);
|
||
return;
|
||
}
|
||
|
||
// The type we're converting to is a class type. Enumerate its constructors
|
||
// to see if one is suitable.
|
||
const RecordType *DestRecordType = DestType->getAs<RecordType>();
|
||
assert(DestRecordType && "Constructor initialization requires record type");
|
||
CXXRecordDecl *DestRecordDecl
|
||
= cast<CXXRecordDecl>(DestRecordType->getDecl());
|
||
|
||
DeclarationName ConstructorName
|
||
= S.Context.DeclarationNames.getCXXConstructorName(
|
||
S.Context.getCanonicalType(DestType).getUnqualifiedType());
|
||
DeclContext::lookup_iterator Con, ConEnd;
|
||
for (llvm::tie(Con, ConEnd) = DestRecordDecl->lookup(ConstructorName);
|
||
Con != ConEnd; ++Con) {
|
||
NamedDecl *D = *Con;
|
||
DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
|
||
bool SuppressUserConversions = false;
|
||
|
||
// Find the constructor (which may be a template).
|
||
CXXConstructorDecl *Constructor = 0;
|
||
FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
|
||
if (ConstructorTmpl)
|
||
Constructor = cast<CXXConstructorDecl>(
|
||
ConstructorTmpl->getTemplatedDecl());
|
||
else {
|
||
Constructor = cast<CXXConstructorDecl>(D);
|
||
|
||
// If we're performing copy initialization using a copy constructor, we
|
||
// suppress user-defined conversions on the arguments.
|
||
// FIXME: Move constructors?
|
||
if (Kind.getKind() == InitializationKind::IK_Copy &&
|
||
Constructor->isCopyConstructor())
|
||
SuppressUserConversions = true;
|
||
}
|
||
|
||
if (!Constructor->isInvalidDecl() &&
|
||
(AllowExplicit || !Constructor->isExplicit())) {
|
||
if (ConstructorTmpl)
|
||
S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
|
||
/*ExplicitArgs*/ 0,
|
||
Args, NumArgs, CandidateSet,
|
||
SuppressUserConversions);
|
||
else
|
||
S.AddOverloadCandidate(Constructor, FoundDecl,
|
||
Args, NumArgs, CandidateSet,
|
||
SuppressUserConversions);
|
||
}
|
||
}
|
||
|
||
SourceLocation DeclLoc = Kind.getLocation();
|
||
|
||
// Perform overload resolution. If it fails, return the failed result.
|
||
OverloadCandidateSet::iterator Best;
|
||
if (OverloadingResult Result
|
||
= S.BestViableFunction(CandidateSet, DeclLoc, Best)) {
|
||
Sequence.SetOverloadFailure(
|
||
InitializationSequence::FK_ConstructorOverloadFailed,
|
||
Result);
|
||
return;
|
||
}
|
||
|
||
// C++0x [dcl.init]p6:
|
||
// If a program calls for the default initialization of an object
|
||
// of a const-qualified type T, T shall be a class type with a
|
||
// user-provided default constructor.
|
||
if (Kind.getKind() == InitializationKind::IK_Default &&
|
||
Entity.getType().isConstQualified() &&
|
||
cast<CXXConstructorDecl>(Best->Function)->isImplicit()) {
|
||
Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
|
||
return;
|
||
}
|
||
|
||
// Add the constructor initialization step. Any cv-qualification conversion is
|
||
// subsumed by the initialization.
|
||
Sequence.AddConstructorInitializationStep(
|
||
cast<CXXConstructorDecl>(Best->Function),
|
||
Best->FoundDecl.getAccess(),
|
||
DestType);
|
||
}
|
||
|
||
/// \brief Attempt value initialization (C++ [dcl.init]p7).
|
||
static void TryValueInitialization(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
InitializationSequence &Sequence) {
|
||
// C++ [dcl.init]p5:
|
||
//
|
||
// To value-initialize an object of type T means:
|
||
QualType T = Entity.getType();
|
||
|
||
// -- if T is an array type, then each element is value-initialized;
|
||
while (const ArrayType *AT = S.Context.getAsArrayType(T))
|
||
T = AT->getElementType();
|
||
|
||
if (const RecordType *RT = T->getAs<RecordType>()) {
|
||
if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
|
||
// -- if T is a class type (clause 9) with a user-declared
|
||
// constructor (12.1), then the default constructor for T is
|
||
// called (and the initialization is ill-formed if T has no
|
||
// accessible default constructor);
|
||
//
|
||
// FIXME: we really want to refer to a single subobject of the array,
|
||
// but Entity doesn't have a way to capture that (yet).
|
||
if (ClassDecl->hasUserDeclaredConstructor())
|
||
return TryConstructorInitialization(S, Entity, Kind, 0, 0, T, Sequence);
|
||
|
||
// -- if T is a (possibly cv-qualified) non-union class type
|
||
// without a user-provided constructor, then the object is
|
||
// zero-initialized and, if T’s implicitly-declared default
|
||
// constructor is non-trivial, that constructor is called.
|
||
if ((ClassDecl->getTagKind() == TTK_Class ||
|
||
ClassDecl->getTagKind() == TTK_Struct) &&
|
||
!ClassDecl->hasTrivialConstructor()) {
|
||
Sequence.AddZeroInitializationStep(Entity.getType());
|
||
return TryConstructorInitialization(S, Entity, Kind, 0, 0, T, Sequence);
|
||
}
|
||
}
|
||
}
|
||
|
||
Sequence.AddZeroInitializationStep(Entity.getType());
|
||
Sequence.setSequenceKind(InitializationSequence::ZeroInitialization);
|
||
}
|
||
|
||
/// \brief Attempt default initialization (C++ [dcl.init]p6).
|
||
static void TryDefaultInitialization(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
InitializationSequence &Sequence) {
|
||
assert(Kind.getKind() == InitializationKind::IK_Default);
|
||
|
||
// C++ [dcl.init]p6:
|
||
// To default-initialize an object of type T means:
|
||
// - if T is an array type, each element is default-initialized;
|
||
QualType DestType = Entity.getType();
|
||
while (const ArrayType *Array = S.Context.getAsArrayType(DestType))
|
||
DestType = Array->getElementType();
|
||
|
||
// - if T is a (possibly cv-qualified) class type (Clause 9), the default
|
||
// constructor for T is called (and the initialization is ill-formed if
|
||
// T has no accessible default constructor);
|
||
if (DestType->isRecordType() && S.getLangOptions().CPlusPlus) {
|
||
return TryConstructorInitialization(S, Entity, Kind, 0, 0, DestType,
|
||
Sequence);
|
||
}
|
||
|
||
// - otherwise, no initialization is performed.
|
||
Sequence.setSequenceKind(InitializationSequence::NoInitialization);
|
||
|
||
// If a program calls for the default initialization of an object of
|
||
// a const-qualified type T, T shall be a class type with a user-provided
|
||
// default constructor.
|
||
if (DestType.isConstQualified() && S.getLangOptions().CPlusPlus)
|
||
Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
|
||
}
|
||
|
||
/// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
|
||
/// which enumerates all conversion functions and performs overload resolution
|
||
/// to select the best.
|
||
static void TryUserDefinedConversion(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Expr *Initializer,
|
||
InitializationSequence &Sequence) {
|
||
Sequence.setSequenceKind(InitializationSequence::UserDefinedConversion);
|
||
|
||
QualType DestType = Entity.getType();
|
||
assert(!DestType->isReferenceType() && "References are handled elsewhere");
|
||
QualType SourceType = Initializer->getType();
|
||
assert((DestType->isRecordType() || SourceType->isRecordType()) &&
|
||
"Must have a class type to perform a user-defined conversion");
|
||
|
||
// Build the candidate set directly in the initialization sequence
|
||
// structure, so that it will persist if we fail.
|
||
OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
|
||
CandidateSet.clear();
|
||
|
||
// Determine whether we are allowed to call explicit constructors or
|
||
// explicit conversion operators.
|
||
bool AllowExplicit = Kind.getKind() == InitializationKind::IK_Direct;
|
||
|
||
if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
|
||
// The type we're converting to is a class type. Enumerate its constructors
|
||
// to see if there is a suitable conversion.
|
||
CXXRecordDecl *DestRecordDecl
|
||
= cast<CXXRecordDecl>(DestRecordType->getDecl());
|
||
|
||
// Try to complete the type we're converting to.
|
||
if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
|
||
DeclarationName ConstructorName
|
||
= S.Context.DeclarationNames.getCXXConstructorName(
|
||
S.Context.getCanonicalType(DestType).getUnqualifiedType());
|
||
DeclContext::lookup_iterator Con, ConEnd;
|
||
for (llvm::tie(Con, ConEnd) = DestRecordDecl->lookup(ConstructorName);
|
||
Con != ConEnd; ++Con) {
|
||
NamedDecl *D = *Con;
|
||
DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
|
||
bool SuppressUserConversions = false;
|
||
|
||
// Find the constructor (which may be a template).
|
||
CXXConstructorDecl *Constructor = 0;
|
||
FunctionTemplateDecl *ConstructorTmpl
|
||
= dyn_cast<FunctionTemplateDecl>(D);
|
||
if (ConstructorTmpl)
|
||
Constructor = cast<CXXConstructorDecl>(
|
||
ConstructorTmpl->getTemplatedDecl());
|
||
else {
|
||
Constructor = cast<CXXConstructorDecl>(D);
|
||
|
||
// If we're performing copy initialization using a copy constructor,
|
||
// we suppress user-defined conversions on the arguments.
|
||
// FIXME: Move constructors?
|
||
if (Kind.getKind() == InitializationKind::IK_Copy &&
|
||
Constructor->isCopyConstructor())
|
||
SuppressUserConversions = true;
|
||
|
||
}
|
||
|
||
if (!Constructor->isInvalidDecl() &&
|
||
Constructor->isConvertingConstructor(AllowExplicit)) {
|
||
if (ConstructorTmpl)
|
||
S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
|
||
/*ExplicitArgs*/ 0,
|
||
&Initializer, 1, CandidateSet,
|
||
SuppressUserConversions);
|
||
else
|
||
S.AddOverloadCandidate(Constructor, FoundDecl,
|
||
&Initializer, 1, CandidateSet,
|
||
SuppressUserConversions);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
SourceLocation DeclLoc = Initializer->getLocStart();
|
||
|
||
if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
|
||
// The type we're converting from is a class type, enumerate its conversion
|
||
// functions.
|
||
|
||
// We can only enumerate the conversion functions for a complete type; if
|
||
// the type isn't complete, simply skip this step.
|
||
if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
|
||
CXXRecordDecl *SourceRecordDecl
|
||
= cast<CXXRecordDecl>(SourceRecordType->getDecl());
|
||
|
||
const UnresolvedSetImpl *Conversions
|
||
= SourceRecordDecl->getVisibleConversionFunctions();
|
||
for (UnresolvedSetImpl::const_iterator I = Conversions->begin(),
|
||
E = Conversions->end();
|
||
I != E; ++I) {
|
||
NamedDecl *D = *I;
|
||
CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
|
||
if (isa<UsingShadowDecl>(D))
|
||
D = cast<UsingShadowDecl>(D)->getTargetDecl();
|
||
|
||
FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
|
||
CXXConversionDecl *Conv;
|
||
if (ConvTemplate)
|
||
Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
|
||
else
|
||
Conv = cast<CXXConversionDecl>(D);
|
||
|
||
if (AllowExplicit || !Conv->isExplicit()) {
|
||
if (ConvTemplate)
|
||
S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
|
||
ActingDC, Initializer, DestType,
|
||
CandidateSet);
|
||
else
|
||
S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
|
||
Initializer, DestType, CandidateSet);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Perform overload resolution. If it fails, return the failed result.
|
||
OverloadCandidateSet::iterator Best;
|
||
if (OverloadingResult Result
|
||
= S.BestViableFunction(CandidateSet, DeclLoc, Best)) {
|
||
Sequence.SetOverloadFailure(
|
||
InitializationSequence::FK_UserConversionOverloadFailed,
|
||
Result);
|
||
return;
|
||
}
|
||
|
||
FunctionDecl *Function = Best->Function;
|
||
|
||
if (isa<CXXConstructorDecl>(Function)) {
|
||
// Add the user-defined conversion step. Any cv-qualification conversion is
|
||
// subsumed by the initialization.
|
||
Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType);
|
||
return;
|
||
}
|
||
|
||
// Add the user-defined conversion step that calls the conversion function.
|
||
QualType ConvType = Function->getResultType().getNonReferenceType();
|
||
if (ConvType->getAs<RecordType>()) {
|
||
// If we're converting to a class type, there may be an copy if
|
||
// the resulting temporary object (possible to create an object of
|
||
// a base class type). That copy is not a separate conversion, so
|
||
// we just make a note of the actual destination type (possibly a
|
||
// base class of the type returned by the conversion function) and
|
||
// let the user-defined conversion step handle the conversion.
|
||
Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType);
|
||
return;
|
||
}
|
||
|
||
Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType);
|
||
|
||
// If the conversion following the call to the conversion function
|
||
// is interesting, add it as a separate step.
|
||
if (Best->FinalConversion.First || Best->FinalConversion.Second ||
|
||
Best->FinalConversion.Third) {
|
||
ImplicitConversionSequence ICS;
|
||
ICS.setStandard();
|
||
ICS.Standard = Best->FinalConversion;
|
||
Sequence.AddConversionSequenceStep(ICS, DestType);
|
||
}
|
||
}
|
||
|
||
bool Sema::TryImplicitConversion(InitializationSequence &Sequence,
|
||
const InitializedEntity &Entity,
|
||
Expr *Initializer,
|
||
bool SuppressUserConversions,
|
||
bool AllowExplicitConversions,
|
||
bool InOverloadResolution) {
|
||
ImplicitConversionSequence ICS
|
||
= TryImplicitConversion(Initializer, Entity.getType(),
|
||
SuppressUserConversions,
|
||
AllowExplicitConversions,
|
||
InOverloadResolution);
|
||
if (ICS.isBad()) return true;
|
||
|
||
// Perform the actual conversion.
|
||
Sequence.AddConversionSequenceStep(ICS, Entity.getType());
|
||
return false;
|
||
}
|
||
|
||
InitializationSequence::InitializationSequence(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Expr **Args,
|
||
unsigned NumArgs)
|
||
: FailedCandidateSet(Kind.getLocation()) {
|
||
ASTContext &Context = S.Context;
|
||
|
||
// C++0x [dcl.init]p16:
|
||
// The semantics of initializers are as follows. The destination type is
|
||
// the type of the object or reference being initialized and the source
|
||
// type is the type of the initializer expression. The source type is not
|
||
// defined when the initializer is a braced-init-list or when it is a
|
||
// parenthesized list of expressions.
|
||
QualType DestType = Entity.getType();
|
||
|
||
if (DestType->isDependentType() ||
|
||
Expr::hasAnyTypeDependentArguments(Args, NumArgs)) {
|
||
SequenceKind = DependentSequence;
|
||
return;
|
||
}
|
||
|
||
QualType SourceType;
|
||
Expr *Initializer = 0;
|
||
if (NumArgs == 1) {
|
||
Initializer = Args[0];
|
||
if (!isa<InitListExpr>(Initializer))
|
||
SourceType = Initializer->getType();
|
||
}
|
||
|
||
// - If the initializer is a braced-init-list, the object is
|
||
// list-initialized (8.5.4).
|
||
if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
|
||
TryListInitialization(S, Entity, Kind, InitList, *this);
|
||
return;
|
||
}
|
||
|
||
// - If the destination type is a reference type, see 8.5.3.
|
||
if (DestType->isReferenceType()) {
|
||
// C++0x [dcl.init.ref]p1:
|
||
// A variable declared to be a T& or T&&, that is, "reference to type T"
|
||
// (8.3.2), shall be initialized by an object, or function, of type T or
|
||
// by an object that can be converted into a T.
|
||
// (Therefore, multiple arguments are not permitted.)
|
||
if (NumArgs != 1)
|
||
SetFailed(FK_TooManyInitsForReference);
|
||
else
|
||
TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
|
||
return;
|
||
}
|
||
|
||
// - If the destination type is an array of characters, an array of
|
||
// char16_t, an array of char32_t, or an array of wchar_t, and the
|
||
// initializer is a string literal, see 8.5.2.
|
||
if (Initializer && IsStringInit(Initializer, DestType, Context)) {
|
||
TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
|
||
return;
|
||
}
|
||
|
||
// - If the initializer is (), the object is value-initialized.
|
||
if (Kind.getKind() == InitializationKind::IK_Value ||
|
||
(Kind.getKind() == InitializationKind::IK_Direct && NumArgs == 0)) {
|
||
TryValueInitialization(S, Entity, Kind, *this);
|
||
return;
|
||
}
|
||
|
||
// Handle default initialization.
|
||
if (Kind.getKind() == InitializationKind::IK_Default){
|
||
TryDefaultInitialization(S, Entity, Kind, *this);
|
||
return;
|
||
}
|
||
|
||
// - Otherwise, if the destination type is an array, the program is
|
||
// ill-formed.
|
||
if (const ArrayType *AT = Context.getAsArrayType(DestType)) {
|
||
if (AT->getElementType()->isAnyCharacterType())
|
||
SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
|
||
else
|
||
SetFailed(FK_ArrayNeedsInitList);
|
||
|
||
return;
|
||
}
|
||
|
||
// Handle initialization in C
|
||
if (!S.getLangOptions().CPlusPlus) {
|
||
setSequenceKind(CAssignment);
|
||
AddCAssignmentStep(DestType);
|
||
return;
|
||
}
|
||
|
||
// - If the destination type is a (possibly cv-qualified) class type:
|
||
if (DestType->isRecordType()) {
|
||
// - If the initialization is direct-initialization, or if it is
|
||
// copy-initialization where the cv-unqualified version of the
|
||
// source type is the same class as, or a derived class of, the
|
||
// class of the destination, constructors are considered. [...]
|
||
if (Kind.getKind() == InitializationKind::IK_Direct ||
|
||
(Kind.getKind() == InitializationKind::IK_Copy &&
|
||
(Context.hasSameUnqualifiedType(SourceType, DestType) ||
|
||
S.IsDerivedFrom(SourceType, DestType))))
|
||
TryConstructorInitialization(S, Entity, Kind, Args, NumArgs,
|
||
Entity.getType(), *this);
|
||
// - Otherwise (i.e., for the remaining copy-initialization cases),
|
||
// user-defined conversion sequences that can convert from the source
|
||
// type to the destination type or (when a conversion function is
|
||
// used) to a derived class thereof are enumerated as described in
|
||
// 13.3.1.4, and the best one is chosen through overload resolution
|
||
// (13.3).
|
||
else
|
||
TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
|
||
return;
|
||
}
|
||
|
||
if (NumArgs > 1) {
|
||
SetFailed(FK_TooManyInitsForScalar);
|
||
return;
|
||
}
|
||
assert(NumArgs == 1 && "Zero-argument case handled above");
|
||
|
||
// - Otherwise, if the source type is a (possibly cv-qualified) class
|
||
// type, conversion functions are considered.
|
||
if (!SourceType.isNull() && SourceType->isRecordType()) {
|
||
TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
|
||
return;
|
||
}
|
||
|
||
// - Otherwise, the initial value of the object being initialized is the
|
||
// (possibly converted) value of the initializer expression. Standard
|
||
// conversions (Clause 4) will be used, if necessary, to convert the
|
||
// initializer expression to the cv-unqualified version of the
|
||
// destination type; no user-defined conversions are considered.
|
||
if (S.TryImplicitConversion(*this, Entity, Initializer,
|
||
/*SuppressUserConversions*/ true,
|
||
/*AllowExplicitConversions*/ false,
|
||
/*InOverloadResolution*/ false))
|
||
SetFailed(InitializationSequence::FK_ConversionFailed);
|
||
else
|
||
setSequenceKind(StandardConversion);
|
||
}
|
||
|
||
InitializationSequence::~InitializationSequence() {
|
||
for (llvm::SmallVectorImpl<Step>::iterator Step = Steps.begin(),
|
||
StepEnd = Steps.end();
|
||
Step != StepEnd; ++Step)
|
||
Step->Destroy();
|
||
}
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Perform initialization
|
||
//===----------------------------------------------------------------------===//
|
||
static Sema::AssignmentAction
|
||
getAssignmentAction(const InitializedEntity &Entity) {
|
||
switch(Entity.getKind()) {
|
||
case InitializedEntity::EK_Variable:
|
||
case InitializedEntity::EK_New:
|
||
return Sema::AA_Initializing;
|
||
|
||
case InitializedEntity::EK_Parameter:
|
||
if (Entity.getDecl() &&
|
||
isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
|
||
return Sema::AA_Sending;
|
||
|
||
return Sema::AA_Passing;
|
||
|
||
case InitializedEntity::EK_Result:
|
||
return Sema::AA_Returning;
|
||
|
||
case InitializedEntity::EK_Exception:
|
||
case InitializedEntity::EK_Base:
|
||
llvm_unreachable("No assignment action for C++-specific initialization");
|
||
break;
|
||
|
||
case InitializedEntity::EK_Temporary:
|
||
// FIXME: Can we tell apart casting vs. converting?
|
||
return Sema::AA_Casting;
|
||
|
||
case InitializedEntity::EK_Member:
|
||
case InitializedEntity::EK_ArrayElement:
|
||
case InitializedEntity::EK_VectorElement:
|
||
case InitializedEntity::EK_BlockElement:
|
||
return Sema::AA_Initializing;
|
||
}
|
||
|
||
return Sema::AA_Converting;
|
||
}
|
||
|
||
/// \brief Whether we should binding a created object as a temporary when
|
||
/// initializing the given entity.
|
||
static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
|
||
switch (Entity.getKind()) {
|
||
case InitializedEntity::EK_ArrayElement:
|
||
case InitializedEntity::EK_Member:
|
||
case InitializedEntity::EK_Result:
|
||
case InitializedEntity::EK_New:
|
||
case InitializedEntity::EK_Variable:
|
||
case InitializedEntity::EK_Base:
|
||
case InitializedEntity::EK_VectorElement:
|
||
case InitializedEntity::EK_Exception:
|
||
case InitializedEntity::EK_BlockElement:
|
||
return false;
|
||
|
||
case InitializedEntity::EK_Parameter:
|
||
case InitializedEntity::EK_Temporary:
|
||
return true;
|
||
}
|
||
|
||
llvm_unreachable("missed an InitializedEntity kind?");
|
||
}
|
||
|
||
/// \brief Whether the given entity, when initialized with an object
|
||
/// created for that initialization, requires destruction.
|
||
static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
|
||
switch (Entity.getKind()) {
|
||
case InitializedEntity::EK_Member:
|
||
case InitializedEntity::EK_Result:
|
||
case InitializedEntity::EK_New:
|
||
case InitializedEntity::EK_Base:
|
||
case InitializedEntity::EK_VectorElement:
|
||
case InitializedEntity::EK_BlockElement:
|
||
return false;
|
||
|
||
case InitializedEntity::EK_Variable:
|
||
case InitializedEntity::EK_Parameter:
|
||
case InitializedEntity::EK_Temporary:
|
||
case InitializedEntity::EK_ArrayElement:
|
||
case InitializedEntity::EK_Exception:
|
||
return true;
|
||
}
|
||
|
||
llvm_unreachable("missed an InitializedEntity kind?");
|
||
}
|
||
|
||
/// \brief Make a (potentially elidable) temporary copy of the object
|
||
/// provided by the given initializer by calling the appropriate copy
|
||
/// constructor.
|
||
///
|
||
/// \param S The Sema object used for type-checking.
|
||
///
|
||
/// \param T The type of the temporary object, which must either by
|
||
/// the type of the initializer expression or a superclass thereof.
|
||
///
|
||
/// \param Enter The entity being initialized.
|
||
///
|
||
/// \param CurInit The initializer expression.
|
||
///
|
||
/// \param IsExtraneousCopy Whether this is an "extraneous" copy that
|
||
/// is permitted in C++03 (but not C++0x) when binding a reference to
|
||
/// an rvalue.
|
||
///
|
||
/// \returns An expression that copies the initializer expression into
|
||
/// a temporary object, or an error expression if a copy could not be
|
||
/// created.
|
||
static Sema::OwningExprResult CopyObject(Sema &S,
|
||
QualType T,
|
||
const InitializedEntity &Entity,
|
||
Sema::OwningExprResult CurInit,
|
||
bool IsExtraneousCopy) {
|
||
// Determine which class type we're copying to.
|
||
Expr *CurInitExpr = (Expr *)CurInit.get();
|
||
CXXRecordDecl *Class = 0;
|
||
if (const RecordType *Record = T->getAs<RecordType>())
|
||
Class = cast<CXXRecordDecl>(Record->getDecl());
|
||
if (!Class)
|
||
return move(CurInit);
|
||
|
||
// C++0x [class.copy]p34:
|
||
// When certain criteria are met, an implementation is allowed to
|
||
// omit the copy/move construction of a class object, even if the
|
||
// copy/move constructor and/or destructor for the object have
|
||
// side effects. [...]
|
||
// - when a temporary class object that has not been bound to a
|
||
// reference (12.2) would be copied/moved to a class object
|
||
// with the same cv-unqualified type, the copy/move operation
|
||
// can be omitted by constructing the temporary object
|
||
// directly into the target of the omitted copy/move
|
||
//
|
||
// Note that the other three bullets are handled elsewhere. Copy
|
||
// elision for return statements and throw expressions are handled as part
|
||
// of constructor initialization, while copy elision for exception handlers
|
||
// is handled by the run-time.
|
||
bool Elidable = CurInitExpr->isTemporaryObject() &&
|
||
S.Context.hasSameUnqualifiedType(T, CurInitExpr->getType());
|
||
SourceLocation Loc;
|
||
switch (Entity.getKind()) {
|
||
case InitializedEntity::EK_Result:
|
||
Loc = Entity.getReturnLoc();
|
||
break;
|
||
|
||
case InitializedEntity::EK_Exception:
|
||
Loc = Entity.getThrowLoc();
|
||
break;
|
||
|
||
case InitializedEntity::EK_Variable:
|
||
Loc = Entity.getDecl()->getLocation();
|
||
break;
|
||
|
||
case InitializedEntity::EK_ArrayElement:
|
||
case InitializedEntity::EK_Member:
|
||
case InitializedEntity::EK_Parameter:
|
||
case InitializedEntity::EK_Temporary:
|
||
case InitializedEntity::EK_New:
|
||
case InitializedEntity::EK_Base:
|
||
case InitializedEntity::EK_VectorElement:
|
||
case InitializedEntity::EK_BlockElement:
|
||
Loc = CurInitExpr->getLocStart();
|
||
break;
|
||
}
|
||
|
||
// Make sure that the type we are copying is complete.
|
||
if (S.RequireCompleteType(Loc, T, S.PDiag(diag::err_temp_copy_incomplete)))
|
||
return move(CurInit);
|
||
|
||
// Perform overload resolution using the class's copy constructors.
|
||
DeclarationName ConstructorName
|
||
= S.Context.DeclarationNames.getCXXConstructorName(
|
||
S.Context.getCanonicalType(S.Context.getTypeDeclType(Class)));
|
||
DeclContext::lookup_iterator Con, ConEnd;
|
||
OverloadCandidateSet CandidateSet(Loc);
|
||
for (llvm::tie(Con, ConEnd) = Class->lookup(ConstructorName);
|
||
Con != ConEnd; ++Con) {
|
||
// Only consider copy constructors.
|
||
CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(*Con);
|
||
if (!Constructor || Constructor->isInvalidDecl() ||
|
||
!Constructor->isCopyConstructor() ||
|
||
!Constructor->isConvertingConstructor(/*AllowExplicit=*/false))
|
||
continue;
|
||
|
||
DeclAccessPair FoundDecl
|
||
= DeclAccessPair::make(Constructor, Constructor->getAccess());
|
||
S.AddOverloadCandidate(Constructor, FoundDecl,
|
||
&CurInitExpr, 1, CandidateSet);
|
||
}
|
||
|
||
OverloadCandidateSet::iterator Best;
|
||
switch (S.BestViableFunction(CandidateSet, Loc, Best)) {
|
||
case OR_Success:
|
||
break;
|
||
|
||
case OR_No_Viable_Function:
|
||
S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
|
||
? diag::ext_rvalue_to_reference_temp_copy_no_viable
|
||
: diag::err_temp_copy_no_viable)
|
||
<< (int)Entity.getKind() << CurInitExpr->getType()
|
||
<< CurInitExpr->getSourceRange();
|
||
S.PrintOverloadCandidates(CandidateSet, Sema::OCD_AllCandidates,
|
||
&CurInitExpr, 1);
|
||
if (!IsExtraneousCopy || S.isSFINAEContext())
|
||
return S.ExprError();
|
||
return move(CurInit);
|
||
|
||
case OR_Ambiguous:
|
||
S.Diag(Loc, diag::err_temp_copy_ambiguous)
|
||
<< (int)Entity.getKind() << CurInitExpr->getType()
|
||
<< CurInitExpr->getSourceRange();
|
||
S.PrintOverloadCandidates(CandidateSet, Sema::OCD_ViableCandidates,
|
||
&CurInitExpr, 1);
|
||
return S.ExprError();
|
||
|
||
case OR_Deleted:
|
||
S.Diag(Loc, diag::err_temp_copy_deleted)
|
||
<< (int)Entity.getKind() << CurInitExpr->getType()
|
||
<< CurInitExpr->getSourceRange();
|
||
S.Diag(Best->Function->getLocation(), diag::note_unavailable_here)
|
||
<< Best->Function->isDeleted();
|
||
return S.ExprError();
|
||
}
|
||
|
||
CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
|
||
ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S);
|
||
CurInit.release(); // Ownership transferred into MultiExprArg, below.
|
||
|
||
S.CheckConstructorAccess(Loc, Constructor, Entity,
|
||
Best->FoundDecl.getAccess(), IsExtraneousCopy);
|
||
|
||
if (IsExtraneousCopy) {
|
||
// If this is a totally extraneous copy for C++03 reference
|
||
// binding purposes, just return the original initialization
|
||
// expression. We don't generate an (elided) copy operation here
|
||
// because doing so would require us to pass down a flag to avoid
|
||
// infinite recursion, where each step adds another extraneous,
|
||
// elidable copy.
|
||
|
||
// Instantiate the default arguments of any extra parameters in
|
||
// the selected copy constructor, as if we were going to create a
|
||
// proper call to the copy constructor.
|
||
for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
|
||
ParmVarDecl *Parm = Constructor->getParamDecl(I);
|
||
if (S.RequireCompleteType(Loc, Parm->getType(),
|
||
S.PDiag(diag::err_call_incomplete_argument)))
|
||
break;
|
||
|
||
// Build the default argument expression; we don't actually care
|
||
// if this succeeds or not, because this routine will complain
|
||
// if there was a problem.
|
||
S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
|
||
}
|
||
|
||
return S.Owned(CurInitExpr);
|
||
}
|
||
|
||
// Determine the arguments required to actually perform the
|
||
// constructor call (we might have derived-to-base conversions, or
|
||
// the copy constructor may have default arguments).
|
||
if (S.CompleteConstructorCall(Constructor,
|
||
Sema::MultiExprArg(S,
|
||
(void **)&CurInitExpr,
|
||
1),
|
||
Loc, ConstructorArgs))
|
||
return S.ExprError();
|
||
|
||
// Actually perform the constructor call.
|
||
CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
|
||
move_arg(ConstructorArgs));
|
||
|
||
// If we're supposed to bind temporaries, do so.
|
||
if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
|
||
CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
|
||
return move(CurInit);
|
||
}
|
||
|
||
void InitializationSequence::PrintInitLocationNote(Sema &S,
|
||
const InitializedEntity &Entity) {
|
||
if (Entity.getKind() == InitializedEntity::EK_Parameter && Entity.getDecl()) {
|
||
if (Entity.getDecl()->getLocation().isInvalid())
|
||
return;
|
||
|
||
if (Entity.getDecl()->getDeclName())
|
||
S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
|
||
<< Entity.getDecl()->getDeclName();
|
||
else
|
||
S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
|
||
}
|
||
}
|
||
|
||
Action::OwningExprResult
|
||
InitializationSequence::Perform(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Action::MultiExprArg Args,
|
||
QualType *ResultType) {
|
||
if (SequenceKind == FailedSequence) {
|
||
unsigned NumArgs = Args.size();
|
||
Diagnose(S, Entity, Kind, (Expr **)Args.release(), NumArgs);
|
||
return S.ExprError();
|
||
}
|
||
|
||
if (SequenceKind == DependentSequence) {
|
||
// If the declaration is a non-dependent, incomplete array type
|
||
// that has an initializer, then its type will be completed once
|
||
// the initializer is instantiated.
|
||
if (ResultType && !Entity.getType()->isDependentType() &&
|
||
Args.size() == 1) {
|
||
QualType DeclType = Entity.getType();
|
||
if (const IncompleteArrayType *ArrayT
|
||
= S.Context.getAsIncompleteArrayType(DeclType)) {
|
||
// FIXME: We don't currently have the ability to accurately
|
||
// compute the length of an initializer list without
|
||
// performing full type-checking of the initializer list
|
||
// (since we have to determine where braces are implicitly
|
||
// introduced and such). So, we fall back to making the array
|
||
// type a dependently-sized array type with no specified
|
||
// bound.
|
||
if (isa<InitListExpr>((Expr *)Args.get()[0])) {
|
||
SourceRange Brackets;
|
||
|
||
// Scavange the location of the brackets from the entity, if we can.
|
||
if (DeclaratorDecl *DD = Entity.getDecl()) {
|
||
if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
|
||
TypeLoc TL = TInfo->getTypeLoc();
|
||
if (IncompleteArrayTypeLoc *ArrayLoc
|
||
= dyn_cast<IncompleteArrayTypeLoc>(&TL))
|
||
Brackets = ArrayLoc->getBracketsRange();
|
||
}
|
||
}
|
||
|
||
*ResultType
|
||
= S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
|
||
/*NumElts=*/0,
|
||
ArrayT->getSizeModifier(),
|
||
ArrayT->getIndexTypeCVRQualifiers(),
|
||
Brackets);
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
if (Kind.getKind() == InitializationKind::IK_Copy || Kind.isExplicitCast())
|
||
return Sema::OwningExprResult(S, Args.release()[0]);
|
||
|
||
if (Args.size() == 0)
|
||
return S.Owned((Expr *)0);
|
||
|
||
unsigned NumArgs = Args.size();
|
||
return S.Owned(new (S.Context) ParenListExpr(S.Context,
|
||
SourceLocation(),
|
||
(Expr **)Args.release(),
|
||
NumArgs,
|
||
SourceLocation()));
|
||
}
|
||
|
||
if (SequenceKind == NoInitialization)
|
||
return S.Owned((Expr *)0);
|
||
|
||
QualType DestType = Entity.getType().getNonReferenceType();
|
||
// FIXME: Ugly hack around the fact that Entity.getType() is not
|
||
// the same as Entity.getDecl()->getType() in cases involving type merging,
|
||
// and we want latter when it makes sense.
|
||
if (ResultType)
|
||
*ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
|
||
Entity.getType();
|
||
|
||
Sema::OwningExprResult CurInit = S.Owned((Expr *)0);
|
||
|
||
assert(!Steps.empty() && "Cannot have an empty initialization sequence");
|
||
|
||
// For initialization steps that start with a single initializer,
|
||
// grab the only argument out the Args and place it into the "current"
|
||
// initializer.
|
||
switch (Steps.front().Kind) {
|
||
case SK_ResolveAddressOfOverloadedFunction:
|
||
case SK_CastDerivedToBaseRValue:
|
||
case SK_CastDerivedToBaseLValue:
|
||
case SK_BindReference:
|
||
case SK_BindReferenceToTemporary:
|
||
case SK_ExtraneousCopyToTemporary:
|
||
case SK_UserConversion:
|
||
case SK_QualificationConversionLValue:
|
||
case SK_QualificationConversionRValue:
|
||
case SK_ConversionSequence:
|
||
case SK_ListInitialization:
|
||
case SK_CAssignment:
|
||
case SK_StringInit:
|
||
assert(Args.size() == 1);
|
||
CurInit = Sema::OwningExprResult(S, ((Expr **)(Args.get()))[0]->Retain());
|
||
if (CurInit.isInvalid())
|
||
return S.ExprError();
|
||
break;
|
||
|
||
case SK_ConstructorInitialization:
|
||
case SK_ZeroInitialization:
|
||
break;
|
||
}
|
||
|
||
// Walk through the computed steps for the initialization sequence,
|
||
// performing the specified conversions along the way.
|
||
bool ConstructorInitRequiresZeroInit = false;
|
||
for (step_iterator Step = step_begin(), StepEnd = step_end();
|
||
Step != StepEnd; ++Step) {
|
||
if (CurInit.isInvalid())
|
||
return S.ExprError();
|
||
|
||
Expr *CurInitExpr = (Expr *)CurInit.get();
|
||
QualType SourceType = CurInitExpr? CurInitExpr->getType() : QualType();
|
||
|
||
switch (Step->Kind) {
|
||
case SK_ResolveAddressOfOverloadedFunction:
|
||
// Overload resolution determined which function invoke; update the
|
||
// initializer to reflect that choice.
|
||
S.CheckAddressOfMemberAccess(CurInitExpr, Step->Function.FoundDecl);
|
||
S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation());
|
||
CurInit = S.FixOverloadedFunctionReference(move(CurInit),
|
||
Step->Function.FoundDecl,
|
||
Step->Function.Function);
|
||
break;
|
||
|
||
case SK_CastDerivedToBaseRValue:
|
||
case SK_CastDerivedToBaseLValue: {
|
||
// We have a derived-to-base cast that produces either an rvalue or an
|
||
// lvalue. Perform that cast.
|
||
|
||
CXXBaseSpecifierArray BasePath;
|
||
|
||
// Casts to inaccessible base classes are allowed with C-style casts.
|
||
bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
|
||
if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
|
||
CurInitExpr->getLocStart(),
|
||
CurInitExpr->getSourceRange(),
|
||
&BasePath, IgnoreBaseAccess))
|
||
return S.ExprError();
|
||
|
||
if (S.BasePathInvolvesVirtualBase(BasePath)) {
|
||
QualType T = SourceType;
|
||
if (const PointerType *Pointer = T->getAs<PointerType>())
|
||
T = Pointer->getPointeeType();
|
||
if (const RecordType *RecordTy = T->getAs<RecordType>())
|
||
S.MarkVTableUsed(CurInitExpr->getLocStart(),
|
||
cast<CXXRecordDecl>(RecordTy->getDecl()));
|
||
}
|
||
|
||
CurInit = S.Owned(new (S.Context) ImplicitCastExpr(Step->Type,
|
||
CastExpr::CK_DerivedToBase,
|
||
(Expr*)CurInit.release(),
|
||
BasePath,
|
||
Step->Kind == SK_CastDerivedToBaseLValue));
|
||
break;
|
||
}
|
||
|
||
case SK_BindReference:
|
||
if (FieldDecl *BitField = CurInitExpr->getBitField()) {
|
||
// References cannot bind to bit fields (C++ [dcl.init.ref]p5).
|
||
S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
|
||
<< Entity.getType().isVolatileQualified()
|
||
<< BitField->getDeclName()
|
||
<< CurInitExpr->getSourceRange();
|
||
S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
|
||
return S.ExprError();
|
||
}
|
||
|
||
if (CurInitExpr->refersToVectorElement()) {
|
||
// References cannot bind to vector elements.
|
||
S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
|
||
<< Entity.getType().isVolatileQualified()
|
||
<< CurInitExpr->getSourceRange();
|
||
PrintInitLocationNote(S, Entity);
|
||
return S.ExprError();
|
||
}
|
||
|
||
// Reference binding does not have any corresponding ASTs.
|
||
|
||
// Check exception specifications
|
||
if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
|
||
return S.ExprError();
|
||
|
||
break;
|
||
|
||
case SK_BindReferenceToTemporary:
|
||
// Reference binding does not have any corresponding ASTs.
|
||
|
||
// Check exception specifications
|
||
if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
|
||
return S.ExprError();
|
||
|
||
break;
|
||
|
||
case SK_ExtraneousCopyToTemporary:
|
||
CurInit = CopyObject(S, Step->Type, Entity, move(CurInit),
|
||
/*IsExtraneousCopy=*/true);
|
||
break;
|
||
|
||
case SK_UserConversion: {
|
||
// We have a user-defined conversion that invokes either a constructor
|
||
// or a conversion function.
|
||
CastExpr::CastKind CastKind = CastExpr::CK_Unknown;
|
||
bool IsCopy = false;
|
||
FunctionDecl *Fn = Step->Function.Function;
|
||
DeclAccessPair FoundFn = Step->Function.FoundDecl;
|
||
bool CreatedObject = false;
|
||
bool IsLvalue = false;
|
||
if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
|
||
// Build a call to the selected constructor.
|
||
ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S);
|
||
SourceLocation Loc = CurInitExpr->getLocStart();
|
||
CurInit.release(); // Ownership transferred into MultiExprArg, below.
|
||
|
||
// Determine the arguments required to actually perform the constructor
|
||
// call.
|
||
if (S.CompleteConstructorCall(Constructor,
|
||
Sema::MultiExprArg(S,
|
||
(void **)&CurInitExpr,
|
||
1),
|
||
Loc, ConstructorArgs))
|
||
return S.ExprError();
|
||
|
||
// Build the an expression that constructs a temporary.
|
||
CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
|
||
move_arg(ConstructorArgs));
|
||
if (CurInit.isInvalid())
|
||
return S.ExprError();
|
||
|
||
S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
|
||
FoundFn.getAccess());
|
||
S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation());
|
||
|
||
CastKind = CastExpr::CK_ConstructorConversion;
|
||
QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
|
||
if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
|
||
S.IsDerivedFrom(SourceType, Class))
|
||
IsCopy = true;
|
||
|
||
CreatedObject = true;
|
||
} else {
|
||
// Build a call to the conversion function.
|
||
CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
|
||
IsLvalue = Conversion->getResultType()->isLValueReferenceType();
|
||
S.CheckMemberOperatorAccess(Kind.getLocation(), CurInitExpr, 0,
|
||
FoundFn);
|
||
S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation());
|
||
|
||
// FIXME: Should we move this initialization into a separate
|
||
// derived-to-base conversion? I believe the answer is "no", because
|
||
// we don't want to turn off access control here for c-style casts.
|
||
if (S.PerformObjectArgumentInitialization(CurInitExpr, /*Qualifier=*/0,
|
||
FoundFn, Conversion))
|
||
return S.ExprError();
|
||
|
||
// Do a little dance to make sure that CurInit has the proper
|
||
// pointer.
|
||
CurInit.release();
|
||
|
||
// Build the actual call to the conversion function.
|
||
CurInit = S.Owned(S.BuildCXXMemberCallExpr(CurInitExpr, FoundFn,
|
||
Conversion));
|
||
if (CurInit.isInvalid() || !CurInit.get())
|
||
return S.ExprError();
|
||
|
||
CastKind = CastExpr::CK_UserDefinedConversion;
|
||
|
||
CreatedObject = Conversion->getResultType()->isRecordType();
|
||
}
|
||
|
||
bool RequiresCopy = !IsCopy &&
|
||
getKind() != InitializationSequence::ReferenceBinding;
|
||
if (RequiresCopy || shouldBindAsTemporary(Entity))
|
||
CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
|
||
else if (CreatedObject && shouldDestroyTemporary(Entity)) {
|
||
CurInitExpr = static_cast<Expr *>(CurInit.get());
|
||
QualType T = CurInitExpr->getType();
|
||
if (const RecordType *Record = T->getAs<RecordType>()) {
|
||
CXXDestructorDecl *Destructor
|
||
= cast<CXXRecordDecl>(Record->getDecl())->getDestructor(S.Context);
|
||
S.CheckDestructorAccess(CurInitExpr->getLocStart(), Destructor,
|
||
S.PDiag(diag::err_access_dtor_temp) << T);
|
||
S.MarkDeclarationReferenced(CurInitExpr->getLocStart(), Destructor);
|
||
}
|
||
}
|
||
|
||
CurInitExpr = CurInit.takeAs<Expr>();
|
||
CurInit = S.Owned(new (S.Context) ImplicitCastExpr(CurInitExpr->getType(),
|
||
CastKind,
|
||
CurInitExpr,
|
||
CXXBaseSpecifierArray(),
|
||
IsLvalue));
|
||
|
||
if (RequiresCopy)
|
||
CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
|
||
move(CurInit), /*IsExtraneousCopy=*/false);
|
||
|
||
break;
|
||
}
|
||
|
||
case SK_QualificationConversionLValue:
|
||
case SK_QualificationConversionRValue:
|
||
// Perform a qualification conversion; these can never go wrong.
|
||
S.ImpCastExprToType(CurInitExpr, Step->Type,
|
||
CastExpr::CK_NoOp,
|
||
Step->Kind == SK_QualificationConversionLValue);
|
||
CurInit.release();
|
||
CurInit = S.Owned(CurInitExpr);
|
||
break;
|
||
|
||
case SK_ConversionSequence: {
|
||
bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
|
||
|
||
if (S.PerformImplicitConversion(CurInitExpr, Step->Type, *Step->ICS,
|
||
Sema::AA_Converting, IgnoreBaseAccess))
|
||
return S.ExprError();
|
||
|
||
CurInit.release();
|
||
CurInit = S.Owned(CurInitExpr);
|
||
break;
|
||
}
|
||
|
||
case SK_ListInitialization: {
|
||
InitListExpr *InitList = cast<InitListExpr>(CurInitExpr);
|
||
QualType Ty = Step->Type;
|
||
if (S.CheckInitList(Entity, InitList, ResultType? *ResultType : Ty))
|
||
return S.ExprError();
|
||
|
||
CurInit.release();
|
||
CurInit = S.Owned(InitList);
|
||
break;
|
||
}
|
||
|
||
case SK_ConstructorInitialization: {
|
||
unsigned NumArgs = Args.size();
|
||
CXXConstructorDecl *Constructor
|
||
= cast<CXXConstructorDecl>(Step->Function.Function);
|
||
|
||
// Build a call to the selected constructor.
|
||
ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S);
|
||
SourceLocation Loc = Kind.getLocation();
|
||
|
||
// Determine the arguments required to actually perform the constructor
|
||
// call.
|
||
if (S.CompleteConstructorCall(Constructor, move(Args),
|
||
Loc, ConstructorArgs))
|
||
return S.ExprError();
|
||
|
||
// Build the expression that constructs a temporary.
|
||
if (Entity.getKind() == InitializedEntity::EK_Temporary &&
|
||
NumArgs != 1 && // FIXME: Hack to work around cast weirdness
|
||
(Kind.getKind() == InitializationKind::IK_Direct ||
|
||
Kind.getKind() == InitializationKind::IK_Value)) {
|
||
// An explicitly-constructed temporary, e.g., X(1, 2).
|
||
unsigned NumExprs = ConstructorArgs.size();
|
||
Expr **Exprs = (Expr **)ConstructorArgs.take();
|
||
S.MarkDeclarationReferenced(Kind.getLocation(), Constructor);
|
||
CurInit = S.Owned(new (S.Context) CXXTemporaryObjectExpr(S.Context,
|
||
Constructor,
|
||
Entity.getType(),
|
||
Kind.getLocation(),
|
||
Exprs,
|
||
NumExprs,
|
||
Kind.getParenRange().getEnd(),
|
||
ConstructorInitRequiresZeroInit));
|
||
} else {
|
||
CXXConstructExpr::ConstructionKind ConstructKind =
|
||
CXXConstructExpr::CK_Complete;
|
||
|
||
if (Entity.getKind() == InitializedEntity::EK_Base) {
|
||
ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
|
||
CXXConstructExpr::CK_VirtualBase :
|
||
CXXConstructExpr::CK_NonVirtualBase;
|
||
}
|
||
|
||
// If the entity allows NRVO, mark the construction as elidable
|
||
// unconditionally.
|
||
if (Entity.allowsNRVO())
|
||
CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
|
||
Constructor, /*Elidable=*/true,
|
||
move_arg(ConstructorArgs),
|
||
ConstructorInitRequiresZeroInit,
|
||
ConstructKind);
|
||
else
|
||
CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
|
||
Constructor,
|
||
move_arg(ConstructorArgs),
|
||
ConstructorInitRequiresZeroInit,
|
||
ConstructKind);
|
||
}
|
||
if (CurInit.isInvalid())
|
||
return S.ExprError();
|
||
|
||
// Only check access if all of that succeeded.
|
||
S.CheckConstructorAccess(Loc, Constructor, Entity,
|
||
Step->Function.FoundDecl.getAccess());
|
||
S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Loc);
|
||
|
||
if (shouldBindAsTemporary(Entity))
|
||
CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
|
||
|
||
break;
|
||
}
|
||
|
||
case SK_ZeroInitialization: {
|
||
step_iterator NextStep = Step;
|
||
++NextStep;
|
||
if (NextStep != StepEnd &&
|
||
NextStep->Kind == SK_ConstructorInitialization) {
|
||
// The need for zero-initialization is recorded directly into
|
||
// the call to the object's constructor within the next step.
|
||
ConstructorInitRequiresZeroInit = true;
|
||
} else if (Kind.getKind() == InitializationKind::IK_Value &&
|
||
S.getLangOptions().CPlusPlus &&
|
||
!Kind.isImplicitValueInit()) {
|
||
CurInit = S.Owned(new (S.Context) CXXZeroInitValueExpr(Step->Type,
|
||
Kind.getRange().getBegin(),
|
||
Kind.getRange().getEnd()));
|
||
} else {
|
||
CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type));
|
||
}
|
||
break;
|
||
}
|
||
|
||
case SK_CAssignment: {
|
||
QualType SourceType = CurInitExpr->getType();
|
||
Sema::AssignConvertType ConvTy =
|
||
S.CheckSingleAssignmentConstraints(Step->Type, CurInitExpr);
|
||
|
||
// If this is a call, allow conversion to a transparent union.
|
||
if (ConvTy != Sema::Compatible &&
|
||
Entity.getKind() == InitializedEntity::EK_Parameter &&
|
||
S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExpr)
|
||
== Sema::Compatible)
|
||
ConvTy = Sema::Compatible;
|
||
|
||
bool Complained;
|
||
if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
|
||
Step->Type, SourceType,
|
||
CurInitExpr,
|
||
getAssignmentAction(Entity),
|
||
&Complained)) {
|
||
PrintInitLocationNote(S, Entity);
|
||
return S.ExprError();
|
||
} else if (Complained)
|
||
PrintInitLocationNote(S, Entity);
|
||
|
||
CurInit.release();
|
||
CurInit = S.Owned(CurInitExpr);
|
||
break;
|
||
}
|
||
|
||
case SK_StringInit: {
|
||
QualType Ty = Step->Type;
|
||
CheckStringInit(CurInitExpr, ResultType ? *ResultType : Ty, S);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return move(CurInit);
|
||
}
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Diagnose initialization failures
|
||
//===----------------------------------------------------------------------===//
|
||
bool InitializationSequence::Diagnose(Sema &S,
|
||
const InitializedEntity &Entity,
|
||
const InitializationKind &Kind,
|
||
Expr **Args, unsigned NumArgs) {
|
||
if (SequenceKind != FailedSequence)
|
||
return false;
|
||
|
||
QualType DestType = Entity.getType();
|
||
switch (Failure) {
|
||
case FK_TooManyInitsForReference:
|
||
// FIXME: Customize for the initialized entity?
|
||
if (NumArgs == 0)
|
||
S.Diag(Kind.getLocation(), diag::err_reference_without_init)
|
||
<< DestType.getNonReferenceType();
|
||
else // FIXME: diagnostic below could be better!
|
||
S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
|
||
<< SourceRange(Args[0]->getLocStart(), Args[NumArgs - 1]->getLocEnd());
|
||
break;
|
||
|
||
case FK_ArrayNeedsInitList:
|
||
case FK_ArrayNeedsInitListOrStringLiteral:
|
||
S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list)
|
||
<< (Failure == FK_ArrayNeedsInitListOrStringLiteral);
|
||
break;
|
||
|
||
case FK_AddressOfOverloadFailed: {
|
||
DeclAccessPair Found;
|
||
S.ResolveAddressOfOverloadedFunction(Args[0],
|
||
DestType.getNonReferenceType(),
|
||
true,
|
||
Found);
|
||
break;
|
||
}
|
||
|
||
case FK_ReferenceInitOverloadFailed:
|
||
case FK_UserConversionOverloadFailed:
|
||
switch (FailedOverloadResult) {
|
||
case OR_Ambiguous:
|
||
if (Failure == FK_UserConversionOverloadFailed)
|
||
S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
|
||
<< Args[0]->getType() << DestType
|
||
<< Args[0]->getSourceRange();
|
||
else
|
||
S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
|
||
<< DestType << Args[0]->getType()
|
||
<< Args[0]->getSourceRange();
|
||
|
||
S.PrintOverloadCandidates(FailedCandidateSet, Sema::OCD_ViableCandidates,
|
||
Args, NumArgs);
|
||
break;
|
||
|
||
case OR_No_Viable_Function:
|
||
S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
|
||
<< Args[0]->getType() << DestType.getNonReferenceType()
|
||
<< Args[0]->getSourceRange();
|
||
S.PrintOverloadCandidates(FailedCandidateSet, Sema::OCD_AllCandidates,
|
||
Args, NumArgs);
|
||
break;
|
||
|
||
case OR_Deleted: {
|
||
S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
|
||
<< Args[0]->getType() << DestType.getNonReferenceType()
|
||
<< Args[0]->getSourceRange();
|
||
OverloadCandidateSet::iterator Best;
|
||
OverloadingResult Ovl = S.BestViableFunction(FailedCandidateSet,
|
||
Kind.getLocation(),
|
||
Best);
|
||
if (Ovl == OR_Deleted) {
|
||
S.Diag(Best->Function->getLocation(), diag::note_unavailable_here)
|
||
<< Best->Function->isDeleted();
|
||
} else {
|
||
llvm_unreachable("Inconsistent overload resolution?");
|
||
}
|
||
break;
|
||
}
|
||
|
||
case OR_Success:
|
||
llvm_unreachable("Conversion did not fail!");
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FK_NonConstLValueReferenceBindingToTemporary:
|
||
case FK_NonConstLValueReferenceBindingToUnrelated:
|
||
S.Diag(Kind.getLocation(),
|
||
Failure == FK_NonConstLValueReferenceBindingToTemporary
|
||
? diag::err_lvalue_reference_bind_to_temporary
|
||
: diag::err_lvalue_reference_bind_to_unrelated)
|
||
<< DestType.getNonReferenceType().isVolatileQualified()
|
||
<< DestType.getNonReferenceType()
|
||
<< Args[0]->getType()
|
||
<< Args[0]->getSourceRange();
|
||
break;
|
||
|
||
case FK_RValueReferenceBindingToLValue:
|
||
S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
|
||
<< Args[0]->getSourceRange();
|
||
break;
|
||
|
||
case FK_ReferenceInitDropsQualifiers:
|
||
S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
|
||
<< DestType.getNonReferenceType()
|
||
<< Args[0]->getType()
|
||
<< Args[0]->getSourceRange();
|
||
break;
|
||
|
||
case FK_ReferenceInitFailed:
|
||
S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
|
||
<< DestType.getNonReferenceType()
|
||
<< (Args[0]->isLvalue(S.Context) == Expr::LV_Valid)
|
||
<< Args[0]->getType()
|
||
<< Args[0]->getSourceRange();
|
||
break;
|
||
|
||
case FK_ConversionFailed:
|
||
S.Diag(Kind.getLocation(), diag::err_init_conversion_failed)
|
||
<< (int)Entity.getKind()
|
||
<< DestType
|
||
<< (Args[0]->isLvalue(S.Context) == Expr::LV_Valid)
|
||
<< Args[0]->getType()
|
||
<< Args[0]->getSourceRange();
|
||
break;
|
||
|
||
case FK_TooManyInitsForScalar: {
|
||
SourceRange R;
|
||
|
||
if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
|
||
R = SourceRange(InitList->getInit(1)->getLocStart(),
|
||
InitList->getLocEnd());
|
||
else
|
||
R = SourceRange(Args[0]->getLocStart(), Args[NumArgs - 1]->getLocEnd());
|
||
|
||
S.Diag(Kind.getLocation(), diag::err_excess_initializers)
|
||
<< /*scalar=*/2 << R;
|
||
break;
|
||
}
|
||
|
||
case FK_ReferenceBindingToInitList:
|
||
S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
|
||
<< DestType.getNonReferenceType() << Args[0]->getSourceRange();
|
||
break;
|
||
|
||
case FK_InitListBadDestinationType:
|
||
S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
|
||
<< (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
|
||
break;
|
||
|
||
case FK_ConstructorOverloadFailed: {
|
||
SourceRange ArgsRange;
|
||
if (NumArgs)
|
||
ArgsRange = SourceRange(Args[0]->getLocStart(),
|
||
Args[NumArgs - 1]->getLocEnd());
|
||
|
||
// FIXME: Using "DestType" for the entity we're printing is probably
|
||
// bad.
|
||
switch (FailedOverloadResult) {
|
||
case OR_Ambiguous:
|
||
S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
|
||
<< DestType << ArgsRange;
|
||
S.PrintOverloadCandidates(FailedCandidateSet,
|
||
Sema::OCD_ViableCandidates, Args, NumArgs);
|
||
break;
|
||
|
||
case OR_No_Viable_Function:
|
||
if (Kind.getKind() == InitializationKind::IK_Default &&
|
||
(Entity.getKind() == InitializedEntity::EK_Base ||
|
||
Entity.getKind() == InitializedEntity::EK_Member) &&
|
||
isa<CXXConstructorDecl>(S.CurContext)) {
|
||
// This is implicit default initialization of a member or
|
||
// base within a constructor. If no viable function was
|
||
// found, notify the user that she needs to explicitly
|
||
// initialize this base/member.
|
||
CXXConstructorDecl *Constructor
|
||
= cast<CXXConstructorDecl>(S.CurContext);
|
||
if (Entity.getKind() == InitializedEntity::EK_Base) {
|
||
S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
|
||
<< Constructor->isImplicit()
|
||
<< S.Context.getTypeDeclType(Constructor->getParent())
|
||
<< /*base=*/0
|
||
<< Entity.getType();
|
||
|
||
RecordDecl *BaseDecl
|
||
= Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
|
||
->getDecl();
|
||
S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
|
||
<< S.Context.getTagDeclType(BaseDecl);
|
||
} else {
|
||
S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
|
||
<< Constructor->isImplicit()
|
||
<< S.Context.getTypeDeclType(Constructor->getParent())
|
||
<< /*member=*/1
|
||
<< Entity.getName();
|
||
S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl);
|
||
|
||
if (const RecordType *Record
|
||
= Entity.getType()->getAs<RecordType>())
|
||
S.Diag(Record->getDecl()->getLocation(),
|
||
diag::note_previous_decl)
|
||
<< S.Context.getTagDeclType(Record->getDecl());
|
||
}
|
||
break;
|
||
}
|
||
|
||
S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
|
||
<< DestType << ArgsRange;
|
||
S.PrintOverloadCandidates(FailedCandidateSet, Sema::OCD_AllCandidates,
|
||
Args, NumArgs);
|
||
break;
|
||
|
||
case OR_Deleted: {
|
||
S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
|
||
<< true << DestType << ArgsRange;
|
||
OverloadCandidateSet::iterator Best;
|
||
OverloadingResult Ovl = S.BestViableFunction(FailedCandidateSet,
|
||
Kind.getLocation(),
|
||
Best);
|
||
if (Ovl == OR_Deleted) {
|
||
S.Diag(Best->Function->getLocation(), diag::note_unavailable_here)
|
||
<< Best->Function->isDeleted();
|
||
} else {
|
||
llvm_unreachable("Inconsistent overload resolution?");
|
||
}
|
||
break;
|
||
}
|
||
|
||
case OR_Success:
|
||
llvm_unreachable("Conversion did not fail!");
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case FK_DefaultInitOfConst:
|
||
if (Entity.getKind() == InitializedEntity::EK_Member &&
|
||
isa<CXXConstructorDecl>(S.CurContext)) {
|
||
// This is implicit default-initialization of a const member in
|
||
// a constructor. Complain that it needs to be explicitly
|
||
// initialized.
|
||
CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
|
||
S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
|
||
<< Constructor->isImplicit()
|
||
<< S.Context.getTypeDeclType(Constructor->getParent())
|
||
<< /*const=*/1
|
||
<< Entity.getName();
|
||
S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
|
||
<< Entity.getName();
|
||
} else {
|
||
S.Diag(Kind.getLocation(), diag::err_default_init_const)
|
||
<< DestType << (bool)DestType->getAs<RecordType>();
|
||
}
|
||
break;
|
||
|
||
case FK_Incomplete:
|
||
S.RequireCompleteType(Kind.getLocation(), DestType,
|
||
diag::err_init_incomplete_type);
|
||
break;
|
||
}
|
||
|
||
PrintInitLocationNote(S, Entity);
|
||
return true;
|
||
}
|
||
|
||
void InitializationSequence::dump(llvm::raw_ostream &OS) const {
|
||
switch (SequenceKind) {
|
||
case FailedSequence: {
|
||
OS << "Failed sequence: ";
|
||
switch (Failure) {
|
||
case FK_TooManyInitsForReference:
|
||
OS << "too many initializers for reference";
|
||
break;
|
||
|
||
case FK_ArrayNeedsInitList:
|
||
OS << "array requires initializer list";
|
||
break;
|
||
|
||
case FK_ArrayNeedsInitListOrStringLiteral:
|
||
OS << "array requires initializer list or string literal";
|
||
break;
|
||
|
||
case FK_AddressOfOverloadFailed:
|
||
OS << "address of overloaded function failed";
|
||
break;
|
||
|
||
case FK_ReferenceInitOverloadFailed:
|
||
OS << "overload resolution for reference initialization failed";
|
||
break;
|
||
|
||
case FK_NonConstLValueReferenceBindingToTemporary:
|
||
OS << "non-const lvalue reference bound to temporary";
|
||
break;
|
||
|
||
case FK_NonConstLValueReferenceBindingToUnrelated:
|
||
OS << "non-const lvalue reference bound to unrelated type";
|
||
break;
|
||
|
||
case FK_RValueReferenceBindingToLValue:
|
||
OS << "rvalue reference bound to an lvalue";
|
||
break;
|
||
|
||
case FK_ReferenceInitDropsQualifiers:
|
||
OS << "reference initialization drops qualifiers";
|
||
break;
|
||
|
||
case FK_ReferenceInitFailed:
|
||
OS << "reference initialization failed";
|
||
break;
|
||
|
||
case FK_ConversionFailed:
|
||
OS << "conversion failed";
|
||
break;
|
||
|
||
case FK_TooManyInitsForScalar:
|
||
OS << "too many initializers for scalar";
|
||
break;
|
||
|
||
case FK_ReferenceBindingToInitList:
|
||
OS << "referencing binding to initializer list";
|
||
break;
|
||
|
||
case FK_InitListBadDestinationType:
|
||
OS << "initializer list for non-aggregate, non-scalar type";
|
||
break;
|
||
|
||
case FK_UserConversionOverloadFailed:
|
||
OS << "overloading failed for user-defined conversion";
|
||
break;
|
||
|
||
case FK_ConstructorOverloadFailed:
|
||
OS << "constructor overloading failed";
|
||
break;
|
||
|
||
case FK_DefaultInitOfConst:
|
||
OS << "default initialization of a const variable";
|
||
break;
|
||
|
||
case FK_Incomplete:
|
||
OS << "initialization of incomplete type";
|
||
break;
|
||
}
|
||
OS << '\n';
|
||
return;
|
||
}
|
||
|
||
case DependentSequence:
|
||
OS << "Dependent sequence: ";
|
||
return;
|
||
|
||
case UserDefinedConversion:
|
||
OS << "User-defined conversion sequence: ";
|
||
break;
|
||
|
||
case ConstructorInitialization:
|
||
OS << "Constructor initialization sequence: ";
|
||
break;
|
||
|
||
case ReferenceBinding:
|
||
OS << "Reference binding: ";
|
||
break;
|
||
|
||
case ListInitialization:
|
||
OS << "List initialization: ";
|
||
break;
|
||
|
||
case ZeroInitialization:
|
||
OS << "Zero initialization\n";
|
||
return;
|
||
|
||
case NoInitialization:
|
||
OS << "No initialization\n";
|
||
return;
|
||
|
||
case StandardConversion:
|
||
OS << "Standard conversion: ";
|
||
break;
|
||
|
||
case CAssignment:
|
||
OS << "C assignment: ";
|
||
break;
|
||
|
||
case StringInit:
|
||
OS << "String initialization: ";
|
||
break;
|
||
}
|
||
|
||
for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
|
||
if (S != step_begin()) {
|
||
OS << " -> ";
|
||
}
|
||
|
||
switch (S->Kind) {
|
||
case SK_ResolveAddressOfOverloadedFunction:
|
||
OS << "resolve address of overloaded function";
|
||
break;
|
||
|
||
case SK_CastDerivedToBaseRValue:
|
||
OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
|
||
break;
|
||
|
||
case SK_CastDerivedToBaseLValue:
|
||
OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
|
||
break;
|
||
|
||
case SK_BindReference:
|
||
OS << "bind reference to lvalue";
|
||
break;
|
||
|
||
case SK_BindReferenceToTemporary:
|
||
OS << "bind reference to a temporary";
|
||
break;
|
||
|
||
case SK_ExtraneousCopyToTemporary:
|
||
OS << "extraneous C++03 copy to temporary";
|
||
break;
|
||
|
||
case SK_UserConversion:
|
||
OS << "user-defined conversion via " << S->Function.Function;
|
||
break;
|
||
|
||
case SK_QualificationConversionRValue:
|
||
OS << "qualification conversion (rvalue)";
|
||
|
||
case SK_QualificationConversionLValue:
|
||
OS << "qualification conversion (lvalue)";
|
||
break;
|
||
|
||
case SK_ConversionSequence:
|
||
OS << "implicit conversion sequence (";
|
||
S->ICS->DebugPrint(); // FIXME: use OS
|
||
OS << ")";
|
||
break;
|
||
|
||
case SK_ListInitialization:
|
||
OS << "list initialization";
|
||
break;
|
||
|
||
case SK_ConstructorInitialization:
|
||
OS << "constructor initialization";
|
||
break;
|
||
|
||
case SK_ZeroInitialization:
|
||
OS << "zero initialization";
|
||
break;
|
||
|
||
case SK_CAssignment:
|
||
OS << "C assignment";
|
||
break;
|
||
|
||
case SK_StringInit:
|
||
OS << "string initialization";
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void InitializationSequence::dump() const {
|
||
dump(llvm::errs());
|
||
}
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Initialization helper functions
|
||
//===----------------------------------------------------------------------===//
|
||
Sema::OwningExprResult
|
||
Sema::PerformCopyInitialization(const InitializedEntity &Entity,
|
||
SourceLocation EqualLoc,
|
||
OwningExprResult Init) {
|
||
if (Init.isInvalid())
|
||
return ExprError();
|
||
|
||
Expr *InitE = (Expr *)Init.get();
|
||
assert(InitE && "No initialization expression?");
|
||
|
||
if (EqualLoc.isInvalid())
|
||
EqualLoc = InitE->getLocStart();
|
||
|
||
InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
|
||
EqualLoc);
|
||
InitializationSequence Seq(*this, Entity, Kind, &InitE, 1);
|
||
Init.release();
|
||
return Seq.Perform(*this, Entity, Kind,
|
||
MultiExprArg(*this, (void**)&InitE, 1));
|
||
}
|