forked from OSchip/llvm-project
Initial skeleton of an AST "importer", which will take AST elements from
one context and import them into another context, merging them according to language-specific rules. This is a skeleton. It doesn't work, it isn't testable, but I want it in version control. llvm-svn: 95395
This commit is contained in:
Douglas Gregor
parent
e4e604b5d6
commit
96e578d29d
|
|
@ -0,0 +1,140 @@
|
|||
//===--- ASTImporter.h - Importing ASTs from other Contexts -----*- 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 ASTImporter class which imports AST nodes from one
|
||||
// context into another context.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
#ifndef LLVM_CLANG_AST_ASTIM PORTER_H
|
||||
#define LLVM_CLANG_AST_ASTIMPORTER_H
|
||||
|
||||
#include "clang/AST/Type.h"
|
||||
#include "clang/AST/DeclarationName.h"
|
||||
#include "clang/Basic/SourceLocation.h"
|
||||
|
||||
namespace clang {
|
||||
class ASTContext;
|
||||
class Decl;
|
||||
class DeclContext;
|
||||
class Diagnostic;
|
||||
class Expr;
|
||||
class IdentifierInfo;
|
||||
class NestedNameSpecifier;
|
||||
class Stmt;
|
||||
class TypeSourceInfo;
|
||||
|
||||
/// \brief Imports selected nodes from one AST context into another context,
|
||||
/// merging AST nodes where appropriate.
|
||||
class ASTImporter {
|
||||
/// \brief The contexts we're importing to and from.
|
||||
ASTContext &ToContext, &FromContext;
|
||||
|
||||
/// \brief The diagnostics object that we should use to emit diagnostics
|
||||
/// within the context we're importing to and from.
|
||||
Diagnostic &ToDiags, &FromDiags;
|
||||
|
||||
public:
|
||||
ASTImporter(ASTContext &ToContext, Diagnostic &ToDiags,
|
||||
ASTContext &FromContext, Diagnostic &FromDiags);
|
||||
|
||||
~ASTImporter();
|
||||
|
||||
/// \brief Import the given type from the "from" context into the "to"
|
||||
/// context.
|
||||
///
|
||||
/// \returns the equivalent type in the "to" context, or a NULL type if
|
||||
/// an error occurred.
|
||||
QualType Import(QualType FromT);
|
||||
|
||||
/// \brief Import the given type source information from the
|
||||
/// "from" context into the "to" context.
|
||||
///
|
||||
/// \returns the equivalent type source information in the "to"
|
||||
/// context, or NULL if an error occurred.
|
||||
TypeSourceInfo *Import(TypeSourceInfo *FromTSI);
|
||||
|
||||
/// \brief Import the given declaration from the "from" context into the
|
||||
/// "to" context.
|
||||
///
|
||||
/// \returns the equivalent declaration in the "to" context, or a NULL type
|
||||
/// if an error occurred.
|
||||
Decl *Import(Decl *FromD);
|
||||
|
||||
/// \brief Import the given declaration context from the "from"
|
||||
/// AST context into the "to" AST context.
|
||||
///
|
||||
/// \returns the equivalent declaration context in the "to"
|
||||
/// context, or a NULL type if an error occurred.
|
||||
DeclContext *ImportContext(DeclContext *FromDC);
|
||||
|
||||
/// \brief Import the given expression from the "from" context into the
|
||||
/// "to" context.
|
||||
///
|
||||
/// \returns the equivalent expression in the "to" context, or NULL if
|
||||
/// an error occurred.
|
||||
Expr *Import(Expr *FromE);
|
||||
|
||||
/// \brief Import the given statement from the "from" context into the
|
||||
/// "to" context.
|
||||
///
|
||||
/// \returns the equivalent statement in the "to" context, or NULL if
|
||||
/// an error occurred.
|
||||
Stmt *Import(Stmt *FromS);
|
||||
|
||||
/// \brief Import the given nested-name-specifier from the "from"
|
||||
/// context into the "to" context.
|
||||
///
|
||||
/// \returns the equivalent nested-name-specifier in the "to"
|
||||
/// context, or NULL if an error occurred.
|
||||
NestedNameSpecifier *Import(NestedNameSpecifier *FromNNS);
|
||||
|
||||
/// \brief Import the given source location from the "from" context into
|
||||
/// the "to" context.
|
||||
///
|
||||
/// \returns the equivalent source location in the "to" context, or an
|
||||
/// invalid source location if an error occurred.
|
||||
SourceLocation Import(SourceLocation FromLoc);
|
||||
|
||||
/// \brief Import the given source range from the "from" context into
|
||||
/// the "to" context.
|
||||
///
|
||||
/// \returns the equivalent source range in the "to" context, or an
|
||||
/// invalid source location if an error occurred.
|
||||
SourceRange Import(SourceRange FromRange);
|
||||
|
||||
/// \brief Import the given declaration name from the "from"
|
||||
/// context into the "to" context.
|
||||
///
|
||||
/// \returns the equivalent declaration name in the "to" context,
|
||||
/// or an empty declaration name if an error occurred.
|
||||
DeclarationName Import(DeclarationName FromName);
|
||||
|
||||
/// \brief Import the given identifier from the "from" context
|
||||
/// into the "to" context.
|
||||
///
|
||||
/// \returns the equivalent identifier in the "to" context.
|
||||
IdentifierInfo *Import(IdentifierInfo *FromId);
|
||||
|
||||
/// \brief Retrieve the context that AST nodes are being imported into.
|
||||
ASTContext &getToContext() const { return ToContext; }
|
||||
|
||||
/// \brief Retrieve the context that AST nodes are being imported from.
|
||||
ASTContext &getFromContext() const { return FromContext; }
|
||||
|
||||
/// \brief Retrieve the diagnostics object to use to report errors within
|
||||
/// the context we're importing into.
|
||||
Diagnostic &getToDiags() const { return ToDiags; }
|
||||
|
||||
/// \brief Retrieve the diagnostics object to use to report errors within
|
||||
/// the context we're importing from.
|
||||
Diagnostic &getFromDiags() const { return FromDiags; }
|
||||
};
|
||||
}
|
||||
|
||||
#endif // LLVM_CLANG_AST_ASTIMPORTER_H
|
||||
|
|
@ -0,0 +1,509 @@
|
|||
//===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- 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 ASTImporter class which imports AST nodes from one
|
||||
// context into another context.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
#include "clang/AST/ASTImporter.h"
|
||||
|
||||
#include "clang/AST/ASTContext.h"
|
||||
#include "clang/AST/DeclObjC.h"
|
||||
#include "clang/AST/TypeVisitor.h"
|
||||
|
||||
using namespace clang;
|
||||
|
||||
namespace {
|
||||
class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType> {
|
||||
ASTImporter &Importer;
|
||||
|
||||
public:
|
||||
explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
|
||||
|
||||
using TypeVisitor<ASTNodeImporter, QualType>::Visit;
|
||||
|
||||
// Importing types
|
||||
QualType VisitBuiltinType(BuiltinType *T);
|
||||
QualType VisitComplexType(ComplexType *T);
|
||||
QualType VisitPointerType(PointerType *T);
|
||||
QualType VisitBlockPointerType(BlockPointerType *T);
|
||||
QualType VisitLValueReferenceType(LValueReferenceType *T);
|
||||
QualType VisitRValueReferenceType(RValueReferenceType *T);
|
||||
QualType VisitMemberPointerType(MemberPointerType *T);
|
||||
QualType VisitConstantArrayType(ConstantArrayType *T);
|
||||
QualType VisitIncompleteArrayType(IncompleteArrayType *T);
|
||||
QualType VisitVariableArrayType(VariableArrayType *T);
|
||||
// FIXME: DependentSizedArrayType
|
||||
// FIXME: DependentSizedExtVectorType
|
||||
QualType VisitVectorType(VectorType *T);
|
||||
QualType VisitExtVectorType(ExtVectorType *T);
|
||||
QualType VisitFunctionNoProtoType(FunctionNoProtoType *T);
|
||||
QualType VisitFunctionProtoType(FunctionProtoType *T);
|
||||
// FIXME: UnresolvedUsingType
|
||||
QualType VisitTypedefType(TypedefType *T);
|
||||
QualType VisitTypeOfExprType(TypeOfExprType *T);
|
||||
// FIXME: DependentTypeOfExprType
|
||||
QualType VisitTypeOfType(TypeOfType *T);
|
||||
QualType VisitDecltypeType(DecltypeType *T);
|
||||
// FIXME: DependentDecltypeType
|
||||
QualType VisitRecordType(RecordType *T);
|
||||
QualType VisitEnumType(EnumType *T);
|
||||
QualType VisitElaboratedType(ElaboratedType *T);
|
||||
// FIXME: TemplateTypeParmType
|
||||
// FIXME: SubstTemplateTypeParmType
|
||||
// FIXME: TemplateSpecializationType
|
||||
QualType VisitQualifiedNameType(QualifiedNameType *T);
|
||||
// FIXME: TypenameType
|
||||
QualType VisitObjCInterfaceType(ObjCInterfaceType *T);
|
||||
QualType VisitObjCObjectPointerType(ObjCObjectPointerType *T);
|
||||
};
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Import Types
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
QualType ASTNodeImporter::VisitBuiltinType(BuiltinType *T) {
|
||||
switch (T->getKind()) {
|
||||
case BuiltinType::Void: return Importer.getToContext().VoidTy;
|
||||
case BuiltinType::Bool: return Importer.getToContext().BoolTy;
|
||||
|
||||
case BuiltinType::Char_U:
|
||||
// The context we're importing from has an unsigned 'char'. If we're
|
||||
// importing into a context with a signed 'char', translate to
|
||||
// 'unsigned char' instead.
|
||||
if (Importer.getToContext().getLangOptions().CharIsSigned)
|
||||
return Importer.getToContext().UnsignedCharTy;
|
||||
|
||||
return Importer.getToContext().CharTy;
|
||||
|
||||
case BuiltinType::UChar: return Importer.getToContext().UnsignedCharTy;
|
||||
|
||||
case BuiltinType::Char16:
|
||||
// FIXME: Make sure that the "to" context supports C++!
|
||||
return Importer.getToContext().Char16Ty;
|
||||
|
||||
case BuiltinType::Char32:
|
||||
// FIXME: Make sure that the "to" context supports C++!
|
||||
return Importer.getToContext().Char32Ty;
|
||||
|
||||
case BuiltinType::UShort: return Importer.getToContext().UnsignedShortTy;
|
||||
case BuiltinType::UInt: return Importer.getToContext().UnsignedIntTy;
|
||||
case BuiltinType::ULong: return Importer.getToContext().UnsignedLongTy;
|
||||
case BuiltinType::ULongLong:
|
||||
return Importer.getToContext().UnsignedLongLongTy;
|
||||
case BuiltinType::UInt128: return Importer.getToContext().UnsignedInt128Ty;
|
||||
|
||||
case BuiltinType::Char_S:
|
||||
// The context we're importing from has an unsigned 'char'. If we're
|
||||
// importing into a context with a signed 'char', translate to
|
||||
// 'unsigned char' instead.
|
||||
if (!Importer.getToContext().getLangOptions().CharIsSigned)
|
||||
return Importer.getToContext().SignedCharTy;
|
||||
|
||||
return Importer.getToContext().CharTy;
|
||||
|
||||
case BuiltinType::SChar: return Importer.getToContext().SignedCharTy;
|
||||
case BuiltinType::WChar:
|
||||
// FIXME: If not in C++, shall we translate to the C equivalent of
|
||||
// wchar_t?
|
||||
return Importer.getToContext().WCharTy;
|
||||
|
||||
case BuiltinType::Short : return Importer.getToContext().ShortTy;
|
||||
case BuiltinType::Int : return Importer.getToContext().IntTy;
|
||||
case BuiltinType::Long : return Importer.getToContext().LongTy;
|
||||
case BuiltinType::LongLong : return Importer.getToContext().LongLongTy;
|
||||
case BuiltinType::Int128 : return Importer.getToContext().Int128Ty;
|
||||
case BuiltinType::Float: return Importer.getToContext().FloatTy;
|
||||
case BuiltinType::Double: return Importer.getToContext().DoubleTy;
|
||||
case BuiltinType::LongDouble: return Importer.getToContext().LongDoubleTy;
|
||||
|
||||
case BuiltinType::NullPtr:
|
||||
// FIXME: Make sure that the "to" context supports C++0x!
|
||||
return Importer.getToContext().NullPtrTy;
|
||||
|
||||
case BuiltinType::Overload: return Importer.getToContext().OverloadTy;
|
||||
case BuiltinType::Dependent: return Importer.getToContext().DependentTy;
|
||||
case BuiltinType::UndeducedAuto:
|
||||
// FIXME: Make sure that the "to" context supports C++0x!
|
||||
return Importer.getToContext().UndeducedAutoTy;
|
||||
|
||||
case BuiltinType::ObjCId:
|
||||
// FIXME: Make sure that the "to" context supports Objective-C!
|
||||
return Importer.getToContext().ObjCBuiltinIdTy;
|
||||
|
||||
case BuiltinType::ObjCClass:
|
||||
return Importer.getToContext().ObjCBuiltinClassTy;
|
||||
|
||||
case BuiltinType::ObjCSel:
|
||||
return Importer.getToContext().ObjCBuiltinSelTy;
|
||||
}
|
||||
|
||||
return QualType();
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitComplexType(ComplexType *T) {
|
||||
QualType ToElementType = Importer.Import(T->getElementType());
|
||||
if (ToElementType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getComplexType(ToElementType);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitPointerType(PointerType *T) {
|
||||
QualType ToPointeeType = Importer.Import(T->getPointeeType());
|
||||
if (ToPointeeType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getPointerType(ToPointeeType);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitBlockPointerType(BlockPointerType *T) {
|
||||
// FIXME: Check for blocks support in "to" context.
|
||||
QualType ToPointeeType = Importer.Import(T->getPointeeType());
|
||||
if (ToPointeeType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getBlockPointerType(ToPointeeType);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitLValueReferenceType(LValueReferenceType *T) {
|
||||
// FIXME: Check for C++ support in "to" context.
|
||||
QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
|
||||
if (ToPointeeType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getLValueReferenceType(ToPointeeType);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitRValueReferenceType(RValueReferenceType *T) {
|
||||
// FIXME: Check for C++0x support in "to" context.
|
||||
QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
|
||||
if (ToPointeeType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getRValueReferenceType(ToPointeeType);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitMemberPointerType(MemberPointerType *T) {
|
||||
// FIXME: Check for C++ support in "to" context.
|
||||
QualType ToPointeeType = Importer.Import(T->getPointeeType());
|
||||
if (ToPointeeType.isNull())
|
||||
return QualType();
|
||||
|
||||
QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
|
||||
return Importer.getToContext().getMemberPointerType(ToPointeeType,
|
||||
ClassType.getTypePtr());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitConstantArrayType(ConstantArrayType *T) {
|
||||
QualType ToElementType = Importer.Import(T->getElementType());
|
||||
if (ToElementType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getConstantArrayType(ToElementType,
|
||||
T->getSize(),
|
||||
T->getSizeModifier(),
|
||||
T->getIndexTypeCVRQualifiers());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitIncompleteArrayType(IncompleteArrayType *T) {
|
||||
QualType ToElementType = Importer.Import(T->getElementType());
|
||||
if (ToElementType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getIncompleteArrayType(ToElementType,
|
||||
T->getSizeModifier(),
|
||||
T->getIndexTypeCVRQualifiers());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitVariableArrayType(VariableArrayType *T) {
|
||||
QualType ToElementType = Importer.Import(T->getElementType());
|
||||
if (ToElementType.isNull())
|
||||
return QualType();
|
||||
|
||||
Expr *Size = Importer.Import(T->getSizeExpr());
|
||||
if (!Size)
|
||||
return QualType();
|
||||
|
||||
SourceRange Brackets = Importer.Import(T->getBracketsRange());
|
||||
return Importer.getToContext().getVariableArrayType(ToElementType, Size,
|
||||
T->getSizeModifier(),
|
||||
T->getIndexTypeCVRQualifiers(),
|
||||
Brackets);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitVectorType(VectorType *T) {
|
||||
QualType ToElementType = Importer.Import(T->getElementType());
|
||||
if (ToElementType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getVectorType(ToElementType,
|
||||
T->getNumElements(),
|
||||
T->isAltiVec(),
|
||||
T->isPixel());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitExtVectorType(ExtVectorType *T) {
|
||||
QualType ToElementType = Importer.Import(T->getElementType());
|
||||
if (ToElementType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getExtVectorType(ToElementType,
|
||||
T->getNumElements());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitFunctionNoProtoType(FunctionNoProtoType *T) {
|
||||
// FIXME: What happens if we're importing a function without a prototype
|
||||
// into C++? Should we make it variadic?
|
||||
QualType ToResultType = Importer.Import(T->getResultType());
|
||||
if (ToResultType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getFunctionNoProtoType(ToResultType,
|
||||
T->getNoReturnAttr(),
|
||||
T->getCallConv());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitFunctionProtoType(FunctionProtoType *T) {
|
||||
QualType ToResultType = Importer.Import(T->getResultType());
|
||||
if (ToResultType.isNull())
|
||||
return QualType();
|
||||
|
||||
// Import argument types
|
||||
llvm::SmallVector<QualType, 4> ArgTypes;
|
||||
for (FunctionProtoType::arg_type_iterator A = T->arg_type_begin(),
|
||||
AEnd = T->arg_type_end();
|
||||
A != AEnd; ++A) {
|
||||
QualType ArgType = Importer.Import(*A);
|
||||
if (ArgType.isNull())
|
||||
return QualType();
|
||||
ArgTypes.push_back(ArgType);
|
||||
}
|
||||
|
||||
// Import exception types
|
||||
llvm::SmallVector<QualType, 4> ExceptionTypes;
|
||||
for (FunctionProtoType::exception_iterator E = T->exception_begin(),
|
||||
EEnd = T->exception_end();
|
||||
E != EEnd; ++E) {
|
||||
QualType ExceptionType = Importer.Import(*E);
|
||||
if (ExceptionType.isNull())
|
||||
return QualType();
|
||||
ExceptionTypes.push_back(ExceptionType);
|
||||
}
|
||||
|
||||
return Importer.getToContext().getFunctionType(ToResultType, ArgTypes.data(),
|
||||
ArgTypes.size(),
|
||||
T->isVariadic(),
|
||||
T->getTypeQuals(),
|
||||
T->hasExceptionSpec(),
|
||||
T->hasAnyExceptionSpec(),
|
||||
ExceptionTypes.size(),
|
||||
ExceptionTypes.data(),
|
||||
T->getNoReturnAttr(),
|
||||
T->getCallConv());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitTypedefType(TypedefType *T) {
|
||||
TypedefDecl *ToDecl
|
||||
= dyn_cast_or_null<TypedefDecl>(Importer.Import(T->getDecl()));
|
||||
if (!ToDecl)
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getTypeDeclType(ToDecl);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitTypeOfExprType(TypeOfExprType *T) {
|
||||
Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
|
||||
if (!ToExpr)
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getTypeOfExprType(ToExpr);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitTypeOfType(TypeOfType *T) {
|
||||
QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
|
||||
if (ToUnderlyingType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getTypeOfType(ToUnderlyingType);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitDecltypeType(DecltypeType *T) {
|
||||
Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
|
||||
if (!ToExpr)
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getDecltypeType(ToExpr);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitRecordType(RecordType *T) {
|
||||
RecordDecl *ToDecl
|
||||
= dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
|
||||
if (!ToDecl)
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getTagDeclType(ToDecl);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitEnumType(EnumType *T) {
|
||||
EnumDecl *ToDecl
|
||||
= dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
|
||||
if (!ToDecl)
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getTagDeclType(ToDecl);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitElaboratedType(ElaboratedType *T) {
|
||||
QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
|
||||
if (ToUnderlyingType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getElaboratedType(ToUnderlyingType,
|
||||
T->getTagKind());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitQualifiedNameType(QualifiedNameType *T) {
|
||||
NestedNameSpecifier *ToQualifier = Importer.Import(T->getQualifier());
|
||||
if (!ToQualifier)
|
||||
return QualType();
|
||||
|
||||
QualType ToNamedType = Importer.Import(T->getNamedType());
|
||||
if (ToNamedType.isNull())
|
||||
return QualType();
|
||||
|
||||
return Importer.getToContext().getQualifiedNameType(ToQualifier, ToNamedType);
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitObjCInterfaceType(ObjCInterfaceType *T) {
|
||||
ObjCInterfaceDecl *Class
|
||||
= dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
|
||||
if (!Class)
|
||||
return QualType();
|
||||
|
||||
llvm::SmallVector<ObjCProtocolDecl *, 4> Protocols;
|
||||
for (ObjCInterfaceType::qual_iterator P = T->qual_begin(),
|
||||
PEnd = T->qual_end();
|
||||
P != PEnd; ++P) {
|
||||
ObjCProtocolDecl *Protocol
|
||||
= dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
|
||||
if (!Protocol)
|
||||
return QualType();
|
||||
Protocols.push_back(Protocol);
|
||||
}
|
||||
|
||||
return Importer.getToContext().getObjCInterfaceType(Class,
|
||||
Protocols.data(),
|
||||
Protocols.size());
|
||||
}
|
||||
|
||||
QualType ASTNodeImporter::VisitObjCObjectPointerType(ObjCObjectPointerType *T) {
|
||||
QualType ToPointeeType = Importer.Import(T->getPointeeType());
|
||||
if (ToPointeeType.isNull())
|
||||
return QualType();
|
||||
|
||||
llvm::SmallVector<ObjCProtocolDecl *, 4> Protocols;
|
||||
for (ObjCObjectPointerType::qual_iterator P = T->qual_begin(),
|
||||
PEnd = T->qual_end();
|
||||
P != PEnd; ++P) {
|
||||
ObjCProtocolDecl *Protocol
|
||||
= dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
|
||||
if (!Protocol)
|
||||
return QualType();
|
||||
Protocols.push_back(Protocol);
|
||||
}
|
||||
|
||||
return Importer.getToContext().getObjCObjectPointerType(ToPointeeType,
|
||||
Protocols.data(),
|
||||
Protocols.size());
|
||||
}
|
||||
|
||||
ASTImporter::ASTImporter(ASTContext &ToContext, Diagnostic &ToDiags,
|
||||
ASTContext &FromContext, Diagnostic &FromDiags)
|
||||
: ToContext(ToContext), FromContext(FromContext),
|
||||
ToDiags(ToDiags), FromDiags(FromDiags) { }
|
||||
|
||||
QualType ASTImporter::Import(QualType FromT) {
|
||||
if (FromT.isNull())
|
||||
return QualType();
|
||||
|
||||
// FIXME: Cache type mappings?
|
||||
|
||||
ASTNodeImporter Importer(*this);
|
||||
QualType ToT = Importer.Visit(FromT.getTypePtr());
|
||||
if (ToT.isNull())
|
||||
return ToT;
|
||||
|
||||
return ToContext.getQualifiedType(ToT, FromT.getQualifiers());
|
||||
}
|
||||
|
||||
DeclarationName ASTImporter::Import(DeclarationName FromName) {
|
||||
if (!FromName)
|
||||
return DeclarationName();
|
||||
|
||||
switch (FromName.getNameKind()) {
|
||||
case DeclarationName::Identifier:
|
||||
return Import(FromName.getAsIdentifierInfo());
|
||||
|
||||
case DeclarationName::ObjCZeroArgSelector:
|
||||
case DeclarationName::ObjCOneArgSelector:
|
||||
case DeclarationName::ObjCMultiArgSelector:
|
||||
return Import(FromName.getObjCSelector());
|
||||
|
||||
case DeclarationName::CXXConstructorName: {
|
||||
QualType T = Import(FromName.getCXXNameType());
|
||||
if (T.isNull())
|
||||
return DeclarationName();
|
||||
|
||||
return ToContext.DeclarationNames.getCXXConstructorName(
|
||||
ToContext.getCanonicalType(T));
|
||||
}
|
||||
|
||||
case DeclarationName::CXXDestructorName: {
|
||||
QualType T = Import(FromName.getCXXNameType());
|
||||
if (T.isNull())
|
||||
return DeclarationName();
|
||||
|
||||
return ToContext.DeclarationNames.getCXXDestructorName(
|
||||
ToContext.getCanonicalType(T));
|
||||
}
|
||||
|
||||
case DeclarationName::CXXConversionFunctionName: {
|
||||
QualType T = Import(FromName.getCXXNameType());
|
||||
if (T.isNull())
|
||||
return DeclarationName();
|
||||
|
||||
return ToContext.DeclarationNames.getCXXConversionFunctionName(
|
||||
ToContext.getCanonicalType(T));
|
||||
}
|
||||
|
||||
case DeclarationName::CXXOperatorName:
|
||||
return ToContext.DeclarationNames.getCXXOperatorName(
|
||||
FromName.getCXXOverloadedOperator());
|
||||
|
||||
case DeclarationName::CXXLiteralOperatorName:
|
||||
return ToContext.DeclarationNames.getCXXLiteralOperatorName(
|
||||
Import(FromName.getCXXLiteralIdentifier()));
|
||||
|
||||
case DeclarationName::CXXUsingDirective:
|
||||
// FIXME: STATICS!
|
||||
return DeclarationName::getUsingDirectiveName();
|
||||
}
|
||||
|
||||
// Silence bogus GCC warning
|
||||
return DeclarationName();
|
||||
}
|
||||
|
||||
IdentifierInfo *ASTImporter::Import(IdentifierInfo *FromId) {
|
||||
if (!FromId)
|
||||
return 0;
|
||||
|
||||
return &ToContext.Idents.get(FromId->getName());
|
||||
}
|
||||
|
|
@ -4,6 +4,7 @@ add_clang_library(clangAST
|
|||
APValue.cpp
|
||||
ASTConsumer.cpp
|
||||
ASTContext.cpp
|
||||
ASTImporter.cpp
|
||||
AttrImpl.cpp
|
||||
CXXInheritance.cpp
|
||||
Decl.cpp
|
||||
|
|
|
|||
Loading…
Reference in New Issue