[cfe-commits] r132667 - in /cfe/trunk: include/clang/Sema/Initialization.h lib/Sema/SemaInit.cpp
Sebastian Redl
sebastian.redl at getdesigned.at
Sun Jun 5 06:59:11 PDT 2011
Author: cornedbee
Date: Sun Jun 5 08:59:11 2011
New Revision: 132667
URL: http://llvm.org/viewvc/llvm-project?rev=132667&view=rev
Log:
Drop most of InitializationSequence::SequenceKind's values. They didn't really contain any information that the step array didn't contain too. This makes debugging dumps a bit less informative, but probably not significantly so. The advantage is that the redundancy is gone, so the code is easier to understand.
ReferenceBinding is still there, because it is used in some unclear code.
Modified:
cfe/trunk/include/clang/Sema/Initialization.h
cfe/trunk/lib/Sema/SemaInit.cpp
Modified: cfe/trunk/include/clang/Sema/Initialization.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Initialization.h?rev=132667&r1=132666&r2=132667&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/Initialization.h (original)
+++ cfe/trunk/include/clang/Sema/Initialization.h Sun Jun 5 08:59:11 2011
@@ -437,48 +437,21 @@
class InitializationSequence {
public:
/// \brief Describes the kind of initialization sequence computed.
- ///
- /// FIXME: Much of this information is in the initialization steps... why is
- /// it duplicated here?
enum SequenceKind {
/// \brief A failed initialization sequence. The failure kind tells what
/// happened.
FailedSequence = 0,
-
+
/// \brief A dependent initialization, which could not be
/// type-checked due to the presence of dependent types or
- /// dependently-type expressions.
+ /// dependently-typed expressions.
DependentSequence,
- /// \brief A user-defined conversion sequence.
- UserDefinedConversion,
-
- /// \brief A constructor call.
- ConstructorInitialization,
-
- /// \brief A reference binding.
- ReferenceBinding,
+ /// \brief A normal sequence.
+ NormalSequence,
- /// \brief List initialization
- ListInitialization,
-
- /// \brief Zero-initialization.
- ZeroInitialization,
-
- /// \brief No initialization required.
- NoInitialization,
-
- /// \brief Standard conversion sequence.
- StandardConversion,
-
- /// \brief C conversion sequence.
- CAssignment,
-
- /// \brief String initialization
- StringInit,
-
- /// \brief Array initialization from another array (GNU C extension).
- ArrayInit
+ /// \brief A reference binding.
+ ReferenceBinding // FIXME: Still looks redundant, but complicated.
};
/// \brief Describes the kind of a particular step in an initialization
@@ -698,7 +671,7 @@
void setSequenceKind(enum SequenceKind SK) { SequenceKind = SK; }
/// \brief Determine whether the initialization sequence is valid.
- operator bool() const { return SequenceKind != FailedSequence; }
+ operator bool() const { return !Failed(); }
/// \brief Determine whether the initialization sequence is invalid.
bool Failed() const { return SequenceKind == FailedSequence; }
Modified: cfe/trunk/lib/Sema/SemaInit.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaInit.cpp?rev=132667&r1=132666&r2=132667&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaInit.cpp (original)
+++ cfe/trunk/lib/Sema/SemaInit.cpp Sun Jun 5 08:59:11 2011
@@ -296,8 +296,7 @@
// Do nothing
} else if (Init < NumInits) {
ILE->setInit(Init, MemberInit.takeAs<Expr>());
- } else if (InitSeq.getKind()
- == InitializationSequence::ConstructorInitialization) {
+ } else if (InitSeq.isConstructorInitialization()) {
// 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
@@ -418,8 +417,7 @@
return;
}
- if (InitSeq.getKind()
- == InitializationSequence::ConstructorInitialization) {
+ if (InitSeq.isConstructorInitialization()) {
// 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
@@ -2310,7 +2308,7 @@
void InitializationSequence::SetOverloadFailure(FailureKind Failure,
OverloadingResult Result) {
- SequenceKind = FailedSequence;
+ setSequenceKind(FailedSequence);
this->Failure = Failure;
this->FailedOverloadResult = Result;
}
@@ -2331,7 +2329,6 @@
// well-formed. When 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();
@@ -2800,7 +2797,6 @@
const InitializationKind &Kind,
Expr *Initializer,
InitializationSequence &Sequence) {
- Sequence.setSequenceKind(InitializationSequence::StringInit);
Sequence.AddStringInitStep(Entity.getType());
}
@@ -2813,8 +2809,6 @@
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();
@@ -2947,7 +2941,6 @@
}
Sequence.AddZeroInitializationStep(Entity.getType());
- Sequence.setSequenceKind(InitializationSequence::ZeroInitialization);
}
/// \brief Attempt default initialization (C++ [dcl.init]p6).
@@ -2973,7 +2966,6 @@
}
// - 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
@@ -2990,8 +2982,6 @@
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();
@@ -3176,6 +3166,9 @@
return;
}
+ // Almost everything is a normal sequence.
+ setSequenceKind(NormalSequence);
+
for (unsigned I = 0; I != NumArgs; ++I)
if (Args[I]->getObjectKind() == OK_ObjCProperty) {
ExprResult Result = S.ConvertPropertyForRValue(Args[I]);
@@ -3252,7 +3245,6 @@
else if (Initializer->HasSideEffects(S.Context))
SetFailed(FK_NonConstantArrayInit);
else {
- setSequenceKind(ArrayInit);
AddArrayInitStep(DestType);
}
} else if (DestAT->getElementType()->isAnyCharacterType())
@@ -3265,7 +3257,6 @@
// Handle initialization in C
if (!S.getLangOptions().CPlusPlus) {
- setSequenceKind(CAssignment);
AddCAssignmentStep(DestType);
return;
}
@@ -3325,8 +3316,6 @@
else
SetFailed(InitializationSequence::FK_ConversionFailed);
}
- else
- setSequenceKind(StandardConversion);
}
InitializationSequence::~InitializationSequence() {
@@ -3656,7 +3645,7 @@
return ExprError();
}
- if (SequenceKind == DependentSequence) {
+ if (getKind() == 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.
@@ -3710,7 +3699,8 @@
SourceLocation()));
}
- if (SequenceKind == NoInitialization)
+ // No steps means no initialization.
+ if (Steps.empty())
return S.Owned((Expr *)0);
QualType DestType = Entity.getType().getNonReferenceType();
@@ -3723,8 +3713,6 @@
ExprResult 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.
@@ -4587,48 +4575,16 @@
}
case DependentSequence:
- OS << "Dependent sequence: ";
+ OS << "Dependent sequence\n";
return;
- case UserDefinedConversion:
- OS << "User-defined conversion sequence: ";
- break;
-
- case ConstructorInitialization:
- OS << "Constructor initialization sequence: ";
+ case NormalSequence:
+ OS << "Normal 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;
-
- case ArrayInit:
- OS << "Array initialization: ";
- break;
}
for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
More information about the cfe-commits
mailing list