std::string Proto = FD->getNameAsString();
const FunctionType *AFT = FD->getType()->getAsFunctionType();
- if (const FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(AFT)) {
+ if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(AFT)) {
Proto += "(";
for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
if (i) Proto += ", ";
}
Proto += ")";
} else {
- assert(isa<FunctionTypeNoProto>(AFT));
+ assert(isa<FunctionNoProtoType>(AFT));
Proto += "()";
}
void RewriteProtocolDecl(ObjCProtocolDecl *PDecl);
void RewriteMethodDecl(ObjCMethodDecl *MDecl);
- void RewriteFunctionTypeProto(QualType funcType, NamedDecl *D);
+ void RewriteFunctionProtoType(QualType funcType, NamedDecl *D);
void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);
void RewriteCastExpr(CastExpr *CE);
BlockDecl *BD = CE->getBlockDecl();
- if (isa<FunctionTypeNoProto>(AFT)) {
+ if (isa<FunctionNoProtoType>(AFT)) {
S += "()";
} else if (BD->param_empty()) {
S += "(" + StructRef + " *__cself)";
} else {
- const FunctionTypeProto *FT = cast<FunctionTypeProto>(AFT);
+ const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
assert(FT && "SynthesizeBlockFunc: No function proto");
S += '(';
// first add the implicit argument.
assert(CPT && "RewriteBlockClass: Bad type");
const FunctionType *FT = CPT->getPointeeType()->getAsFunctionType();
assert(FT && "RewriteBlockClass: Bad type");
- const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(FT);
+ const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT);
// FTP will be null for closures that don't take arguments.
// Build a closure call - start with a paren expr to enforce precedence.
BlockCall += "(" + Exp->getType().getAsString() + "(*)";
BlockCall += "(struct __block_impl *";
if (FTP) {
- for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
+ for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(),
E = FTP->arg_type_end(); I && (I != E); ++I)
BlockCall += ", " + (*I).getAsString();
}
}
bool RewriteBlocks::PointerTypeTakesAnyBlockArguments(QualType QT) {
- const FunctionTypeProto *FTP;
+ const FunctionProtoType *FTP;
const PointerType *PT = QT->getAsPointerType();
if (PT) {
- FTP = PT->getPointeeType()->getAsFunctionTypeProto();
+ FTP = PT->getPointeeType()->getAsFunctionProtoType();
} else {
const BlockPointerType *BPT = QT->getAsBlockPointerType();
assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type");
- FTP = BPT->getPointeeType()->getAsFunctionTypeProto();
+ FTP = BPT->getPointeeType()->getAsFunctionProtoType();
}
if (FTP) {
- for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
+ for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(),
E = FTP->arg_type_end(); I != E; ++I)
if (isBlockPointerType(*I))
return true;
return S;
}
-void RewriteBlocks::RewriteFunctionTypeProto(QualType funcType, NamedDecl *D) {
- if (FunctionTypeProto *fproto = dyn_cast<FunctionTypeProto>(funcType)) {
- for (FunctionTypeProto::arg_type_iterator I = fproto->arg_type_begin(),
+void RewriteBlocks::RewriteFunctionProtoType(QualType funcType, NamedDecl *D) {
+ if (FunctionProtoType *fproto = dyn_cast<FunctionProtoType>(funcType)) {
+ for (FunctionProtoType::arg_type_iterator I = fproto->arg_type_begin(),
E = fproto->arg_type_end(); I && (I != E); ++I)
if (isBlockPointerType(*I)) {
// All the args are checked/rewritten. Don't call twice!
void RewriteBlocks::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {
const PointerType *PT = funcType->getAsPointerType();
if (PT && PointerTypeTakesAnyBlockArguments(funcType))
- RewriteFunctionTypeProto(PT->getPointeeType(), ND);
+ RewriteFunctionProtoType(PT->getPointeeType(), ND);
}
/// HandleDeclInMainFile - This is called for each top-level decl defined in the
// Since function prototypes don't have ParmDecl's, we check the function
// prototype. This enables us to rewrite function declarations and
// definitions using the same code.
- RewriteFunctionTypeProto(FD->getType(), FD);
+ RewriteFunctionProtoType(FD->getType(), FD);
if (Stmt *Body = FD->getBody()) {
CurFunctionDef = FD;
void SynthesizeMetaDataIntoBuffer(std::string &Result);
// Block rewriting.
- void RewriteBlocksInFunctionTypeProto(QualType funcType, NamedDecl *D);
+ void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D);
void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);
void InsertBlockLiteralsWithinFunction(FunctionDecl *FD);
};
}
-void RewriteObjC::RewriteBlocksInFunctionTypeProto(QualType funcType,
+void RewriteObjC::RewriteBlocksInFunctionProtoType(QualType funcType,
NamedDecl *D) {
- if (FunctionTypeProto *fproto = dyn_cast<FunctionTypeProto>(funcType)) {
- for (FunctionTypeProto::arg_type_iterator I = fproto->arg_type_begin(),
+ if (FunctionProtoType *fproto = dyn_cast<FunctionProtoType>(funcType)) {
+ for (FunctionProtoType::arg_type_iterator I = fproto->arg_type_begin(),
E = fproto->arg_type_end(); I && (I != E); ++I)
if (isTopLevelBlockPointerType(*I)) {
// All the args are checked/rewritten. Don't call twice!
void RewriteObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {
const PointerType *PT = funcType->getAsPointerType();
if (PT && PointerTypeTakesAnyBlockArguments(funcType))
- RewriteBlocksInFunctionTypeProto(PT->getPointeeType(), ND);
+ RewriteBlocksInFunctionProtoType(PT->getPointeeType(), ND);
}
static bool IsHeaderFile(const std::string &Filename) {
ResultStr += ")"; // close the precedence "scope" for "*".
// Now, emit the argument types (if any).
- if (const FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(FPRetType)) {
+ if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)) {
ResultStr += "(";
for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) {
if (i) ResultStr += ", ";
void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) {
SourceLocation Loc;
QualType Type;
- const FunctionTypeProto *proto = 0;
+ const FunctionProtoType *proto = 0;
if (VarDecl *VD = dyn_cast<VarDecl>(Dcl)) {
Loc = VD->getLocation();
Type = VD->getType();
// information (id<p>, C<p>*). The protocol references need to be rewritten!
const FunctionType *funcType = FD->getType()->getAsFunctionType();
assert(funcType && "missing function type");
- proto = dyn_cast<FunctionTypeProto>(funcType);
+ proto = dyn_cast<FunctionProtoType>(funcType);
if (!proto)
return;
Type = proto->getResultType();
BlockDecl *BD = CE->getBlockDecl();
- if (isa<FunctionTypeNoProto>(AFT)) {
+ if (isa<FunctionNoProtoType>(AFT)) {
// No user-supplied arguments. Still need to pass in a pointer to the
// block (to reference imported block decl refs).
S += "(" + StructRef + " *__cself)";
} else if (BD->param_empty()) {
S += "(" + StructRef + " *__cself)";
} else {
- const FunctionTypeProto *FT = cast<FunctionTypeProto>(AFT);
+ const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
assert(FT && "SynthesizeBlockFunc: No function proto");
S += '(';
// first add the implicit argument.
assert(CPT && "RewriteBlockClass: Bad type");
const FunctionType *FT = CPT->getPointeeType()->getAsFunctionType();
assert(FT && "RewriteBlockClass: Bad type");
- const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(FT);
+ const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT);
// FTP will be null for closures that don't take arguments.
RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
// Push the block argument type.
ArgTypes.push_back(PtrBlock);
if (FTP) {
- for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
+ for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(),
E = FTP->arg_type_end(); I && (I != E); ++I) {
QualType t = *I;
// Make sure we convert "t (^)(...)" to "t (*)(...)".
}
bool RewriteObjC::PointerTypeTakesAnyBlockArguments(QualType QT) {
- const FunctionTypeProto *FTP;
+ const FunctionProtoType *FTP;
const PointerType *PT = QT->getAsPointerType();
if (PT) {
- FTP = PT->getPointeeType()->getAsFunctionTypeProto();
+ FTP = PT->getPointeeType()->getAsFunctionProtoType();
} else {
const BlockPointerType *BPT = QT->getAsBlockPointerType();
assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type");
- FTP = BPT->getPointeeType()->getAsFunctionTypeProto();
+ FTP = BPT->getPointeeType()->getAsFunctionProtoType();
}
if (FTP) {
- for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
+ for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(),
E = FTP->arg_type_end(); I != E; ++I)
if (isTopLevelBlockPointerType(*I))
return true;
FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(const char *name) {
IdentifierInfo *ID = &Context->Idents.get(name);
- QualType FType = Context->getFunctionTypeNoProto(Context->VoidPtrTy);
+ QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy);
return FunctionDecl::Create(*Context, TUDecl,SourceLocation(),
ID, FType, FunctionDecl::Extern, false,
false);
// Since function prototypes don't have ParmDecl's, we check the function
// prototype. This enables us to rewrite function declarations and
// definitions using the same code.
- RewriteBlocksInFunctionTypeProto(FD->getType(), FD);
+ RewriteBlocksInFunctionProtoType(FD->getType(), FD);
if (Stmt *Body = FD->getBody()) {
CurFunctionDef = FD;
std::vector<VariableArrayType*> VariableArrayTypes;
std::vector<DependentSizedArrayType*> DependentSizedArrayTypes;
llvm::FoldingSet<VectorType> VectorTypes;
- llvm::FoldingSet<FunctionTypeNoProto> FunctionTypeNoProtos;
- llvm::FoldingSet<FunctionTypeProto> FunctionTypeProtos;
+ llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
+ llvm::FoldingSet<FunctionProtoType> FunctionProtoTypes;
llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
llvm::FoldingSet<ClassTemplateSpecializationType>
ClassTemplateSpecializationTypes;
/// type.
QualType getExtVectorType(QualType VectorType, unsigned NumElts);
- /// getFunctionTypeNoProto - Return a K&R style C function type like 'int()'.
+ /// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
///
- QualType getFunctionTypeNoProto(QualType ResultTy);
+ QualType getFunctionNoProtoType(QualType ResultTy);
/// getFunctionType - Return a normal function type with a typed argument
/// list. isVariadic indicates whether the argument list includes '...'.
/// getTypeOfType - GCC extension.
- QualType getTypeOfExpr(Expr *e);
+ QualType getTypeOfExprType(Expr *e);
QualType getTypeOfType(QualType t);
/// getTagDeclType - Return the unique reference to the type for the
QualType getThisType(ASTContext &C) const;
unsigned getTypeQualifiers() const {
- return getType()->getAsFunctionTypeProto()->getTypeQuals();
+ return getType()->getAsFunctionProtoType()->getTypeQuals();
}
// Implement isa/cast/dyncast/etc.
class Expr;
class Stmt;
class SourceLocation;
- class PointerType;
- class BlockPointerType;
- class ReferenceType;
- class MemberPointerType;
- class VectorType;
- class ArrayType;
- class ConstantArrayType;
- class VariableArrayType;
- class IncompleteArrayType;
- class DependentSizedArrayType;
- class RecordType;
- class EnumType;
- class ComplexType;
- class TagType;
- class TypedefType;
- class TemplateTypeParmType;
- class FunctionType;
- class FunctionTypeNoProto;
- class FunctionTypeProto;
- class ExtVectorType;
- class BuiltinType;
- class ObjCInterfaceType;
- class ObjCQualifiedIdType;
- class ObjCQualifiedInterfaceType;
class StmtIteratorBase;
- class ClassTemplateSpecializationType;
+
+ // Provide forward declarations for all of the *Type classes
+#define TYPE(Class, Base) class Class##Type;
+#include "clang/AST/TypeNodes.def"
/// QualType - For efficiency, we don't store CVR-qualified types as nodes on
/// their own: instead each reference to a type stores the qualifiers. This
///
/// There will be a Type object created for 'int'. Since int is canonical, its
/// canonicaltype pointer points to itself. There is also a Type for 'foo' (a
-/// TypeNameType). Its CanonicalType pointer points to the 'int' Type. Next
+/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
/// there is a PointerType that represents 'int*', which, like 'int', is
/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
-/// type is 'int*', and there is a TypeNameType for 'bar', whose canonical type
+/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
/// is also 'int*'.
///
/// Non-canonical types are useful for emitting diagnostics, without losing
class Type {
public:
enum TypeClass {
- Builtin, Complex, Pointer, Reference, MemberPointer,
- ConstantArray, VariableArray, IncompleteArray, DependentSizedArray,
- Vector, ExtVector,
- FunctionNoProto, FunctionProto,
- TypeName, Tagged, ExtQual,
- TemplateTypeParm, ClassTemplateSpecialization,
- ObjCInterface, ObjCQualifiedInterface,
- ObjCQualifiedId, ObjCQualifiedClass,
- TypeOfExp, TypeOfTyp, // GNU typeof extension.
- BlockPointer, // C extension
- FixedWidthInt
+#define TYPE(Class, Base) Class,
+#define ABSTRACT_TYPE(Class, Base)
+#include "clang/AST/TypeNodes.def"
+ TagFirst = Record, TagLast = Enum
};
private:
// the best type we can.
const BuiltinType *getAsBuiltinType() const;
const FunctionType *getAsFunctionType() const;
- const FunctionTypeNoProto *getAsFunctionTypeNoProto() const;
- const FunctionTypeProto *getAsFunctionTypeProto() const;
+ const FunctionNoProtoType *getAsFunctionNoProtoType() const;
+ const FunctionProtoType *getAsFunctionProtoType() const;
const PointerType *getAsPointerType() const;
const BlockPointerType *getAsBlockPointerType() const;
const ReferenceType *getAsReferenceType() const;
};
/// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base
-/// class of FunctionTypeNoProto and FunctionTypeProto.
+/// class of FunctionNoProtoType and FunctionProtoType.
///
class FunctionType : public Type {
/// SubClassData - This field is owned by the subclass, put here to pack
/// tightly with the ivars in Type.
bool SubClassData : 1;
- /// TypeQuals - Used only by FunctionTypeProto, put here to pack with the
+ /// TypeQuals - Used only by FunctionProtoType, put here to pack with the
/// other bitfields.
- /// The qualifiers are part of FunctionTypeProto because...
+ /// The qualifiers are part of FunctionProtoType because...
///
/// C++ 8.3.5p4: The return type, the parameter type list and the
/// cv-qualifier-seq, [...], are part of the function type.
static bool classof(const FunctionType *) { return true; }
};
-/// FunctionTypeNoProto - Represents a K&R-style 'int foo()' function, which has
+/// FunctionNoProtoType - Represents a K&R-style 'int foo()' function, which has
/// no information available about its arguments.
-class FunctionTypeNoProto : public FunctionType, public llvm::FoldingSetNode {
- FunctionTypeNoProto(QualType Result, QualType Canonical)
+class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
+ FunctionNoProtoType(QualType Result, QualType Canonical)
: FunctionType(FunctionNoProto, Result, false, 0, Canonical,
/*Dependent=*/false) {}
friend class ASTContext; // ASTContext creates these.
static bool classof(const Type *T) {
return T->getTypeClass() == FunctionNoProto;
}
- static bool classof(const FunctionTypeNoProto *) { return true; }
+ static bool classof(const FunctionNoProtoType *) { return true; }
protected:
virtual void EmitImpl(llvm::Serializer& S) const;
friend class Type;
};
-/// FunctionTypeProto - Represents a prototype with argument type info, e.g.
+/// FunctionProtoType - Represents a prototype with argument type info, e.g.
/// 'int foo(int)' or 'int foo(void)'. 'void' is represented as having no
/// arguments, not as having a single void argument.
-class FunctionTypeProto : public FunctionType, public llvm::FoldingSetNode {
+class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
/// hasAnyDependentType - Determine whether there are any dependent
/// types within the arguments passed in.
static bool hasAnyDependentType(const QualType *ArgArray, unsigned numArgs) {
return false;
}
- FunctionTypeProto(QualType Result, const QualType *ArgArray, unsigned numArgs,
+ FunctionProtoType(QualType Result, const QualType *ArgArray, unsigned numArgs,
bool isVariadic, unsigned typeQuals, QualType Canonical)
: FunctionType(FunctionProto, Result, isVariadic, typeQuals, Canonical,
(Result->isDependentType() ||
static bool classof(const Type *T) {
return T->getTypeClass() == FunctionProto;
}
- static bool classof(const FunctionTypeProto *) { return true; }
+ static bool classof(const FunctionProtoType *) { return true; }
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
virtual void getAsStringInternal(std::string &InnerString) const;
- static bool classof(const Type *T) { return T->getTypeClass() == TypeName; }
+ static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
static bool classof(const TypedefType *) { return true; }
protected:
friend class Type;
};
-/// TypeOfExpr (GCC extension).
-class TypeOfExpr : public Type {
+/// TypeOfExprType (GCC extension).
+class TypeOfExprType : public Type {
Expr *TOExpr;
- TypeOfExpr(Expr *E, QualType can);
+ TypeOfExprType(Expr *E, QualType can);
friend class ASTContext; // ASTContext creates these.
public:
Expr *getUnderlyingExpr() const { return TOExpr; }
virtual void getAsStringInternal(std::string &InnerString) const;
- static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExp; }
- static bool classof(const TypeOfExpr *) { return true; }
+ static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
+ static bool classof(const TypeOfExprType *) { return true; }
protected:
virtual void EmitImpl(llvm::Serializer& S) const;
class TypeOfType : public Type {
QualType TOType;
TypeOfType(QualType T, QualType can)
- : Type(TypeOfTyp, can, T->isDependentType()), TOType(T) {
+ : Type(TypeOf, can, T->isDependentType()), TOType(T) {
assert(!isa<TypedefType>(can) && "Invalid canonical type");
}
friend class ASTContext; // ASTContext creates these.
virtual void getAsStringInternal(std::string &InnerString) const;
- static bool classof(const Type *T) { return T->getTypeClass() == TypeOfTyp; }
+ static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
static bool classof(const TypeOfType *) { return true; }
protected:
// FIXME: We'll need the user to pass in information about whether
// this type is dependent or not, because we don't have enough
// information to compute it here.
- TagType(TagDecl *D, QualType can)
- : Type(Tagged, can, /*Dependent=*/false), decl(D, 0) {}
+ TagType(TypeClass TC, TagDecl *D, QualType can)
+ : Type(TC, can, /*Dependent=*/false), decl(D, 0) {}
public:
TagDecl *getDecl() const { return decl.getPointer(); }
virtual void getAsStringInternal(std::string &InnerString) const;
- static bool classof(const Type *T) { return T->getTypeClass() == Tagged; }
+ static bool classof(const Type *T) {
+ return T->getTypeClass() >= TagFirst && T->getTypeClass() <= TagLast;
+ }
static bool classof(const TagType *) { return true; }
-
+ static bool classof(const RecordType *) { return true; }
+ static bool classof(const CXXRecordType *) { return true; }
+ static bool classof(const EnumType *) { return true; }
+
protected:
virtual void EmitImpl(llvm::Serializer& S) const;
static Type* CreateImpl(ASTContext& Context, llvm::Deserializer& D);
class RecordType : public TagType {
protected:
explicit RecordType(RecordDecl *D)
- : TagType(reinterpret_cast<TagDecl*>(D), QualType()) { }
+ : TagType(Record, reinterpret_cast<TagDecl*>(D), QualType()) { }
+ explicit RecordType(TypeClass TC, RecordDecl *D)
+ : TagType(TC, reinterpret_cast<TagDecl*>(D), QualType()) { }
friend class ASTContext; // ASTContext creates these.
public:
/// isa/cast/dyncast to detect TagType objects of C++ structs/unions/classes.
class CXXRecordType : public RecordType {
explicit CXXRecordType(CXXRecordDecl *D)
- : RecordType(reinterpret_cast<RecordDecl*>(D)) { }
+ : RecordType(CXXRecord, reinterpret_cast<RecordDecl*>(D)) { }
friend class ASTContext; // ASTContext creates these.
public:
/// to detect TagType objects of enums.
class EnumType : public TagType {
explicit EnumType(EnumDecl *D)
- : TagType(reinterpret_cast<TagDecl*>(D), QualType()) { }
+ : TagType(Enum, reinterpret_cast<TagDecl*>(D), QualType()) { }
friend class ASTContext; // ASTContext creates these.
public:
--- /dev/null
+//===-- TypeNodes.def - Metadata about Type AST nodes -----------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AST type info database. Each type node is
+// enumerated by providing its name (e.g., "Builtin" or "Enum") and
+// base class (e.g., "Type" or "TagType"). Depending on where in the
+// abstract syntax tree the type will show up, the enumeration uses
+// one of four different macros:
+//
+// TYPE(Class, Base) - A type that can show up anywhere in the AST,
+// and might be dependent, canonical, or non-canonical. All clients
+// will need to understand these types.
+//
+// ABSTRACT_TYPE(Class, Base) - An abstract class that shows up in
+// the type hierarchy but has no concrete instances.
+//
+// NON_CANONICAL_TYPE(Class, Base) - A type that can show up
+// anywhere in the AST but will never be a part of a canonical
+// type. Clients that only need to deal with canonical types
+// (ignoring, e.g., typedefs and other type alises used for
+// pretty-printing) can ignore these types.
+//
+// DEPENDENT_TYPE(Class, Base) - A type that will only show up
+// within a C++ template that has not been instantiated, e.g., a
+// type that is always dependent. Clients that do not need to deal
+// with uninstantiated C++ templates can ignore these types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ABSTRACT_TYPE
+# define ABSTRACT_TYPE(Class, Base) TYPE(Class, Base)
+#endif
+
+#ifndef NON_CANONICAL_TYPE
+# define NON_CANONICAL_TYPE(Class, Base) TYPE(Class, Base)
+#endif
+
+#ifndef DEPENDENT_TYPE
+# define DEPENDENT_TYPE(Class, Base) TYPE(Class, Base)
+#endif
+
+TYPE(ExtQual, Type)
+TYPE(Builtin, Type)
+TYPE(FixedWidthInt, Type)
+TYPE(Complex, Type)
+TYPE(Pointer, Type)
+TYPE(BlockPointer, Type)
+TYPE(Reference, Type)
+TYPE(MemberPointer, Type)
+ABSTRACT_TYPE(Array, Type)
+TYPE(ConstantArray, ArrayType)
+TYPE(IncompleteArray, ArrayType)
+TYPE(VariableArray, ArrayType)
+DEPENDENT_TYPE(DependentSizedArray, ArrayType)
+TYPE(Vector, Type)
+TYPE(ExtVector, VectorType)
+ABSTRACT_TYPE(Function, Type)
+TYPE(FunctionProto, Function)
+TYPE(FunctionNoProto, Function)
+NON_CANONICAL_TYPE(Typedef, Type)
+NON_CANONICAL_TYPE(TypeOfExpr, Type)
+NON_CANONICAL_TYPE(TypeOf, Type)
+ABSTRACT_TYPE(Tag, Type)
+TYPE(Record, TagType)
+TYPE(CXXRecord, RecordType) // FIXME: kill this one
+TYPE(Enum, TagType)
+DEPENDENT_TYPE(TemplateTypeParm, Type)
+NON_CANONICAL_TYPE(ClassTemplateSpecialization, Type)
+TYPE(ObjCInterface, Type)
+TYPE(ObjCQualifiedInterface, ObjCInterfaceType)
+TYPE(ObjCQualifiedId, Type)
+TYPE(ObjCQualifiedClass, Type)
+
+#undef DEPENDENT_TYPE
+#undef NON_CANONICAL_TYPE
+#undef ABSTRACT_TYPE
+#undef TYPE
NodeSet& Dst);
void VisitCallRec(CallExpr* CE, NodeTy* Pred,
CallExpr::arg_iterator AI, CallExpr::arg_iterator AE,
- NodeSet& Dst, const FunctionTypeProto *,
+ NodeSet& Dst, const FunctionProtoType *,
unsigned ParamIdx = 0);
/// VisitCast - Transfer function logic for all casts (implicit and explicit).
unsigned NumTagStruct = 0, NumTagUnion = 0, NumTagEnum = 0, NumTagClass = 0;
unsigned NumObjCInterfaces = 0, NumObjCQualifiedInterfaces = 0;
unsigned NumObjCQualifiedIds = 0;
- unsigned NumTypeOfTypes = 0, NumTypeOfExprs = 0;
+ unsigned NumTypeOfTypes = 0, NumTypeOfExprTypes = 0;
for (unsigned i = 0, e = Types.size(); i != e; ++i) {
Type *T = Types[i];
++NumArray;
else if (isa<VectorType>(T))
++NumVector;
- else if (isa<FunctionTypeNoProto>(T))
+ else if (isa<FunctionNoProtoType>(T))
++NumFunctionNP;
- else if (isa<FunctionTypeProto>(T))
+ else if (isa<FunctionProtoType>(T))
++NumFunctionP;
else if (isa<TypedefType>(T))
++NumTypeName;
++NumObjCQualifiedIds;
else if (isa<TypeOfType>(T))
++NumTypeOfTypes;
- else if (isa<TypeOfExpr>(T))
- ++NumTypeOfExprs;
+ else if (isa<TypeOfExprType>(T))
+ ++NumTypeOfExprTypes;
else {
QualType(T, 0).dump();
assert(0 && "Unknown type!");
fprintf(stderr, " %d protocol qualified id types\n",
NumObjCQualifiedIds);
fprintf(stderr, " %d typeof types\n", NumTypeOfTypes);
- fprintf(stderr, " %d typeof exprs\n", NumTypeOfExprs);
+ fprintf(stderr, " %d typeof exprs\n", NumTypeOfExprTypes);
fprintf(stderr, "Total bytes = %d\n", int(NumBuiltin*sizeof(BuiltinType)+
NumPointer*sizeof(PointerType)+NumArray*sizeof(ArrayType)+
NumComplex*sizeof(ComplexType)+NumVector*sizeof(VectorType)+
NumMemberPointer*sizeof(MemberPointerType)+
- NumFunctionP*sizeof(FunctionTypeProto)+
- NumFunctionNP*sizeof(FunctionTypeNoProto)+
+ NumFunctionP*sizeof(FunctionProtoType)+
+ NumFunctionNP*sizeof(FunctionNoProtoType)+
NumTypeName*sizeof(TypedefType)+NumTagged*sizeof(TagType)+
- NumTypeOfTypes*sizeof(TypeOfType)+NumTypeOfExprs*sizeof(TypeOfExpr)));
+ NumTypeOfTypes*sizeof(TypeOfType)+NumTypeOfExprTypes*sizeof(TypeOfExprType)));
}
uint64_t Width;
unsigned Align;
switch (T->getTypeClass()) {
- case Type::TypeName: assert(0 && "Not a canonical type!");
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+ assert(false && "Should not see non-canonical or dependent types");
+ break;
+
case Type::FunctionNoProto:
case Type::FunctionProto:
- default:
+ case Type::IncompleteArray:
assert(0 && "Incomplete types have no size!");
case Type::VariableArray:
assert(0 && "VLAs not implemented yet!");
- case Type::DependentSizedArray:
- assert(0 && "Dependently-sized arrays don't have a known size");
case Type::ConstantArray: {
const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
return getTypeInfo(QualType(cast<ExtQualType>(T)->getBaseType(), 0));
case Type::ObjCQualifiedId:
case Type::ObjCQualifiedClass:
+ case Type::ObjCQualifiedInterface:
Width = Target.getPointerWidth(0);
Align = Target.getPointerAlign(0);
break;
Align = Layout.getAlignment();
break;
}
- case Type::Tagged: {
+ case Type::Record:
+ case Type::CXXRecord:
+ case Type::Enum: {
const TagType *TT = cast<TagType>(T);
if (TT->getDecl()->isInvalidDecl()) {
return QualType(New, 0);
}
-/// getFunctionTypeNoProto - Return a K&R style C function type like 'int()'.
+/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
///
-QualType ASTContext::getFunctionTypeNoProto(QualType ResultTy) {
+QualType ASTContext::getFunctionNoProtoType(QualType ResultTy) {
// Unique functions, to guarantee there is only one function of a particular
// structure.
llvm::FoldingSetNodeID ID;
- FunctionTypeNoProto::Profile(ID, ResultTy);
+ FunctionNoProtoType::Profile(ID, ResultTy);
void *InsertPos = 0;
- if (FunctionTypeNoProto *FT =
- FunctionTypeNoProtos.FindNodeOrInsertPos(ID, InsertPos))
+ if (FunctionNoProtoType *FT =
+ FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(FT, 0);
QualType Canonical;
if (!ResultTy->isCanonical()) {
- Canonical = getFunctionTypeNoProto(getCanonicalType(ResultTy));
+ Canonical = getFunctionNoProtoType(getCanonicalType(ResultTy));
// Get the new insert position for the node we care about.
- FunctionTypeNoProto *NewIP =
- FunctionTypeNoProtos.FindNodeOrInsertPos(ID, InsertPos);
+ FunctionNoProtoType *NewIP =
+ FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
}
- FunctionTypeNoProto *New =new(*this,8)FunctionTypeNoProto(ResultTy,Canonical);
+ FunctionNoProtoType *New =new(*this,8)FunctionNoProtoType(ResultTy,Canonical);
Types.push_back(New);
- FunctionTypeNoProtos.InsertNode(New, InsertPos);
+ FunctionNoProtoTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
}
// Unique functions, to guarantee there is only one function of a particular
// structure.
llvm::FoldingSetNodeID ID;
- FunctionTypeProto::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic,
+ FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic,
TypeQuals);
void *InsertPos = 0;
- if (FunctionTypeProto *FTP =
- FunctionTypeProtos.FindNodeOrInsertPos(ID, InsertPos))
+ if (FunctionProtoType *FTP =
+ FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(FTP, 0);
// Determine whether the type being created is already canonical or not.
isVariadic, TypeQuals);
// Get the new insert position for the node we care about.
- FunctionTypeProto *NewIP =
- FunctionTypeProtos.FindNodeOrInsertPos(ID, InsertPos);
+ FunctionProtoType *NewIP =
+ FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
}
- // FunctionTypeProto objects are allocated with extra bytes after them
+ // FunctionProtoType objects are allocated with extra bytes after them
// for a variable size array (for parameter types) at the end of them.
- FunctionTypeProto *FTP =
- (FunctionTypeProto*)Allocate(sizeof(FunctionTypeProto) +
+ FunctionProtoType *FTP =
+ (FunctionProtoType*)Allocate(sizeof(FunctionProtoType) +
NumArgs*sizeof(QualType), 8);
- new (FTP) FunctionTypeProto(ResultTy, ArgArray, NumArgs, isVariadic,
+ new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, isVariadic,
TypeQuals, Canonical);
Types.push_back(FTP);
- FunctionTypeProtos.InsertNode(FTP, InsertPos);
+ FunctionProtoTypes.InsertNode(FTP, InsertPos);
return QualType(FTP, 0);
}
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
QualType Canonical = getCanonicalType(Decl->getUnderlyingType());
- Decl->TypeForDecl = new(*this,8) TypedefType(Type::TypeName, Decl, Canonical);
+ Decl->TypeForDecl = new(*this,8) TypedefType(Type::Typedef, Decl, Canonical);
Types.push_back(Decl->TypeForDecl);
return QualType(Decl->TypeForDecl, 0);
}
return QualType(QType, 0);
}
-/// getTypeOfExpr - Unlike many "get<Type>" functions, we can't unique
-/// TypeOfExpr AST's (since expression's are never shared). For example,
+/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
+/// TypeOfExprType AST's (since expression's are never shared). For example,
/// multiple declarations that refer to "typeof(x)" all contain different
/// DeclRefExpr's. This doesn't effect the type checker, since it operates
/// on canonical type's (which are always unique).
-QualType ASTContext::getTypeOfExpr(Expr *tofExpr) {
+QualType ASTContext::getTypeOfExprType(Expr *tofExpr) {
QualType Canonical = getCanonicalType(tofExpr->getType());
- TypeOfExpr *toe = new (*this,8) TypeOfExpr(tofExpr, Canonical);
+ TypeOfExprType *toe = new (*this,8) TypeOfExprType(tofExpr, Canonical);
Types.push_back(toe);
return QualType(toe, 0);
}
bool ASTContext::typesAreBlockCompatible(QualType lhs, QualType rhs) {
const FunctionType *lbase = lhs->getAsFunctionType();
const FunctionType *rbase = rhs->getAsFunctionType();
- const FunctionTypeProto *lproto = dyn_cast<FunctionTypeProto>(lbase);
- const FunctionTypeProto *rproto = dyn_cast<FunctionTypeProto>(rbase);
+ const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
+ const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
if (lproto && rproto)
return !mergeTypes(lhs, rhs).isNull();
return false;
QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) {
const FunctionType *lbase = lhs->getAsFunctionType();
const FunctionType *rbase = rhs->getAsFunctionType();
- const FunctionTypeProto *lproto = dyn_cast<FunctionTypeProto>(lbase);
- const FunctionTypeProto *rproto = dyn_cast<FunctionTypeProto>(rbase);
+ const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
+ const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
bool allLTypes = true;
bool allRTypes = true;
if (lproto) allRTypes = false;
if (rproto) allLTypes = false;
- const FunctionTypeProto *proto = lproto ? lproto : rproto;
+ const FunctionProtoType *proto = lproto ? lproto : rproto;
if (proto) {
if (proto->isVariadic()) return QualType();
// Check that the types are compatible with the types that
if (allLTypes) return lhs;
if (allRTypes) return rhs;
- return getFunctionTypeNoProto(retType);
+ return getFunctionNoProtoType(retType);
}
QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
// The canonical type classes match.
switch (LHSClass) {
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+ assert(false && "Non-canonical and dependent types shouldn't get here");
+ return QualType();
+
+ case Type::Reference:
+ case Type::MemberPointer:
+ assert(false && "C++ should never be in mergeTypes");
+ return QualType();
+
+ case Type::IncompleteArray:
+ case Type::VariableArray:
+ case Type::FunctionProto:
+ case Type::ExtVector:
+ case Type::ObjCQualifiedInterface:
+ assert(false && "Types are eliminated above");
+ return QualType();
+
case Type::Pointer:
{
// Merge two pointer types, while trying to preserve typedef info
}
case Type::FunctionNoProto:
return mergeFunctionTypes(LHS, RHS);
- case Type::Tagged:
+ case Type::Record:
+ case Type::CXXRecord:
+ case Type::Enum:
// FIXME: Why are these compatible?
if (isObjCIdStructType(LHS) && isObjCClassStructType(RHS)) return LHS;
if (isObjCClassStructType(LHS) && isObjCIdStructType(RHS)) return LHS;
case Type::ObjCQualifiedId:
// Distinct qualified id's are not compatible.
return QualType();
- default:
- assert(0 && "unexpected type");
- return QualType();
}
+
+ return QualType();
}
//===----------------------------------------------------------------------===//
// handle untyped/variadic arguments "T c99Style();" or "T cppStyle(...);".
if (ArgTypes.size() == 0 && TypeStr[0] == '.')
- return Context.getFunctionTypeNoProto(ResType);
+ return Context.getFunctionNoProtoType(ResType);
return Context.getFunctionType(ResType, &ArgTypes[0], ArgTypes.size(),
TypeStr[0] == '.', 0);
}
// Helper function for FunctionDecl::getNumParams and FunctionDecl::setParams()
static unsigned getNumTypeParams(QualType T) {
const FunctionType *FT = T->getAsFunctionType();
- if (isa<FunctionTypeNoProto>(FT))
+ if (isa<FunctionNoProtoType>(FT))
return 0;
- return cast<FunctionTypeProto>(FT)->getNumArgs();
+ return cast<FunctionProtoType>(FT)->getNumArgs();
}
unsigned FunctionDecl::getNumParams() const {
if (Method->isStatic())
continue;
// TODO: Skip templates? Or is this implicitly done due to parameter types?
- const FunctionTypeProto *FnType =
- Method->getType()->getAsFunctionTypeProto();
+ const FunctionProtoType *FnType =
+ Method->getType()->getAsFunctionProtoType();
assert(FnType && "Overloaded operator has no prototype.");
// Don't assert on this; an invalid decl might have been left in the AST.
if (FnType->getNumArgs() != 1 || FnType->isVariadic())
// We're interested specifically in copy assignment operators.
// Unlike addedConstructor, this method is not called for implicit
// declarations.
- const FunctionTypeProto *FnType = OpDecl->getType()->getAsFunctionTypeProto();
+ const FunctionProtoType *FnType = OpDecl->getType()->getAsFunctionProtoType();
assert(FnType && "Overloaded operator has no proto function type.");
assert(FnType->getNumArgs() == 1 && !FnType->isVariadic());
QualType ArgType = FnType->getArgType(0);
return false;
return (getNumParams() == 0 &&
- getType()->getAsFunctionTypeProto()->isVariadic()) ||
+ getType()->getAsFunctionProtoType()->isVariadic()) ||
(getNumParams() == 1) ||
(getNumParams() > 1 && getParamDecl(1)->getDefaultArg() != 0);
}
const FunctionType *AFT = Node->getFunctionType();
- if (isa<FunctionTypeNoProto>(AFT)) {
+ if (isa<FunctionNoProtoType>(AFT)) {
OS << "()";
- } else if (!BD->param_empty() || cast<FunctionTypeProto>(AFT)->isVariadic()) {
+ } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
OS << '(';
std::string ParamStr;
for (BlockDecl::param_iterator AI = BD->param_begin(),
OS << ParamStr;
}
- const FunctionTypeProto *FT = cast<FunctionTypeProto>(AFT);
+ const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
if (FT->isVariadic()) {
if (!BD->param_empty()) OS << ", ";
OS << "...";
QualType Type::getDesugaredType() const {
if (const TypedefType *TDT = dyn_cast<TypedefType>(this))
return TDT->LookThroughTypedefs();
- if (const TypeOfExpr *TOE = dyn_cast<TypeOfExpr>(this))
+ if (const TypeOfExprType *TOE = dyn_cast<TypeOfExprType>(this))
return TOE->getUnderlyingExpr()->getType();
if (const TypeOfType *TOT = dyn_cast<TypeOfType>(this))
return TOT->getUnderlyingType();
case FunctionProto:
case FunctionNoProto:
case Reference:
+ case Record:
+ case CXXRecord:
return true;
- case Tagged:
- return !cast<TagType>(CanonicalType)->getDecl()->isEnum();
default:
return false;
}
return getDesugaredType()->getAsFunctionType();
}
-const FunctionTypeNoProto *Type::getAsFunctionTypeNoProto() const {
- return dyn_cast_or_null<FunctionTypeNoProto>(getAsFunctionType());
+const FunctionNoProtoType *Type::getAsFunctionNoProtoType() const {
+ return dyn_cast_or_null<FunctionNoProtoType>(getAsFunctionType());
}
-const FunctionTypeProto *Type::getAsFunctionTypeProto() const {
- return dyn_cast_or_null<FunctionTypeProto>(getAsFunctionType());
+const FunctionProtoType *Type::getAsFunctionProtoType() const {
+ return dyn_cast_or_null<FunctionProtoType>(getAsFunctionType());
}
// Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never
// be completed.
return isVoidType();
- case Tagged:
+ case Record:
+ case CXXRecord:
+ case Enum:
// A tagged type (struct/union/enum/class) is incomplete if the decl is a
// forward declaration, but not a full definition (C99 6.2.5p22).
return !cast<TagType>(CanonicalType)->getDecl()->isDefinition();
case ObjCQualifiedId:
return true;
- case Tagged:
- if (isEnumeralType())
- return true;
- if (CXXRecordDecl *RDecl = dyn_cast<CXXRecordDecl>(
- cast<TagType>(CanonicalType)->getDecl()))
- return RDecl->isPOD();
+ case Enum:
+ return true;
+
+ case Record:
// C struct/union is POD.
return true;
+
+ case CXXRecord:
+ return cast<CXXRecordType>(CanonicalType)->getDecl()->isPOD();
}
}
}
}
-void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
+void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
arg_type_iterator ArgTys,
unsigned NumArgs, bool isVariadic,
unsigned TypeQuals) {
ID.AddInteger(TypeQuals);
}
-void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID) {
+void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(),
getTypeQuals());
}
}
}
-TypeOfExpr::TypeOfExpr(Expr *E, QualType can)
- : Type(TypeOfExp, can, E->isTypeDependent()), TOExpr(E) {
+TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
+ : Type(TypeOfExpr, can, E->isTypeDependent()), TOExpr(E) {
assert(!isa<TypedefType>(can) && "Invalid canonical type");
}
ElementType.getAsStringInternal(S);
}
-void TypeOfExpr::getAsStringInternal(std::string &InnerString) const {
+void TypeOfExprType::getAsStringInternal(std::string &InnerString) const {
if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(e) X'.
InnerString = ' ' + InnerString;
std::string Str;
InnerString = "typeof(" + Tmp + ")" + InnerString;
}
-void FunctionTypeNoProto::getAsStringInternal(std::string &S) const {
+void FunctionNoProtoType::getAsStringInternal(std::string &S) const {
// If needed for precedence reasons, wrap the inner part in grouping parens.
if (!S.empty())
S = "(" + S + ")";
getResultType().getAsStringInternal(S);
}
-void FunctionTypeProto::getAsStringInternal(std::string &S) const {
+void FunctionProtoType::getAsStringInternal(std::string &S) const {
// If needed for precedence reasons, wrap the inner part in grouping parens.
if (!S.empty())
S = "(" + S + ")";
break;
case Type::FunctionNoProto:
- D.RegisterPtr(PtrID,FunctionTypeNoProto::CreateImpl(Context,D));
+ D.RegisterPtr(PtrID,FunctionNoProtoType::CreateImpl(Context,D));
break;
case Type::FunctionProto:
- D.RegisterPtr(PtrID,FunctionTypeProto::CreateImpl(Context,D));
+ D.RegisterPtr(PtrID,FunctionProtoType::CreateImpl(Context,D));
break;
case Type::IncompleteArray:
D.RegisterPtr(PtrID, ReferenceType::CreateImpl(Context, D));
break;
- case Type::Tagged:
- D.RegisterPtr(PtrID, TagType::CreateImpl(Context, D));
+ case Type::Record:
+ case Type::CXXRecord:
+ case Type::Enum:
+ // FIXME: Implement this!
+ assert(false && "Can't deserialize tag types!");
break;
- case Type::TypeName:
+ case Type::Typedef:
D.RegisterPtr(PtrID, TypedefType::CreateImpl(Context, D));
break;
- case Type::TypeOfExp:
- D.RegisterPtr(PtrID, TypeOfExpr::CreateImpl(Context, D));
+ case Type::TypeOfExpr:
+ D.RegisterPtr(PtrID, TypeOfExprType::CreateImpl(Context, D));
break;
- case Type::TypeOfTyp:
+ case Type::TypeOf:
D.RegisterPtr(PtrID, TypeOfType::CreateImpl(Context, D));
break;
}
//===----------------------------------------------------------------------===//
-// FunctionTypeNoProto
+// FunctionNoProtoType
//===----------------------------------------------------------------------===//
-void FunctionTypeNoProto::EmitImpl(Serializer& S) const {
+void FunctionNoProtoType::EmitImpl(Serializer& S) const {
S.Emit(getResultType());
}
-Type* FunctionTypeNoProto::CreateImpl(ASTContext& Context, Deserializer& D) {
- return Context.getFunctionTypeNoProto(QualType::ReadVal(D)).getTypePtr();
+Type* FunctionNoProtoType::CreateImpl(ASTContext& Context, Deserializer& D) {
+ return Context.getFunctionNoProtoType(QualType::ReadVal(D)).getTypePtr();
}
//===----------------------------------------------------------------------===//
-// FunctionTypeProto
+// FunctionProtoType
//===----------------------------------------------------------------------===//
-void FunctionTypeProto::EmitImpl(Serializer& S) const {
+void FunctionProtoType::EmitImpl(Serializer& S) const {
S.Emit(getResultType());
S.EmitBool(isVariadic());
S.EmitInt(getTypeQuals());
S.Emit(*I);
}
-Type* FunctionTypeProto::CreateImpl(ASTContext& Context, Deserializer& D) {
+Type* FunctionProtoType::CreateImpl(ASTContext& Context, Deserializer& D) {
QualType ResultType = QualType::ReadVal(D);
bool isVariadic = D.ReadBool();
unsigned TypeQuals = D.ReadInt();
std::vector<Type*>& Types =
const_cast<std::vector<Type*>&>(Context.getTypes());
- TagType* T = new TagType(NULL,QualType());
+ // FIXME: This is wrong: we need the subclasses to do the
+ // (de-)serialization.
+ TagType* T = new TagType(Record, NULL,QualType());
Types.push_back(T);
// Deserialize the decl.
std::vector<Type*>& Types =
const_cast<std::vector<Type*>&>(Context.getTypes());
- TypedefType* T = new TypedefType(Type::TypeName, NULL, QualType::ReadVal(D));
+ TypedefType* T = new TypedefType(Type::Typedef, NULL, QualType::ReadVal(D));
Types.push_back(T);
D.ReadPtr(T->Decl); // May be backpatched.
}
//===----------------------------------------------------------------------===//
-// TypeOfExpr
+// TypeOfExprType
//===----------------------------------------------------------------------===//
-void TypeOfExpr::EmitImpl(llvm::Serializer& S) const {
+void TypeOfExprType::EmitImpl(llvm::Serializer& S) const {
S.EmitOwnedPtr(TOExpr);
}
-Type* TypeOfExpr::CreateImpl(ASTContext& Context, Deserializer& D) {
+Type* TypeOfExprType::CreateImpl(ASTContext& Context, Deserializer& D) {
Expr* E = D.ReadOwnedPtr<Expr>(Context);
std::vector<Type*>& Types =
const_cast<std::vector<Type*>&>(Context.getTypes());
- TypeOfExpr* T = new TypeOfExpr(E, Context.getCanonicalType(E->getType()));
+ TypeOfExprType* T
+ = new TypeOfExprType(E, Context.getCanonicalType(E->getType()));
Types.push_back(T);
return T;
// Sanity check that this is *really* a unary function. This can
// happen if people do weird things.
- const FunctionTypeProto* FTP = dyn_cast<FunctionTypeProto>(FT);
+ const FunctionProtoType* FTP = dyn_cast<FunctionProtoType>(FT);
if (!FTP || FTP->getNumArgs() != 1)
return getPersistentStopSummary();
NodeSet& Dst)
{
// Determine the type of function we're calling (if available).
- const FunctionTypeProto *Proto = NULL;
+ const FunctionProtoType *Proto = NULL;
QualType FnType = CE->getCallee()->IgnoreParens()->getType();
if (const PointerType *FnTypePtr = FnType->getAsPointerType())
- Proto = FnTypePtr->getPointeeType()->getAsFunctionTypeProto();
+ Proto = FnTypePtr->getPointeeType()->getAsFunctionProtoType();
VisitCallRec(CE, Pred, AI, AE, Dst, Proto, /*ParamIdx=*/0);
}
void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
CallExpr::arg_iterator AI,
CallExpr::arg_iterator AE,
- NodeSet& Dst, const FunctionTypeProto *Proto,
+ NodeSet& Dst, const FunctionProtoType *Proto,
unsigned ParamIdx) {
// Process the arguments.
/// function type for the block, including the first block literal argument.
static QualType getBlockFunctionType(ASTContext &Ctx,
const BlockPointerType *BPT) {
- const FunctionTypeProto *FTy = cast<FunctionTypeProto>(BPT->getPointeeType());
+ const FunctionProtoType *FTy = cast<FunctionProtoType>(BPT->getPointeeType());
llvm::SmallVector<QualType, 8> Types;
Types.push_back(Ctx.getPointerType(Ctx.VoidTy));
- for (FunctionTypeProto::arg_type_iterator i = FTy->arg_type_begin(),
+ for (FunctionProtoType::arg_type_iterator i = FTy->arg_type_begin(),
e = FTy->arg_type_end(); i != e; ++i)
Types.push_back(*i);
const BlockInfo& Info,
uint64_t &Size,
uint64_t &Align,
- llvm::SmallVector<ValueDecl *, 8> &subBlockDeclRefDecls) {
- const FunctionTypeProto *FTy =
- cast<FunctionTypeProto>(Expr->getFunctionType());
+ llvm::SmallVector<ValueDecl *, 8> &subBlockDeclRefDecls) {
+ const FunctionProtoType *FTy =
+ cast<FunctionProtoType>(Expr->getFunctionType());
FunctionArgList Args;
// FIXME: Use iterator and sidestep silly type array creation.
const
-CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionTypeNoProto *FTNP) {
+CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionNoProtoType *FTNP) {
return getFunctionInfo(FTNP->getResultType(),
llvm::SmallVector<QualType, 16>());
}
const
-CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionTypeProto *FTP) {
+CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionProtoType *FTP) {
llvm::SmallVector<QualType, 16> ArgTys;
// FIXME: Kill copy.
for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionDecl *FD) {
const FunctionType *FTy = FD->getType()->getAsFunctionType();
- if (const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(FTy))
+ if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FTy))
return getFunctionInfo(FTP);
- return getFunctionInfo(cast<FunctionTypeNoProto>(FTy));
+ return getFunctionInfo(cast<FunctionNoProtoType>(FTy));
}
const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const ObjCMethodDecl *MD) {
// Set up remainder of arguments if there is a prototype.
// FIXME: IF NOT, HOW IS THIS REPRESENTED? llvm-gcc doesn't represent '...'!
- if (const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(Ty)) {
+ if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) {
for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit));
} else {
// Work out details of type.
switch (Ty->getTypeClass()) {
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base)
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+ assert(false && "Dependent types cannot show up in debug information");
+
case Type::Complex:
case Type::Reference:
case Type::Vector:
case Type::ObjCInterface:
case Type::ObjCQualifiedInterface:
case Type::ObjCQualifiedId:
- default:
return llvm::DIType();
case Type::Builtin: Slot = CreateType(cast<BuiltinType>(Ty), Unit); break;
case Type::Pointer: Slot = CreateType(cast<PointerType>(Ty), Unit); break;
- case Type::TypeName: Slot = CreateType(cast<TypedefType>(Ty), Unit); break;
- case Type::Tagged: Slot = CreateType(cast<TagType>(Ty), Unit); break;
+ case Type::Typedef: Slot = CreateType(cast<TypedefType>(Ty), Unit); break;
+ case Type::Record:
+ case Type::CXXRecord:
+ case Type::Enum:
+ Slot = CreateType(cast<TagType>(Ty), Unit);
+ break;
case Type::FunctionProto:
case Type::FunctionNoProto:
return Slot = CreateType(cast<FunctionType>(Ty), Unit);
case Type::VariableArray:
case Type::IncompleteArray:
return Slot = CreateType(cast<ArrayType>(Ty), Unit);
- case Type::TypeOfExp:
- return Slot = getOrCreateType(cast<TypeOfExpr>(Ty)->getUnderlyingExpr()
+ case Type::TypeOfExpr:
+ return Slot = getOrCreateType(cast<TypeOfExprType>(Ty)->getUnderlyingExpr()
->getType(), Unit);
- case Type::TypeOfTyp:
+ case Type::TypeOf:
return Slot = getOrCreateType(cast<TypeOfType>(Ty)->getUnderlyingType(),
Unit);
}
FunctionArgList Args;
if (FD->getNumParams()) {
- const FunctionTypeProto* FProto = FD->getType()->getAsFunctionTypeProto();
+ const FunctionProtoType* FProto = FD->getType()->getAsFunctionProtoType();
assert(FProto && "Function def must have prototype!");
for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
class Decl;
class EnumConstantDecl;
class FunctionDecl;
- class FunctionTypeProto;
+ class FunctionProtoType;
class LabelStmt;
class ObjCContainerDecl;
class ObjCInterfaceDecl;
const clang::Type &Ty = *Context.getCanonicalType(T);
switch (Ty.getTypeClass()) {
- case Type::TypeName: // typedef isn't canonical.
- case Type::TemplateTypeParm:// template type parameters never generated
- case Type::ClassTemplateSpecialization: // these types are always sugar
- case Type::DependentSizedArray: // dependent types are never generated
- case Type::TypeOfExp: // typeof isn't canonical.
- case Type::TypeOfTyp: // typeof isn't canonical.
- assert(0 && "Non-canonical type, shouldn't happen");
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+ assert(false && "Non-canonical or dependent types aren't possible.");
+ break;
+
case Type::Builtin: {
switch (cast<BuiltinType>(Ty).getKind()) {
default: assert(0 && "Unknown builtin type!");
VT.getNumElements());
}
case Type::FunctionNoProto:
- return GetFunctionType(getFunctionInfo(cast<FunctionTypeNoProto>(&Ty)),
+ return GetFunctionType(getFunctionInfo(cast<FunctionNoProtoType>(&Ty)),
true);
case Type::FunctionProto: {
- const FunctionTypeProto *FTP = cast<FunctionTypeProto>(&Ty);
+ const FunctionProtoType *FTP = cast<FunctionProtoType>(&Ty);
return GetFunctionType(getFunctionInfo(FTP), FTP->isVariadic());
}
// Protocols don't influence the LLVM type.
return ConvertTypeRecursive(Context.getObjCIdType());
- case Type::Tagged: {
+ case Type::Record:
+ case Type::CXXRecord:
+ case Type::Enum: {
const TagDecl *TD = cast<TagType>(Ty).getDecl();
const llvm::Type *Res = ConvertTagDeclType(TD);
class ABIInfo;
class ASTContext;
class FieldDecl;
- class FunctionTypeProto;
+ class FunctionProtoType;
class ObjCInterfaceDecl;
class ObjCIvarDecl;
class PointerType;
const llvm::SmallVector<QualType,16>
&ArgTys);
- const CGFunctionInfo &getFunctionInfo(const FunctionTypeNoProto *FTNP);
- const CGFunctionInfo &getFunctionInfo(const FunctionTypeProto *FTP);
+ const CGFunctionInfo &getFunctionInfo(const FunctionNoProtoType *FTNP);
+ const CGFunctionInfo &getFunctionInfo(const FunctionProtoType *FTP);
const CGFunctionInfo &getFunctionInfo(const FunctionDecl *FD);
const CGFunctionInfo &getFunctionInfo(const ObjCMethodDecl *MD);
const CGFunctionInfo &getFunctionInfo(QualType ResTy,
if (MangleReturnType)
mangleType(T->getResultType());
- const FunctionTypeProto *Proto = dyn_cast<FunctionTypeProto>(T);
+ const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(T);
assert(Proto && "Can't mangle K&R function prototypes");
- for (FunctionTypeProto::arg_type_iterator Arg = Proto->arg_type_begin(),
+ for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(),
ArgEnd = Proto->arg_type_end();
Arg != ArgEnd; ++Arg)
mangleType(*Arg);
Expr *From, QualType ToType,
OverloadCandidateSet& CandidateSet);
void AddSurrogateCandidate(CXXConversionDecl *Conversion,
- const FunctionTypeProto *Proto,
+ const FunctionProtoType *Proto,
Expr *Object, Expr **Args, unsigned NumArgs,
OverloadCandidateSet& CandidateSet);
bool AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
IdentifierInfo &Member);
bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
FunctionDecl *FDecl,
- const FunctionTypeProto *Proto,
+ const FunctionProtoType *Proto,
Expr **Args, unsigned NumArgs,
SourceLocation RParenLoc);
if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) {
if (Format->getType() == "printf") {
bool HasVAListArg = false;
- if (const FunctionTypeProto *Proto
- = FDecl->getType()->getAsFunctionTypeProto())
+ if (const FunctionProtoType *Proto
+ = FDecl->getType()->getAsFunctionProtoType())
HasVAListArg = !Proto->isVariadic();
CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1,
Format->getFirstArg() - 1);
// Determine whether the current function is variadic or not.
bool isVariadic;
if (getCurFunctionDecl()) {
- if (FunctionTypeProto* FTP =
- dyn_cast<FunctionTypeProto>(getCurFunctionDecl()->getType()))
+ if (FunctionProtoType* FTP =
+ dyn_cast<FunctionProtoType>(getCurFunctionDecl()->getType()))
isVariadic = FTP->isVariadic();
else
isVariadic = false;
// Create Decl objects for each parameter, adding them to the
// FunctionDecl.
- if (FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(R)) {
+ if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
llvm::SmallVector<ParmVarDecl*, 16> Params;
for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
if (!getLangOptions().CPlusPlus &&
Context.typesAreCompatible(OldQType, NewQType)) {
const FunctionType *NewFuncType = NewQType->getAsFunctionType();
- const FunctionTypeProto *OldProto = 0;
- if (isa<FunctionTypeNoProto>(NewFuncType) &&
- (OldProto = OldQType->getAsFunctionTypeProto())) {
+ const FunctionProtoType *OldProto = 0;
+ if (isa<FunctionNoProtoType>(NewFuncType) &&
+ (OldProto = OldQType->getAsFunctionProtoType())) {
// The old declaration provided a function prototype, but the
// new declaration does not. Merge in the prototype.
llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
// Synthesize a parameter for each argument type.
llvm::SmallVector<ParmVarDecl*, 16> Params;
- for (FunctionTypeProto::arg_type_iterator
+ for (FunctionProtoType::arg_type_iterator
ParamType = OldProto->arg_type_begin(),
ParamEnd = OldProto->arg_type_end();
ParamType != ParamEnd; ++ParamType) {
// typedef void fn(int);
// fn f;
// @endcode
- const FunctionTypeProto *FT = R->getAsFunctionTypeProto();
+ const FunctionProtoType *FT = R->getAsFunctionProtoType();
if (!FT) {
// This is a typedef of a function with no prototype, so we
// don't need to do anything.
} else {
// Synthesize a parameter for each argument type.
llvm::SmallVector<ParmVarDecl*, 16> Params;
- for (FunctionTypeProto::arg_type_iterator ArgType = FT->arg_type_begin();
+ for (FunctionProtoType::arg_type_iterator ArgType = FT->arg_type_begin();
ArgType != FT->arg_type_end(); ++ArgType) {
ParmVarDecl *Param = ParmVarDecl::Create(Context, DC,
SourceLocation(), 0,
// Functions marked "overloadable" must have a prototype (that
// we can't get through declaration merging).
- if (!R->getAsFunctionTypeProto()) {
+ if (!R->getAsFunctionProtoType()) {
Diag(NewFD->getLocation(), diag::err_attribute_overloadable_no_prototype)
<< NewFD;
InvalidDecl = true;
/// isFunctionOrMethod.
static bool hasFunctionProto(Decl *d) {
if (const FunctionType *FnTy = getFunctionType(d)) {
- return isa<FunctionTypeProto>(FnTy);
+ return isa<FunctionProtoType>(FnTy);
} else {
assert(isa<ObjCMethodDecl>(d));
return true;
/// hasFunctionProto first).
static unsigned getFunctionOrMethodNumArgs(Decl *d) {
if (const FunctionType *FnTy = getFunctionType(d))
- return cast<FunctionTypeProto>(FnTy)->getNumArgs();
+ return cast<FunctionProtoType>(FnTy)->getNumArgs();
return cast<ObjCMethodDecl>(d)->param_size();
}
static QualType getFunctionOrMethodArgType(Decl *d, unsigned Idx) {
if (const FunctionType *FnTy = getFunctionType(d))
- return cast<FunctionTypeProto>(FnTy)->getArgType(Idx);
+ return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
return cast<ObjCMethodDecl>(d)->param_begin()[Idx]->getType();
}
static bool isFunctionOrMethodVariadic(Decl *d) {
if (const FunctionType *FnTy = getFunctionType(d)) {
- const FunctionTypeProto *proto = cast<FunctionTypeProto>(FnTy);
+ const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
return proto->isVariadic();
} else {
return cast<ObjCMethodDecl>(d)->isVariadic();
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) {
QualType FT = FD->getType();
- if (!FT->getAsFunctionTypeProto()->isVariadic()) {
+ if (!FT->getAsFunctionProtoType()->isVariadic()) {
S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic);
return;
}
<< SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
<< SourceRange(D.getIdentifierLoc());
}
- if (R->getAsFunctionTypeProto()->getTypeQuals() != 0) {
+ if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
if (FTI.TypeQuals & QualType::Const)
Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
// return type, since constructors don't have return types. We
// *always* have to do this, because GetTypeForDeclarator will
// put in a result type of "int" when none was specified.
- const FunctionTypeProto *Proto = R->getAsFunctionTypeProto();
+ const FunctionProtoType *Proto = R->getAsFunctionProtoType();
R = Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
Proto->getNumArgs(),
Proto->isVariadic(),
<< SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
<< SourceRange(D.getIdentifierLoc());
}
- if (R->getAsFunctionTypeProto()->getTypeQuals() != 0) {
+ if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
if (FTI.TypeQuals & QualType::Const)
Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
}
// Make sure we don't have any parameters.
- if (R->getAsFunctionTypeProto()->getNumArgs() > 0) {
+ if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
// Delete the parameters.
}
// Make sure the destructor isn't variadic.
- if (R->getAsFunctionTypeProto()->isVariadic())
+ if (R->getAsFunctionProtoType()->isVariadic())
Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
// Rebuild the function type "R" without any type qualifiers or
}
// Make sure we don't have any parameters.
- if (R->getAsFunctionTypeProto()->getNumArgs() > 0) {
+ if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
// Delete the parameters.
}
// Make sure the conversion function isn't variadic.
- if (R->getAsFunctionTypeProto()->isVariadic())
+ if (R->getAsFunctionProtoType()->isVariadic())
Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
// C++ [class.conv.fct]p4:
// of the errors above fired) and with the conversion type as the
// return type.
R = Context.getFunctionType(ConvType, 0, 0, false,
- R->getAsFunctionTypeProto()->getTypeQuals());
+ R->getAsFunctionProtoType()->getTypeQuals());
// C++0x explicit conversion operators.
if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
// Overloaded operators other than operator() cannot be variadic.
if (Op != OO_Call &&
- FnDecl->getType()->getAsFunctionTypeProto()->isVariadic()) {
+ FnDecl->getType()->getAsFunctionProtoType()->isVariadic()) {
return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
<< FnDecl->getDeclName();
}
// type.
QualType T = Func->getType();
QualType NoProtoType = T;
- if (const FunctionTypeProto *Proto = T->getAsFunctionTypeProto())
- NoProtoType = Context.getFunctionTypeNoProto(Proto->getResultType());
+ if (const FunctionProtoType *Proto = T->getAsFunctionProtoType())
+ NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType());
return Owned(BuildDeclRefExpr(VD, NoProtoType, Loc, false, false, SS));
}
}
bool
Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
FunctionDecl *FDecl,
- const FunctionTypeProto *Proto,
+ const FunctionProtoType *Proto,
Expr **Args, unsigned NumArgs,
SourceLocation RParenLoc) {
// C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
// We know the result type of the call, set it.
TheCall->setType(FuncT->getResultType().getNonReferenceType());
- if (const FunctionTypeProto *Proto = dyn_cast<FunctionTypeProto>(FuncT)) {
+ if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) {
if (ConvertArgumentsForCall(&*TheCall, Fn, FDecl, Proto, Args, NumArgs,
RParenLoc))
return ExprError();
} else {
- assert(isa<FunctionTypeNoProto>(FuncT) && "Unknown FunctionType!");
+ assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
// Promote the arguments (C99 6.5.2.2p6).
for (unsigned i = 0; i != NumArgs; i++) {
QualType BlockTy;
if (!BSI->hasPrototype)
- BlockTy = Context.getFunctionTypeNoProto(RetTy);
+ BlockTy = Context.getFunctionNoProtoType(RetTy);
else
BlockTy = Context.getFunctionType(RetTy, &ArgTypes[0], ArgTypes.size(),
BSI->isVariadic, 0);
Context,
AssociatedNamespaces, AssociatedClasses);
- const FunctionTypeProto *Proto = dyn_cast<FunctionTypeProto>(FunctionType);
+ const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FunctionType);
if (!Proto)
return;
// Argument types
- for (FunctionTypeProto::arg_type_iterator Arg = Proto->arg_type_begin(),
+ for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(),
ArgEnd = Proto->arg_type_end();
Arg != ArgEnd; ++Arg)
addAssociatedClassesAndNamespaces(*Arg, Context,
// If either of these functions is a K&R-style function (no
// prototype), then we consider them to have matching signatures.
- if (isa<FunctionTypeNoProto>(OldQType.getTypePtr()) ||
- isa<FunctionTypeNoProto>(NewQType.getTypePtr()))
+ if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
+ isa<FunctionNoProtoType>(NewQType.getTypePtr()))
return false;
- FunctionTypeProto* OldType = cast<FunctionTypeProto>(OldQType.getTypePtr());
- FunctionTypeProto* NewType = cast<FunctionTypeProto>(NewQType.getTypePtr());
+ FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType.getTypePtr());
+ FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType.getTypePtr());
// The signature of a function includes the types of its
// parameters (C++ 1.3.10), which includes the presence or absence
// differences in the argument and result types are in Objective-C
// pointer conversions. If so, we permit the conversion (but
// complain about it).
- const FunctionTypeProto *FromFunctionType
- = FromPointeeType->getAsFunctionTypeProto();
- const FunctionTypeProto *ToFunctionType
- = ToPointeeType->getAsFunctionTypeProto();
+ const FunctionProtoType *FromFunctionType
+ = FromPointeeType->getAsFunctionProtoType();
+ const FunctionProtoType *ToFunctionType
+ = ToPointeeType->getAsFunctionProtoType();
if (FromFunctionType && ToFunctionType) {
// If the function types are exactly the same, this isn't an
// Objective-C pointer conversion.
OverloadCandidateSet& CandidateSet,
bool SuppressUserConversions)
{
- const FunctionTypeProto* Proto
- = dyn_cast<FunctionTypeProto>(Function->getType()->getAsFunctionType());
+ const FunctionProtoType* Proto
+ = dyn_cast<FunctionProtoType>(Function->getType()->getAsFunctionType());
assert(Proto && "Functions without a prototype cannot be overloaded");
assert(!isa<CXXConversionDecl>(Function) &&
"Use AddConversionCandidate for conversion functions");
OverloadCandidateSet& CandidateSet,
bool SuppressUserConversions)
{
- const FunctionTypeProto* Proto
- = dyn_cast<FunctionTypeProto>(Method->getType()->getAsFunctionType());
+ const FunctionProtoType* Proto
+ = dyn_cast<FunctionProtoType>(Method->getType()->getAsFunctionType());
assert(Proto && "Methods without a prototype cannot be overloaded");
assert(!isa<CXXConversionDecl>(Method) &&
"Use AddConversionCandidate for conversion functions");
/// with the given arguments (C++ [over.call.object]p2-4). Proto is
/// the type of function that we'll eventually be calling.
void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
- const FunctionTypeProto *Proto,
+ const FunctionProtoType *Proto,
Expr *Object, Expr **Args, unsigned NumArgs,
OverloadCandidateSet& CandidateSet) {
CandidateSet.push_back(OverloadCandidate());
if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
return true;
- const FunctionTypeProto *Proto = Fn->getType()->getAsFunctionTypeProto();
+ const FunctionProtoType *Proto = Fn->getType()->getAsFunctionProtoType();
if (Proto->getNumArgs() < 1)
return false;
MemExpr->setBase(ObjectArg);
// Convert the rest of the arguments
- const FunctionTypeProto *Proto = cast<FunctionTypeProto>(Method->getType());
+ const FunctionProtoType *Proto = cast<FunctionProtoType>(Method->getType());
if (ConvertArgumentsForCall(&*TheCall, MemExpr, Method, Proto, Args, NumArgs,
RParenLoc))
return true;
if (const PointerType *ConvPtrType = ConvType->getAsPointerType())
ConvType = ConvPtrType->getPointeeType();
- if (const FunctionTypeProto *Proto = ConvType->getAsFunctionTypeProto())
+ if (const FunctionProtoType *Proto = ConvType->getAsFunctionProtoType())
AddSurrogateCandidate(Conv, Proto, Object, Args, NumArgs, CandidateSet);
}
// that calls this method, using Object for the implicit object
// parameter and passing along the remaining arguments.
CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
- const FunctionTypeProto *Proto = Method->getType()->getAsFunctionTypeProto();
+ const FunctionProtoType *Proto = Method->getType()->getAsFunctionProtoType();
unsigned NumArgsInProto = Proto->getNumArgs();
unsigned NumArgsToCheck = NumArgs;
Expr *E = static_cast<Expr *>(DS.getTypeRep());
assert(E && "Didn't get an expression for typeof?");
// TypeQuals handled by caller.
- Result = Context.getTypeOfExpr(E);
+ Result = Context.getTypeOfExprType(E);
break;
}
case DeclSpec::TST_error:
T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, 0);
} else {
// Simple void foo(), where the incoming T is the result type.
- T = Context.getFunctionTypeNoProto(T);
+ T = Context.getFunctionNoProtoType(T);
}
} else if (FTI.ArgInfo[0].Param == 0) {
// C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function definition.
// Look for 'void'. void is allowed only as a single argument to a
// function with no other parameters (C99 6.7.5.3p10). We record
- // int(void) as a FunctionTypeProto with an empty argument list.
+ // int(void) as a FunctionProtoType with an empty argument list.
else if (ArgTy->isVoidType()) {
// If this is something like 'float(int, void)', reject it. 'void'
// is an incomplete type (C99 6.2.5p19) and function decls cannot
}
if (getLangOptions().CPlusPlus && T->isFunctionType()) {
- const FunctionTypeProto *FnTy = T->getAsFunctionTypeProto();
- assert(FnTy && "Why oh why is there not a FunctionTypeProto here ?");
+ const FunctionProtoType *FnTy = T->getAsFunctionProtoType();
+ assert(FnTy && "Why oh why is there not a FunctionProtoType here ?");
// C++ 8.3.5p4: A cv-qualifier-seq shall only be part of the function type
// for a nonstatic member function, the function type to which a pointer
projects / clang / commitdiff