vendor/clang/clang-r74383

8 files changed, 220 insertions, 39 deletions

diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
index b686b0edd30a..aa01b7fdf06f 100644
--- a/include/clang/AST/ASTContext.h
+++ b/include/clang/AST/ASTContext.h
@@ -192,6 +192,7 @@ public:
   QualType VoidPtrTy, NullPtrTy;
   QualType OverloadTy;
   QualType DependentTy;
+  QualType UndeducedAutoTy;
 
   ASTContext(const LangOptions& LOpts, SourceManager &SM, TargetInfo &t,
              IdentifierTable &idents, SelectorTable &sels,
@@ -360,6 +361,9 @@ public:
   QualType getTypeOfExprType(Expr *e);
   QualType getTypeOfType(QualType t);
   
+  /// getDecltypeType - C++0x decltype.
+  QualType getDecltypeType(Expr *e);
+  
   /// getTagDeclType - Return the unique reference to the type for the
   /// specified TagDecl (struct/union/class/enum) decl.
   QualType getTagDeclType(TagDecl *Decl);
diff --git a/include/clang/AST/Attr.h b/include/clang/AST/Attr.h
index a5b7ad4ca382..7d3009b01129 100644
--- a/include/clang/AST/Attr.h
+++ b/include/clang/AST/Attr.h
@@ -72,6 +72,7 @@ public:
     Packed,
     Pure,
     Regparm,
+    ReqdWorkGroupSize,   // OpenCL-specific
     Section,
     Sentinel,
     StdCall,
@@ -501,6 +502,27 @@ public:
   static bool classof(const RegparmAttr *A) { return true; }
 };
 
+class ReqdWorkGroupSizeAttr : public Attr {
+  unsigned X, Y, Z;
+public:
+  ReqdWorkGroupSizeAttr(unsigned X, unsigned Y, unsigned Z)
+  : Attr(ReqdWorkGroupSize), X(X), Y(Y), Z(Z) {}
+
+  unsigned getXDim() const { return X; }
+  unsigned getYDim() const { return Y; }
+  unsigned getZDim() const { return Z; }
+
+  virtual Attr *clone(ASTContext &C) const { 
+    return ::new (C) ReqdWorkGroupSizeAttr(X, Y, Z); 
+  }
+  
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Attr *A) {
+    return A->getKind() == ReqdWorkGroupSize;
+  }
+  static bool classof(const ReqdWorkGroupSizeAttr *A) { return true; }
+};
+  
 // Checker-specific attributes.
 DEF_SIMPLE_ATTR(CFReturnsRetained);
 DEF_SIMPLE_ATTR(NSReturnsRetained);
diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
index f594db27bc8f..3de01f3baeb5 100644
--- a/include/clang/AST/Decl.h
+++ b/include/clang/AST/Decl.h
@@ -25,7 +25,8 @@ class FunctionTemplateDecl;
 class Stmt;
 class CompoundStmt;
 class StringLiteral;
-
+class TemplateArgumentList;
+  
 /// TranslationUnitDecl - The top declaration context.
 class TranslationUnitDecl : public Decl, public DeclContext {
   TranslationUnitDecl()
@@ -105,6 +106,13 @@ public:
   /// \brief Determine whether this declaration has linkage.
   bool hasLinkage() const;
 
+  /// \brief Looks through UsingDecls and ObjCCompatibleAliasDecls for
+  /// the underlying named decl.
+  NamedDecl *getUnderlyingDecl();
+  const NamedDecl *getUnderlyingDecl() const {
+    return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
+  }
+  
   static bool classof(const Decl *D) {
     return D->getKind() >= NamedFirst && D->getKind() <= NamedLast;
   }
@@ -614,10 +622,17 @@ public:
     None, Extern, Static, PrivateExtern
   };
 private:
+  /// \brief Provides information about a function template specialization, 
+  /// which is a FunctionDecl that has been explicitly specialization or
+  /// instantiated from a function template.
+  struct TemplateSpecializationInfo {
+    FunctionTemplateDecl *Template;
+    const TemplateArgumentList *TemplateArguments;
+  };
+  
   /// 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.
