Stage two of getting CFE top correct.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@39734 91177308-0d34-0410-b5e6-96231b3b80d8

40 files changed, 8394 insertions, 0 deletions

diff --git a/include/clang/AST/AST.h b/include/clang/AST/AST.h
new file mode 100644
index 0000000000..a185692985
--- /dev/null
+++ b/include/clang/AST/AST.h
@@ -0,0 +1,24 @@
+//===--- AST.h - "Umbrella" header for AST library --------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the interface to the AST classes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_AST_H
+#define LLVM_CLANG_AST_AST_H
+
+// This header exports all AST interfaces.
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/StmtVisitor.h"
+
+#endif
diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
new file mode 100644
index 0000000000..759940dfdd
--- /dev/null
+++ b/include/clang/AST/ASTContext.h
@@ -0,0 +1,128 @@
+//===--- ASTContext.h - Context to hold long-lived AST nodes ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the ASTContext interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_ASTCONTEXT_H
+#define LLVM_CLANG_AST_ASTCONTEXT_H
+
+#include "clang/AST/Builtins.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/Expr.h"
+#include <vector>
+
+namespace clang {
+  class TargetInfo;
+  
+/// ASTContext - This class holds long-lived AST nodes (such as types and
+/// decls) that can be referred to throughout the semantic analysis of a file.
+class ASTContext {
+  std::vector<Type*> Types;
+  llvm::FoldingSet<ComplexType> ComplexTypes;
+  llvm::FoldingSet<PointerType> PointerTypes;
+  llvm::FoldingSet<ReferenceType> ReferenceTypes;
+  llvm::FoldingSet<ArrayType> ArrayTypes;
+  llvm::FoldingSet<VectorType> VectorTypes;
+  llvm::FoldingSet<FunctionTypeNoProto> FunctionTypeNoProtos;
+  llvm::FoldingSet<FunctionTypeProto> FunctionTypeProtos;
+public:
+  TargetInfo &Target;
+  Builtin::Context BuiltinInfo;
+
+  // Builtin Types.
+  QualType VoidTy;
+  QualType BoolTy;
+  QualType CharTy;
+  QualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy;
+  QualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;
+  QualType UnsignedLongLongTy;
+  QualType FloatTy, DoubleTy, LongDoubleTy;
+  QualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy;
+  
+  ASTContext(TargetInfo &t, IdentifierTable &idents) : Target(t) {
+    InitBuiltinTypes();
+    BuiltinInfo.InitializeBuiltins(idents, Target);
+  }    
+  ~ASTContext();
+  
+  void PrintStats() const;
+
+  /// getComplexType - Return the uniqued reference to the type for a complex
+  /// number with the specified element type.
+  QualType getComplexType(QualType T);
+  
+  /// getPointerType - Return the uniqued reference to the type for a pointer to
+  /// the specified type.
+  QualType getPointerType(QualType T);
+  
+  /// getReferenceType - Return the uniqued reference to the type for a
+  /// reference to the specified type.
+  QualType getReferenceType(QualType T);
+  
+  /// getArrayType - Return the unique reference to the type for an array of the
+  /// specified element type.
+  QualType getArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM,
+                        unsigned EltTypeQuals, Expr *NumElts);
+                        
+  /// convertToVectorType - Return the unique reference to a vector type of
+  /// the specified element type and size. VectorType can be a pointer, array,
+  /// function, or built-in type (i.e. _Bool, integer, or float).
+  QualType convertToVectorType(QualType VectorType, unsigned NumElts);
+
+  /// getFunctionTypeNoProto - Return a K&R style C function type like 'int()'.
+  ///
+  QualType getFunctionTypeNoProto(QualType ResultTy);
+  
+  /// getFunctionType - Return a normal function type with a typed argument
+  /// list.  isVariadic indicates whether the argument list includes '...'.
+  QualType getFunctionType(QualType ResultTy, QualType *ArgArray,
+                           unsigned NumArgs, bool isVariadic);
+  
+  /// getTypedefType - Return the unique reference to the type for the
+  /// specified typename decl.
+  QualType getTypedefType(TypedefDecl *Decl);
+
+  /// getTagDeclType - Return the unique reference to the type for the
+  /// specified TagDecl (struct/union/class/enum) decl.
+  QualType getTagDeclType(TagDecl *Decl);
+  
+  /// getSizeType - Return the unique type for "size_t" (C99 7.17), defined
+  /// in <stddef.h>. The sizeof operator requires this (C99 6.5.3.4p4).
+  QualType getSizeType() const;
+  
+  /// getIntegerBitwidth - Return the bitwidth of the specified integer type
+  /// according to the target.  'Loc' specifies the source location that
+  /// requires evaluation of this property.
+  unsigned getIntegerBitwidth(QualType T, SourceLocation Loc);
+
+  // maxIntegerType - Returns the highest ranked integer type. Handles 3
+  // different type combos: unsigned/unsigned, signed/signed, signed/unsigned.
+  static QualType maxIntegerType(QualType lhs, QualType rhs);
+  
+  // maxFloatingType - Returns the highest ranked float type. Both input 
+  // types are required to be floats.
+  static QualType maxFloatingType(QualType lt, QualType rt);
+
+  // maxComplexType - Returns the highest ranked complex type. Handles 3
+  // different type combos: complex/complex, complex/float, float/complex. 
+  QualType maxComplexType(QualType lt, QualType rt) const;
+  
+private:
+  ASTContext(const ASTContext&); // DO NOT IMPLEMENT
+  void operator=(const ASTContext&); // DO NOT IMPLEMENT
+  
+  void InitBuiltinTypes();
+  void InitBuiltinType(QualType &R, BuiltinType::Kind K);
+};
+  
+}  // end namespace clang
+
+#endif
diff --git a/include/clang/AST/Builtins.def b/include/clang/AST/Builtins.def
new file mode 100644
index 0000000000..97431da951
--- /dev/null
+++ b/include/clang/AST/Builtins.def
@@ -0,0 +1,53 @@
+//===--- Builtins.def - Builtin function info database ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the standard builtin function database.  Users of this file
+// must define the BUILTIN macro to make use of this information.
+//
+//===----------------------------------------------------------------------===//
+
+// FIXME: this needs to be the full list supported by GCC.  Right now, I'm just
+// adding stuff on demand.
+//
+// FIXME: This should really be a .td file, but that requires modifying tblgen.
+// Perhaps tblgen should have plugins.
+
+// The first value provided to the macro specifies the function name of the
+// builtin, and results in a clang::builtin::BIXX enum value for XX.
+
+// The second value provided to the macro specifies the type of the function
+// (result value, then each argument) as follows:
+//  v -> void
+//  c -> char
+//  s -> short
+//  i -> int
+//  f -> float
+//  d -> double
+//  . -> "...".  This may only occur at the end of the function list.
+//
+// Types maybe prefixed with the following modifiers:
+//  L  -> long (e.g. Li for 'long int')
+//  LL -> long long
+//  S  -> signed
+//  U  -> unsigned
+
+// The third value provided to the macro specifies information about attributes
+// of the function.  Currently we have:
+//  n -> nothrow
+//  c -> const
+
+BUILTIN(__builtin_inf  , "d"   , "nc")
+BUILTIN(__builtin_inff , "f"   , "nc")
+BUILTIN(__builtin_infl , "Ld"  , "nc")
+BUILTIN(__builtin_fabs , "dd"  , "nc")
+BUILTIN(__builtin_fabsf, "ff"  , "nc")
+BUILTIN(__builtin_fabsl, "LdLd", "nc")
+BUILTIN(__builtin_constant_p, "UsUs", "nc")
+
+#undef BUILTIN
diff --git a/include/clang/AST/Builtins.h b/include/clang/AST/Builtins.h
new file mode 100644
index 0000000000..682031f7be
--- /dev/null
+++ b/include/clang/AST/Builtins.h
@@ -0,0 +1,72 @@
+//===--- Builtins.h - Builtin function header -------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines enum values for all the target-independent builtin
+// functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_BUILTINS_H
+#define LLVM_CLANG_AST_BUILTINS_H
+
+#include <cstring>
+
+namespace clang {
+  class TargetInfo;
+  class IdentifierTable;
+  class ASTContext;
+  class QualType;
+
+namespace Builtin {
+enum ID {
+  NotBuiltin  = 0,      // This is not a builtin function.
+#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+#include "clang/AST/Builtins.def"
+  FirstTSBuiltin
+};
+
+struct Info {
+  const char *Name, *Type, *Attributes;
+  
+  bool operator==(const Info &RHS) const {
+    return !strcmp(Name, RHS.Name) &&
+           !strcmp(Type, RHS.Type) &&
+           !strcmp(Attributes, RHS.Attributes);
+  }
+  bool operator!=(const Info &RHS) const { return !(*this == RHS); }
+};
+
+/// Builtin::Context - This holds information about target-independent and
+/// target-specific builtins, allowing easy queries by clients.
+class Context {
+  const Info *TSRecords;
+  unsigned NumTSRecords;
+public:
+  Context() : TSRecords(0), NumTSRecords(0) {}
+  
+  /// InitializeBuiltins - Mark the identifiers for all the builtins with their
+  /// appropriate builtin ID # and mark any non-portable builtin identifiers as
+  /// such.
+  void InitializeBuiltins(IdentifierTable &Table, const TargetInfo &Target);
+  
+  /// Builtin::GetName - Return the identifier name for the specified builtin,
+  /// e.g. "__builtin_abs".
+  const char *GetName(unsigned ID) const {
+    return GetRecord(ID).Name;
+  }
+  
+  /// GetBuiltinType - Return the type for the specified builtin.
+  QualType GetBuiltinType(unsigned ID, ASTContext &Context) const;
+private:
+  const Info &GetRecord(unsigned ID) const;
+};
+
+}
+} // end namespace clang
+#endif
diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
new file mode 100644
index 0000000000..2d3b01d3ce
--- /dev/null
+++ b/include/clang/AST/Decl.h
@@ -0,0 +1,442 @@
+//===--- Decl.h - Classes for representing declarations ---------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the Decl interface and subclasses.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_DECL_H
+#define LLVM_CLANG_AST_DECL_H
+
+#include "clang/Basic/SourceLocation.h"
+#include "clang/AST/Type.h"
+#include "llvm/ADT/APSInt.h"
+
+namespace clang {
+class IdentifierInfo;
+class Expr;
+class Stmt;
+class FunctionDecl;
+
+
+/// Decl - This represents one declaration (or definition), e.g. a variable, 
+/// typedef, function, struct, etc.  
+///
+class Decl {
+public:
+  enum Kind {
+    // Concrete sub-classes of ValueDecl
+    Function, BlockVariable, FileVariable, ParmVariable, EnumConstant,
+    // Concrete sub-classes of TypeDecl
+    Typedef, Struct, Union, Class, Enum, 
+    // Concrete sub-class of Decl
+    Field
+  };
+
+  /// IdentifierNamespace - According to C99 6.2.3, there are four namespaces,
+  /// labels, tags, members and ordinary identifiers.
+  enum IdentifierNamespace {
+    IDNS_Label,
+    IDNS_Tag,
+    IDNS_Member,
+    IDNS_Ordinary
+  };
+private:
+  /// DeclKind - This indicates which class this is.
+  Kind DeclKind;
+  
+  /// Loc - The location that this decl.
+  SourceLocation Loc;
+  
+  /// Identifier - The identifier for this declaration (e.g. the name for the
+  /// variable, the tag for a struct).
+  IdentifierInfo *Identifier;
+  
+  /// When this decl is in scope while parsing, the Next field contains a
+  /// pointer to the shadowed decl of the same name.  When the scope is popped,
+  /// Decls are relinked onto a containing decl object.
+  ///
+  Decl *Next;
+
+  /// NextDeclarator - If this decl was part of a multi-declarator declaration,
+  /// such as "int X, Y, *Z;" this indicates Decl for the next declarator.
+  Decl *NextDeclarator;
+  
+protected:
+  Decl(Kind DK, SourceLocation L, IdentifierInfo *Id, Decl *NextDecl)
+    : DeclKind(DK), Loc(L), Identifier(Id), Next(0), NextDeclarator(NextDecl) {
+    if (Decl::CollectingStats()) addDeclKind(DK);
+  }
+  virtual ~Decl();
+  
+public:
+  IdentifierInfo *getIdentifier() const { return Identifier; }
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+  const char *getName() const;
+  
+  Kind getKind() const { return DeclKind; }
+  Decl *getNext() const { return Next; }
+  void setNext(Decl *N) { Next = N; }
+  
+  /// getNextDeclarator - If this decl was part of a multi-declarator
+  /// declaration, such as "int X, Y, *Z;" this returns the decl for the next
+  /// declarator.  Otherwise it returns null.
+  Decl *getNextDeclarator() { return NextDeclarator; }
+  const Decl *getNextDeclarator() const { return NextDeclarator; }
+  void setNextDeclarator(Decl *N) { NextDeclarator = N; }
+  
+  IdentifierNamespace getIdentifierNamespace() const {
+    switch (DeclKind) {
+    default: assert(0 && "Unknown decl kind!");
+    case Typedef:
+    case Function:
+    case BlockVariable:
+    case FileVariable:
+    case ParmVariable:
+    case EnumConstant:
+      return IDNS_Ordinary;
+    case Struct:
+    case Union:
+    case Class:
+    case Enum:
+      return IDNS_Tag;
+    }
+  }
+  // global temp stats (until we have a per-module visitor)
+  static void addDeclKind(const Kind k);
+  static bool CollectingStats(bool enable=false);
+  static void PrintStats();
+    
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *) { return true; }
+};
+
+/// ValueDecl - Represent the declaration of a variable (in which case it is 
+/// an lvalue) a function (in which case it is a function designator) or
+/// an enum constant. 
+class ValueDecl : public Decl {
+  QualType DeclType;
+protected:
+  ValueDecl(Kind DK, SourceLocation L, IdentifierInfo *Id, QualType T,
+            Decl *PrevDecl) : Decl(DK, L, Id, PrevDecl), DeclType(T) {}
+public:
+  QualType getType() const { return DeclType; }
+  void setType(QualType newType) { DeclType = newType; }
+  QualType getCanonicalType() const { return DeclType.getCanonicalType(); }
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) {
+    return D->getKind() >= Function && D->getKind() <= EnumConstant;
+  }
+  static bool classof(const ValueDecl *D) { return true; }
+};
+
+/// VarDecl - An instance of this class is created to represent a variable
+/// declaration or definition.
+class VarDecl : public ValueDecl {
+public:
+  enum StorageClass {
+    None, Extern, Static, Auto, Register
+  };
+  StorageClass getStorageClass() const { return SClass; }
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { 
+    return D->getKind() >= BlockVariable && D->getKind() <= ParmVariable; 
+  }
+  static bool classof(const VarDecl *D) { return true; }
+protected:
+  VarDecl(Kind DK, SourceLocation L, IdentifierInfo *Id, QualType T,
+          StorageClass SC, Decl *PrevDecl)
+    : ValueDecl(DK, L, Id, T, PrevDecl) { SClass = SC; }
+private:
+  StorageClass SClass;
+  // TODO: Initializer.
+};
+
+/// BlockVarDecl - Represent a local variable declaration.
+class BlockVarDecl : public VarDecl {
+public:
+  BlockVarDecl(SourceLocation L, IdentifierInfo *Id, QualType T, StorageClass S,
+               Decl *PrevDecl)
+    : VarDecl(BlockVariable, L, Id, T, S, PrevDecl) {}
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return D->getKind() == BlockVariable; }
+  static bool classof(const BlockVarDecl *D) { return true; }
+};
+
+/// FileVarDecl - Represent a file scoped variable declaration. This
+/// will allow us to reason about external variable declarations and tentative 
+/// definitions (C99 6.9.2p2) using our type system (without storing a
+/// pointer to the decl's scope, which is transient).
+class FileVarDecl : public VarDecl {
+public:
+  FileVarDecl(SourceLocation L, IdentifierInfo *Id, QualType T, StorageClass S,
+              Decl *PrevDecl)
+    : VarDecl(FileVariable, L, Id, T, S, PrevDecl) {}
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return D->getKind() == FileVariable; }
+  static bool classof(const FileVarDecl *D) { return true; }
+};
+
+/// ParmVarDecl - Represent a parameter to a function.
+class ParmVarDecl : public VarDecl {
+public:
+  ParmVarDecl(SourceLocation L, IdentifierInfo *Id, QualType T, StorageClass S,
+              Decl *PrevDecl)
+    : VarDecl(ParmVariable, L, Id, T, S, PrevDecl) {}
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return D->getKind() == ParmVariable; }
+  static bool classof(const ParmVarDecl *D) { return true; }
+};
+
+/// FunctionDecl - An instance of this class is created to represent a function
+/// declaration or definition.
+class FunctionDecl : public ValueDecl {
+public:
+  enum StorageClass {
+    None, Extern, Static
+  };
+  FunctionDecl(SourceLocation L, IdentifierInfo *Id, QualType T,
+               StorageClass S = None, Decl *PrevDecl)
+    : ValueDecl(Function, L, Id, T, PrevDecl), 
+      ParamInfo(0), Body(0), DeclChain(0), SClass(S) {}
+  virtual ~FunctionDecl();
+
+  Stmt *getBody() const { return Body; }
+  void setBody(Stmt *B) { Body = B; }
+  
+  Decl *getDeclChain() const { return DeclChain; }
+  void setDeclChain(Decl *D) { DeclChain = D; }
+
+  unsigned getNumParams() const;
+  const ParmVarDecl *getParamDecl(unsigned i) const {
+    assert(i < getNumParams() && "Illegal param #");
+    return ParamInfo[i];
+  }
+  ParmVarDecl *getParamDecl(unsigned i) {
+    assert(i < getNumParams() && "Illegal param #");
+    return ParamInfo[i];
+  }
+  void setParams(ParmVarDecl **NewParamInfo, unsigned NumParams);
+
+  QualType getResultType() const { 
+    return cast<FunctionType>(getType())->getResultType();
+  }
+  StorageClass getStorageClass() const { return SClass; }
+    
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return D->getKind() == Function; }
+  static bool classof(const FunctionDecl *D) { return true; }
+private:
+  /// ParamInfo - new[]'d array of pointers to VarDecls for the formal
+  /// parameters of this function.  This is null if a prototype or if there are
+  /// no formals.  TODO: we could allocate this space immediately after the
+  /// FunctionDecl object to save an allocation like FunctionType does.
+  ParmVarDecl **ParamInfo;
+  
+  Stmt *Body;  // Null if a prototype.
+  
+  /// DeclChain - Linked list of declarations that are defined inside this
+  /// function.
+  Decl *DeclChain;
+
+  StorageClass SClass;
+};
+
+
+/// FieldDecl - An instance of this class is created by Sema::ParseField to 
+/// represent a member of a struct/union/class.
+class FieldDecl : public Decl {
+  QualType DeclType;
+public:
+  FieldDecl(SourceLocation L, IdentifierInfo *Id, QualType T, Decl *PrevDecl)
+    : Decl(Field, L, Id, PrevDecl), DeclType(T) {}
+
+  QualType getType() const { return DeclType; }
+  QualType getCanonicalType() const { return DeclType.getCanonicalType(); }
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) {
+    return D->getKind() == Field;
+  }
+  static bool classof(const FieldDecl *D) { return true; }
+};
+
+/// EnumConstantDecl - An instance of this object exists for each enum constant
+/// that is defined.  For example, in "enum X {a,b}", each of a/b are
+/// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
+/// TagType for the X EnumDecl.
+class EnumConstantDecl : public ValueDecl {
+  Expr *Init; // an integer constant expression
+  llvm::APSInt Val; // The value.
+public:
+  EnumConstantDecl(SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E,
+                   const llvm::APSInt &V, Decl *PrevDecl)
+    : ValueDecl(EnumConstant, L, Id, T, PrevDecl), Init(E), Val(V) {}
+
+  const Expr *getInitExpr() const { return Init; }
+  Expr *getInitExpr() { return Init; }
+  const llvm::APSInt &getInitVal() const { return Val; }
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) {
+    return D->getKind() == EnumConstant;
+  }
+  static bool classof(const EnumConstantDecl *D) { return true; }
+};
+
+
+/// TypeDecl - Represents a declaration of a type.
+///
+class TypeDecl : public Decl {
+  /// TypeForDecl - This indicates the Type object that represents this
+  /// TypeDecl.  It is a cache maintained by ASTContext::getTypedefType and
+  /// ASTContext::getTagDeclType.
+  Type *TypeForDecl;
+  friend class ASTContext;
+protected:
+  TypeDecl(Kind DK, SourceLocation L, IdentifierInfo *Id, Decl *PrevDecl)
+    : Decl(DK, L, Id, PrevDecl), TypeForDecl(0) {}
+public:
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) {
+    return D->getKind() >= Typedef && D->getKind() <= Enum;
+  }
+  static bool classof(const TypeDecl *D) { return true; }
+};
+
+
+class TypedefDecl : public TypeDecl {
+  /// UnderlyingType - This is the type the typedef is set to.
+  QualType UnderlyingType;
+public:
+  TypedefDecl(SourceLocation L, IdentifierInfo *Id, QualType T, Decl *PrevDecl)
+    : TypeDecl(Typedef, L, Id, PrevDecl), UnderlyingType(T) {}
+  
+  QualType getUnderlyingType() const { return UnderlyingType; }
+  void setUnderlyingType(QualType newType) { UnderlyingType = newType; }
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return D->getKind() == Typedef; }
+  static bool classof(const TypedefDecl *D) { return true; }
+};
+
+
+/// TagDecl - Represents the declaration of a struct/union/class/enum.
+class TagDecl : public TypeDecl {
+  /// IsDefinition - True if this is a definition ("struct foo {};"), false if
+  /// it is a declaration ("struct foo;").
+  bool IsDefinition : 1;
+protected:
+  TagDecl(Kind DK, SourceLocation L, IdentifierInfo *Id, Decl *PrevDecl)
+    : TypeDecl(DK, L, Id, PrevDecl) {
+    IsDefinition = false;
+  }
+public:
+  
+  /// isDefinition - Return true if this decl has its body specified.
+  bool isDefinition() const {
+    return IsDefinition;
+  }
+  
+  const char *getKindName() const {
+    switch (getKind()) {
+    default: assert(0 && "Unknown TagDecl!");
+    case Struct: return "struct";
+    case Union:  return "union";
+    case Class:  return "class";
+    case Enum:   return "enum";
+    }
+  }
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) {
+    return D->getKind() == Struct || D->getKind() == Union ||
+           D->getKind() == Class || D->getKind() == Enum;
+  }
+  static bool classof(const TagDecl *D) { return true; }
+protected:
+  void setDefinition(bool V) { IsDefinition = V; }
+};
+
+/// EnumDecl - Represents an enum.  As an extension, we allow forward-declared
+/// enums.
+class EnumDecl : public TagDecl {
+  /// ElementList - this is a linked list of EnumConstantDecl's which are linked
+  /// together through their getNextDeclarator pointers.
+  EnumConstantDecl *ElementList;
+public:
+  EnumDecl(SourceLocation L, IdentifierInfo *Id, Decl *PrevDecl)
+    : TagDecl(Enum, L, Id, PrevDecl) {
+    ElementList = 0;
+  }
+  
+  /// defineElements - When created, EnumDecl correspond to a forward declared
+  /// enum.  This method is used to mark the decl as being defined, with the
+  /// specified list of enums.
+  void defineElements(EnumConstantDecl *ListHead) {
+    assert(!isDefinition() && "Cannot redefine enums!");
+    ElementList = ListHead;
+    setDefinition(true);
+  }
+  
+  static bool classof(const Decl *D) {
+    return D->getKind() == Enum;
+  }