| //===------- SemaTemplateInstantiate.cpp - C++ Template Instantiation ------===/ |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| //===----------------------------------------------------------------------===/ |
| // |
| // This file implements C++ template instantiation. |
| // |
| //===----------------------------------------------------------------------===/ |
| |
| #include "Sema.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/Expr.h" |
| #include "clang/AST/ExprCXX.h" |
| #include "clang/AST/DeclTemplate.h" |
| #include "clang/Parse/DeclSpec.h" |
| #include "clang/Basic/LangOptions.h" |
| |
| using namespace clang; |
| |
| //===----------------------------------------------------------------------===/ |
| // Template Instantiation for Types |
| //===----------------------------------------------------------------------===/ |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ExtQualType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ExtQualType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const BuiltinType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| assert(false && "BuiltinType is never dependent and cannot be instantiated"); |
| return QualType(T, CVR); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const FixedWidthIntType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate FixedWidthIntType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ComplexType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ComplexType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const PointerType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate PointerType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const BlockPointerType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate BlockPointerType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ReferenceType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ReferenceType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const MemberPointerType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate MemberPointerType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ConstantArrayType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ConstantArrayType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const IncompleteArrayType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate IncompleteArrayType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const VariableArrayType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate VariableArrayType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const DependentSizedArrayType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate DependentSizedArrayType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const VectorType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate VectorType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ExtVectorType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ExtVectorType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const FunctionProtoType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate FunctionProtoType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const FunctionNoProtoType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate FunctionNoProtoType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const TypedefType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate TypedefType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const TypeOfExprType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate TypeOfExprType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const TypeOfType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate TypeOfType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const RecordType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate RecordType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const CXXRecordType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate CXXRecordType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const EnumType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate EnumType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const TemplateTypeParmType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| if (T->getDepth() == 0) { |
| // Replace the template type parameter with its corresponding |
| // template argument. |
| assert(T->getIndex() < NumTemplateArgs && "Wrong # of template args"); |
| assert(TemplateArgs[T->getIndex()].getKind() == TemplateArgument::Type && |
| "Template argument kind mismatch"); |
| QualType Result = TemplateArgs[T->getIndex()].getAsType(); |
| if (Result.isNull() || !CVR) |
| return Result; |
| |
| // C++ [dcl.ref]p1: |
| // [...] Cv-qualified references are ill-formed except when |
| // the cv-qualifiers are introduced through the use of a |
| // typedef (7.1.3) or of a template type argument (14.3), in |
| // which case the cv-qualifiers are ignored. |
| if (CVR && Result->isReferenceType()) |
| CVR = 0; |
| |
| return QualType(Result.getTypePtr(), CVR | Result.getCVRQualifiers()); |
| } |
| |
| // The template type parameter comes from an inner template (e.g., |
| // the template parameter list of a member template inside the |
| // template we are instantiating). Create a new template type |
| // parameter with the template "level" reduced by one. |
| return SemaRef.Context.getTemplateTypeParmType(T->getDepth() - 1, |
| T->getIndex(), |
| T->getName()); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ClassTemplateSpecializationType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ClassTemplateSpecializationType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ObjCInterfaceType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ObjCInterfaceType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ObjCQualifiedInterfaceType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ObjCQualifiedInterfaceType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ObjCQualifiedIdType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ObjCQualifiedIdType yet"); |
| return QualType(); |
| } |
| |
| static QualType PerformTypeInstantiation(Sema &SemaRef, |
| const ObjCQualifiedClassType *T, |
| unsigned CVR, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, |
| DeclarationName Entity) { |
| // FIXME: Implement this |
| assert(false && "Cannot instantiate ObjCQualifiedClassType yet"); |
| return QualType(); |
| } |
| |
| |
| /// \brief Instantiate the type T with a given set of template arguments. |
| /// |
| /// This routine substitutes the given template arguments into the |
| /// type T and produces the instantiated type. |
| /// |
| /// \param T the type into which the template arguments will be |
| /// substituted. If this type is not dependent, it will be returned |
| /// immediately. |
| /// |
| /// \param TemplateArgs the template arguments that will be |
| /// substituted for the top-level template parameters within T. |
| /// |
| /// \param NumTemplateArgs the number of template arguments provided |
| /// by TemplateArgs. |
| /// |
| /// \param Loc the location in the source code where this substitution |
| /// is being performed. It will typically be the location of the |
| /// declarator (if we're instantiating the type of some declaration) |
| /// or the location of the type in the source code (if, e.g., we're |
| /// instantiating the type of a cast expression). |
| /// |
| /// \param Entity the name of the entity associated with a declaration |
| /// being instantiated (if any). May be empty to indicate that there |
| /// is no such entity (if, e.g., this is a type that occurs as part of |
| /// a cast expression) or that the entity has no name (e.g., an |
| /// unnamed function parameter). |
| /// |
| /// \returns If the instantiation succeeds, the instantiated |
| /// type. Otherwise, produces diagnostics and returns a NULL type. |
| QualType Sema::InstantiateType(QualType T, |
| const TemplateArgument *TemplateArgs, |
| unsigned NumTemplateArgs, |
| SourceLocation Loc, DeclarationName Entity) { |
| // If T is not a dependent type, there is nothing to do. |
| if (!T->isDependentType()) |
| return T; |
| |
| switch (T->getTypeClass()) { |
| #define TYPE(Class, Base) \ |
| case Type::Class: \ |
| return PerformTypeInstantiation(*this, \ |
| cast<Class##Type>(T.getTypePtr()), \ |
| T.getCVRQualifiers(), TemplateArgs, \ |
| NumTemplateArgs, Loc, Entity); |
| #define ABSTRACT_TYPE(Class, Base) |
| #include "clang/AST/TypeNodes.def" |
| } |
| |
| assert(false && "Not all types have been decoded for instantiation"); |
| return QualType(); |
| } |