+  /// no formals.
   ParmVarDecl **ParamInfo;
   
   LazyDeclStmtPtr Body;
@@ -664,8 +679,12 @@ private:
   /// pointer to a FunctionTemplateDecl. For member functions
   /// of class template specializations, this will be the
   /// FunctionDecl from which the member function was instantiated.
-  llvm::PointerUnion<FunctionTemplateDecl*, FunctionDecl*>
-    TemplateOrInstantiation;
+  /// For function template specializations, this will be a 
+  /// FunctionTemplateSpecializationInfo, which contains information about
+  /// the template being specialized and the template arguments involved in 
+  /// that specialization.
+  llvm::PointerUnion3<FunctionTemplateDecl*, FunctionDecl*,
+                      TemplateSpecializationInfo*> TemplateOrSpecialization;
 
 protected:
   FunctionDecl(Kind DK, DeclContext *DC, SourceLocation L,
@@ -678,7 +697,7 @@ protected:
       SClass(S), IsInline(isInline), C99InlineDefinition(false), 
       IsVirtualAsWritten(false), IsPure(false), HasInheritedPrototype(false), 
       HasWrittenPrototype(true), IsDeleted(false), TypeSpecStartLoc(TSSL),
-      EndRangeLoc(L), TemplateOrInstantiation() {}
+      EndRangeLoc(L), TemplateOrSpecialization() {}
 
   virtual ~FunctionDecl() {}
   virtual void Destroy(ASTContext& C);
@@ -887,13 +906,13 @@ public:
   /// X<int>::A is required, it will be instantiated from the
   /// declaration returned by getInstantiatedFromMemberFunction().
   FunctionDecl *getInstantiatedFromMemberFunction() const {
-    return TemplateOrInstantiation.dyn_cast<FunctionDecl*>();
+    return TemplateOrSpecialization.dyn_cast<FunctionDecl*>();
   }
 
   /// \brief Specify that this record is an instantiation of the
   /// member function RD.
   void setInstantiationOfMemberFunction(FunctionDecl *RD) { 
-    TemplateOrInstantiation = RD;
+    TemplateOrSpecialization = RD;
   }
 
   /// \brief Retrieves the function template that is described by this
@@ -909,13 +928,54 @@ public:
   /// getDescribedFunctionTemplate() retrieves the
   /// FunctionTemplateDecl from a FunctionDecl.
   FunctionTemplateDecl *getDescribedFunctionTemplate() const {
-    return TemplateOrInstantiation.dyn_cast<FunctionTemplateDecl*>();
+    return TemplateOrSpecialization.dyn_cast<FunctionTemplateDecl*>();
   }
 
   void setDescribedFunctionTemplate(FunctionTemplateDecl *Template) {
-    TemplateOrInstantiation = Template;
+    TemplateOrSpecialization = Template;
   }
 
+  /// \brief Retrieve the primary template that this function template
+  /// specialization either specializes or was instantiated from.
+  ///
+  /// If this function declaration is not a function template specialization,
+  /// returns NULL.
+  FunctionTemplateDecl *getPrimaryTemplate() const {
+    if (TemplateSpecializationInfo *Info 
+          = TemplateOrSpecialization.dyn_cast<TemplateSpecializationInfo*>()) {
+      return Info->Template;
+    }
+    return 0;
+  }
+  
+  /// \brief Retrieve the template arguments used to produce this function
+  /// template specialization from the primary template.
+  ///
+  /// If this function declaration is not a function template specialization,
+  /// returns NULL.
+  const TemplateArgumentList *getTemplateSpecializationArgs() const {
+    if (TemplateSpecializationInfo *Info 
+          = TemplateOrSpecialization.dyn_cast<TemplateSpecializationInfo*>()) {
+      return Info->TemplateArguments;
+    }
+    return 0;
+  }
+  
+  
+  /// \brief Specify that this function declaration is actually a function
+  /// template specialization.
+  ///
+  /// \param Context the AST context in which this function resides.
+  ///
+  /// \param Template the function template that this function template
+  /// specialization specializes.
+  ///
+  /// \param TemplateArgs the template arguments that produced this
+  /// function template specialization from the template.
+  void setFunctionTemplateSpecialization(ASTContext &Context,
+                                         FunctionTemplateDecl *Template,
+                                      const TemplateArgumentList *TemplateArgs);
+  
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= FunctionFirst && D->getKind() <= FunctionLast;
diff --git a/include/clang/AST/DeclBase.h b/include/clang/AST/DeclBase.h
index a75eecd02220..c959b05473fe 100644
--- a/include/clang/AST/DeclBase.h
+++ b/include/clang/AST/DeclBase.h
@@ -329,6 +329,9 @@ public:
   /// template parameter pack.
   bool isTemplateParameterPack() const;
 
+  /// \brief Whether this declaration is a function or function template.
+  bool isFunctionOrFunctionTemplate() const;
+  
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *) { return true; }
   static DeclContext *castToDeclContext(const Decl *);
diff --git a/include/clang/AST/DeclCXX.h b/include/clang/AST/DeclCXX.h
index 52ed0ec8535e..a2fe24e83105 100644
--- a/include/clang/AST/DeclCXX.h
+++ b/include/clang/AST/DeclCXX.h
@@ -27,6 +27,40 @@ class CXXConversionDecl;
 class CXXMethodDecl;
 class ClassTemplateSpecializationDecl;
 
+/// \brief Represents any kind of function declaration, whether it is a 
+/// concrete function or a function template.
+class AnyFunctionDecl {
+  NamedDecl *Function;
+  
+public:
+  AnyFunctionDecl(FunctionDecl *FD) : Function(FD) { }
+  AnyFunctionDecl(FunctionTemplateDecl *FTD);
+  
+  /// \brief Implicily converts any function or function template into a 
+  /// named declaration.
+  operator NamedDecl *() const { return Function; }
+  
+  /// \brief Retrieve the underlying function or function template.
+  NamedDecl *get() const { return Function; }
+};
+  
+} // end namespace clang
+
+namespace llvm {
+  /// Implement simplify_type for AnyFunctionDecl, so that we can dyn_cast from 
+  /// AnyFunctionDecl to any function or function template declaration.
+  template<> struct simplify_type<const ::clang::AnyFunctionDecl> {
+    typedef ::clang::NamedDecl* SimpleType;
+    static SimpleType getSimplifiedValue(const ::clang::AnyFunctionDecl &Val) {
+      return Val;
+    }
+  };
+  template<> struct simplify_type< ::clang::AnyFunctionDecl>
+  : public simplify_type<const ::clang::AnyFunctionDecl> {};
+} // end namespace llvm
+
+namespace clang {
+  
 /// OverloadedFunctionDecl - An instance of this class represents a
 /// set of overloaded functions. All of the functions have the same
 /// name and occur within the same scope.
@@ -43,15 +77,15 @@ protected:
 
   /// Functions - the set of overloaded functions contained in this
   /// overload set.
-  llvm::SmallVector<FunctionDecl *, 4> Functions;
+  llvm::SmallVector<AnyFunctionDecl, 4> Functions;
 
   // FIXME: This should go away when we stop using
   // OverloadedFunctionDecl to store conversions in CXXRecordDecl.
   friend class CXXRecordDecl;
 
 public:
-  typedef llvm::SmallVector<FunctionDecl *, 4>::iterator function_iterator;
-  typedef llvm::SmallVector<FunctionDecl *, 4>::const_iterator
+  typedef llvm::SmallVector<AnyFunctionDecl, 4>::iterator function_iterator;
+  typedef llvm::SmallVector<AnyFunctionDecl, 4>::const_iterator
     function_const_iterator;
 
   static OverloadedFunctionDecl *Create(ASTContext &C, DeclContext *DC,
@@ -71,30 +105,18 @@ public:
       this->setLocation(FD->getLocation());
   }
 
+  /// addOverload - Add an overloaded function template FTD to this set of
+  /// overloaded functions.
+  void addOverload(FunctionTemplateDecl *FTD);
+  
   function_iterator function_begin() { return Functions.begin(); }
   function_iterator function_end() { return Functions.end(); }
   function_const_iterator function_begin() const { return Functions.begin(); }
   function_const_iterator function_end() const { return Functions.end(); }
 
-  /// getNumFunctions - the number of overloaded functions stored in
+  /// \brief Returns the number of overloaded functions stored in
   /// this set.
-  unsigned getNumFunctions() const { return Functions.size(); }
-
-  /// getFunction - retrieve the ith function in the overload set.
-  const FunctionDecl *getFunction(unsigned i) const {
-    assert(i < getNumFunctions() && "Illegal function #");
-    return Functions[i];
-  }
-  FunctionDecl *getFunction(unsigned i) {
-    assert(i < getNumFunctions() && "Illegal function #");
-    return Functions[i];
-  }
-
-  // getDeclContext - Get the context of these overloaded functions.
-  DeclContext *getDeclContext() {
-    assert(getNumFunctions() > 0 && "Context of an empty overload set");
-    return getFunction(0)->getDeclContext();
-  }
+  unsigned size() const { return Functions.size(); }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { 
@@ -449,6 +471,15 @@ public:
   /// getDestructor - Returns the destructor decl for this class.
   const CXXDestructorDecl *getDestructor(ASTContext &Context);
   
+  /// isLocalClass - If the class is a local class [class.local], returns
+  /// the enclosing function declaration.
+  const FunctionDecl *isLocalClass() const {
+    if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(getDeclContext()))
+      return RD->isLocalClass();
+    
+    return dyn_cast<FunctionDecl>(getDeclContext());
+  }
+  
   /// viewInheritance - Renders and displays an inheritance diagram
   /// for this C++ class and all of its base classes (transitively) using
   /// GraphViz.
@@ -1070,17 +1101,25 @@ class UsingDecl : public NamedDecl {
 public:
   /// \brief Returns the source range that covers the nested-name-specifier
   /// preceding the namespace name.
-  SourceRange getNestedNameRange() { return(NestedNameRange); }
+  SourceRange getNestedNameRange() { return NestedNameRange; }
+  
   /// \brief Returns the source location of the target declaration name.
-  SourceLocation getTargetNameLocation() { return(TargetNameLocation); }
+  SourceLocation getTargetNameLocation() { return TargetNameLocation; }
+  
   /// \brief Returns the source location of the "using" location itself.
-  SourceLocation getUsingLocation() { return(UsingLocation); }
+  SourceLocation getUsingLocation() { return UsingLocation; }
+  
   /// \brief getTargetDecl - Returns target specified by using-decl.
-  NamedDecl *getTargetDecl() { return(TargetDecl); }
+  NamedDecl *getTargetDecl() { return TargetDecl; }
+  const NamedDecl *getTargetDecl() const { return TargetDecl; }
+  
   /// \brief Get target nested name declaration.
-  NestedNameSpecifier* getTargetNestedNameDecl() { return(TargetNestedNameDecl); }
+  NestedNameSpecifier* getTargetNestedNameDecl() { 
+    return TargetNestedNameDecl; 
+  }
+  
   /// isTypeName - Return true if using decl had 'typename'.
-  bool isTypeName() const { return(IsTypeName); }
+  bool isTypeName() const { return IsTypeName; }
 
   static UsingDecl *Create(ASTContext &C, DeclContext *DC,
       SourceLocation L, SourceRange NNR, SourceLocation TargetNL,
diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h
index 2608dd9d3157..aad19a63ef0f 100644
--- a/include/clang/AST/DeclTemplate.h
+++ b/include/clang/AST/DeclTemplate.h
@@ -153,7 +153,7 @@ protected:
   NamedDecl *TemplatedDecl;
   TemplateParameterList* TemplateParams;
 };
-
+ 
 /// Declaration of a template function.
 class FunctionTemplateDecl : public TemplateDecl {
 protected:
@@ -580,6 +580,30 @@ public:
     return reinterpret_cast<Expr *>(TypeOrValue);
   }
 
+  /// \brief Iterator that traverses the elements of a template argument pack.
+  typedef const TemplateArgument * pack_iterator;
+  
+  /// \brief Iterator referencing the first argument of a template argument 
+  /// pack.
+  pack_iterator pack_begin() const {
+    assert(Kind == Pack);
+    return Args.Args;
+  }
+
+  /// \brief Iterator referencing one past the last argument of a template
+  /// argument pack.
+  pack_iterator pack_end() const {
+    assert(Kind == Pack);
+    return Args.Args + Args.NumArgs;
+  }
+  
+  /// \brief The number of template arguments in the given template argument
+  /// pack.
+  unsigned pack_size() const {
+    assert(Kind == Pack);
+    return Args.NumArgs;
+  }
+  
   /// \brief Retrieve the location where the template argument starts.
   SourceLocation getLocation() const { return StartLoc; }
 
@@ -957,6 +981,10 @@ public:
   virtual void Destroy(ASTContext& C);
 };
 
+/// Implementation of inline functions that require the template declarations
+inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD) 
+  : Function(FTD) { }
+
 } /* end of namespace clang */
 
 #endif
diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index ca55ea670b24..321b1f204fcf 100644
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -572,7 +572,10 @@ public:
     NullPtr,  // This is the type of C++0x 'nullptr'.
 
     Overload,  // This represents the type of an overloaded function declaration.
-    Dependent  // This represents the type of a type-dependent expression.
+    Dependent, // This represents the type of a type-dependent expression.
+    
+    UndeducedAuto  // In C++0x, this represents the type of an auto variable
+                   // that has not been deduced yet.
   };
 private:
   Kind TypeKind;
@@ -1103,11 +1106,17 @@ public:
       case '7': return 7;
       case '8': return 8;
       case '9': return 9;
+      case 'A':
       case 'a': return 10;
+      case 'B':
       case 'b': return 11;
+      case 'C':
       case 'c': return 12;
+      case 'D':
       case 'd': return 13;
+      case 'E':
       case 'e': return 14;
+      case 'F':
       case 'f': return 15;
     }
   }
@@ -1358,6 +1367,21 @@ public:
   static bool classof(const TypeOfType *) { return true; }
 };
 
+/// DecltypeType (C++0x)
+class DecltypeType : public Type {
+  Expr *E;
+  DecltypeType(Expr *E, QualType can);
+  friend class ASTContext;  // ASTContext creates these.
+public:
+  Expr *getUnderlyingExpr() const { return E; }
+  
+  virtual void getAsStringInternal(std::string &InnerString, 
+                                   const PrintingPolicy &Policy) const;
+  
+  static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
+  static bool classof(const DecltypeType *) { return true; }
+};
+  
 class TagType : public Type {
   /// Stores the TagDecl associated with this type. The decl will
   /// point to the TagDecl that actually defines the entity (or is a
diff --git a/include/clang/AST/TypeNodes.def b/include/clang/AST/TypeNodes.def
index 5555a9b0ae7e..64a09d800270 100644
--- a/include/clang/AST/TypeNodes.def
+++ b/include/clang/AST/TypeNodes.def
@@ -69,6 +69,7 @@ TYPE(FunctionNoProto, FunctionType)
 NON_CANONICAL_TYPE(Typedef, Type)
 NON_CANONICAL_TYPE(TypeOfExpr, Type)
 NON_CANONICAL_TYPE(TypeOf, Type)
+NON_CANONICAL_TYPE(Decltype, Type)
 ABSTRACT_TYPE(Tag, Type)
 TYPE(Record, TagType)
 TYPE(Enum, TagType)