maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/AST/ASTImporter.cpp

4538 lines
166 KiB
C++
Raw Normal View History

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
2010-02-06 01:54:41 +08:00
//===--- 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"
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
#include "clang/AST/ASTDiagnostic.h"
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
#include "clang/AST/DeclCXX.h"
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
2010-02-06 01:54:41 +08:00
#include "clang/AST/DeclObjC.h"
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
#include "clang/AST/DeclVisitor.h"
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
#include "clang/AST/StmtVisitor.h"
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
2010-02-06 01:54:41 +08:00
#include "clang/AST/TypeVisitor.h"
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
#include "clang/Basic/FileManager.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/Support/MemoryBuffer.h"
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
#include <deque>
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
2010-02-06 01:54:41 +08:00
using namespace clang;
namespace {
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
public DeclVisitor<ASTNodeImporter, Decl *>,
public StmtVisitor<ASTNodeImporter, Stmt *> {
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
2010-02-06 01:54:41 +08:00
ASTImporter &Importer;
public:
explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
using TypeVisitor<ASTNodeImporter, QualType>::Visit;
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
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
2010-02-06 01:54:41 +08:00
// Importing types
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType VisitType(const Type *T);
QualType VisitBuiltinType(const BuiltinType *T);
QualType VisitComplexType(const ComplexType *T);
QualType VisitPointerType(const PointerType *T);
QualType VisitBlockPointerType(const BlockPointerType *T);
QualType VisitLValueReferenceType(const LValueReferenceType *T);
QualType VisitRValueReferenceType(const RValueReferenceType *T);
QualType VisitMemberPointerType(const MemberPointerType *T);
QualType VisitConstantArrayType(const ConstantArrayType *T);
QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
QualType VisitVariableArrayType(const VariableArrayType *T);
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
2010-02-06 01:54:41 +08:00
// FIXME: DependentSizedArrayType
// FIXME: DependentSizedExtVectorType
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType VisitVectorType(const VectorType *T);
QualType VisitExtVectorType(const ExtVectorType *T);
QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
QualType VisitFunctionProtoType(const FunctionProtoType *T);
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
2010-02-06 01:54:41 +08:00
// FIXME: UnresolvedUsingType
Extended the AST importer to support ParenTypes. This is necessary to support importing certain function pointer types. llvm-svn: 137311
2011-08-12 00:56:07 +08:00
QualType VisitParenType(const ParenType *T);
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType VisitTypedefType(const TypedefType *T);
QualType VisitTypeOfExprType(const TypeOfExprType *T);
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
2010-02-06 01:54:41 +08:00
// FIXME: DependentTypeOfExprType
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType VisitTypeOfType(const TypeOfType *T);
QualType VisitDecltypeType(const DecltypeType *T);
Implement a new type node, UnaryTransformType, designed to represent a type that turns one type into another. This is used as the basis to implement __underlying_type properly - with TypeSourceInfo and proper behavior in the face of templates. llvm-svn: 132017
2011-05-25 06:41:36 +08:00
QualType VisitUnaryTransformType(const UnaryTransformType *T);
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
QualType VisitAutoType(const AutoType *T);
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
2010-02-06 01:54:41 +08:00
// FIXME: DependentDecltypeType
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType VisitRecordType(const RecordType *T);
QualType VisitEnumType(const EnumType *T);
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
2010-02-06 01:54:41 +08:00
// FIXME: TemplateTypeParmType
// FIXME: SubstTemplateTypeParmType
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
QualType VisitElaboratedType(const ElaboratedType *T);
Rename TypenameType to DependentNameType in anticipation of some refactoring work in this area. llvm-svn: 100019
2010-04-01 01:34:00 +08:00
// FIXME: DependentNameType
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
// FIXME: DependentTemplateSpecializationType
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
QualType VisitObjCObjectType(const ObjCObjectType *T);
QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// Importing declarations
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
DeclContext *&LexicalDC, DeclarationName &Name,
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
SourceLocation &Loc);
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = 0);
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
DeclarationNameInfo& To);
Introduce the notion of a "minimal" import of ASTs, to better support LLDB. llvm-svn: 123723
2011-01-18 11:11:38 +08:00
void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
bool ImportDefinition(RecordDecl *From, RecordDecl *To,
bool ForceImport = false);
bool ImportDefinition(EnumDecl *From, EnumDecl *To,
bool ForceImport = false);
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
TemplateParameterList *ImportTemplateParameterList(
TemplateParameterList *Params);
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
bool ImportTemplateArguments(const TemplateArgument *FromArgs,
unsigned NumFromArgs,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<TemplateArgument> &ToArgs);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord);
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
Complain about types and declarations that we don't know how to import. llvm-svn: 95706
2010-02-10 06:48:33 +08:00
Decl *VisitDecl(Decl *D);
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
Decl *VisitNamespaceDecl(NamespaceDecl *D);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
Decl *VisitTypedefDecl(TypedefDecl *D);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
Decl *VisitEnumDecl(EnumDecl *D);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
Decl *VisitRecordDecl(RecordDecl *D);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Decl *VisitFunctionDecl(FunctionDecl *D);
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
Decl *VisitFieldDecl(FieldDecl *D);
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
Implement AST importing of Objective-C instance variables. Check superclasses when merging two Objective-C @interfaces. llvm-svn: 96420
2010-02-17 08:34:30 +08:00
Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
Decl *VisitVarDecl(VarDecl *D);
Implement AST importing of ImplicitParamDecls, despite the sad fact that we can't test it yet. llvm-svn: 96516
2010-02-18 05:22:52 +08:00
Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Decl *VisitParmVarDecl(ParmVarDecl *D);
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
Implement ASTImporter support for Objective-C category implementations. llvm-svn: 121139
2010-12-07 23:32:12 +08:00
Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
Extern the ASTImporter to import @implementation declarations. llvm-svn: 121097
2010-12-07 09:26:03 +08:00
Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
Implement AST merging for Objective-C properties. llvm-svn: 96483
2010-02-18 02:02:10 +08:00
Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
Implement AST import for Objective-C property implementations (@synthesize and @dynamic). llvm-svn: 121159
2010-12-08 02:32:03 +08:00
Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
AST import for forward declarations of Objective-C protocols llvm-svn: 96555
2010-02-18 10:12:22 +08:00
Decl *VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D);
Implement import of forward declarations of Objective-C classes llvm-svn: 96554
2010-02-18 10:04:09 +08:00
Decl *VisitObjCClassDecl(ObjCClassDecl *D);
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
Decl *VisitClassTemplateSpecializationDecl(
ClassTemplateSpecializationDecl *D);
Implement import of forward declarations of Objective-C classes llvm-svn: 96554
2010-02-18 10:04:09 +08:00
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
// Importing statements
Stmt *VisitStmt(Stmt *S);
// Importing expressions
Expr *VisitExpr(Expr *E);
AST import for DeclRefExprs llvm-svn: 96646
2010-02-19 09:17:02 +08:00
Expr *VisitDeclRefExpr(DeclRefExpr *E);
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
Expr *VisitIntegerLiteral(IntegerLiteral *E);
AST import for character literals llvm-svn: 96557
2010-02-18 10:21:22 +08:00
Expr *VisitCharacterLiteral(CharacterLiteral *E);
AST import of parenthesized expressions, unary operators, binary operators, and compound assignment operators. llvm-svn: 96643
2010-02-19 09:07:06 +08:00
Expr *VisitParenExpr(ParenExpr *E);
Expr *VisitUnaryOperator(UnaryOperator *E);
Add support for the OpenCL vec_step operator, by generalising and extending the existing support for sizeof and alignof. Original patch by Guy Benyei. llvm-svn: 127475
2011-03-12 03:24:49 +08:00
Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
AST import of parenthesized expressions, unary operators, binary operators, and compound assignment operators. llvm-svn: 96643
2010-02-19 09:07:06 +08:00
Expr *VisitBinaryOperator(BinaryOperator *E);
Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
AST import for CStyleCastExpr. With this, we can import Cocoa.h into an empty context llvm-svn: 96648
2010-02-19 09:32:14 +08:00
Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
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
2010-02-06 01:54:41 +08:00
};
}
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
//----------------------------------------------------------------------------
// Structural Equivalence
//----------------------------------------------------------------------------
namespace {
struct StructuralEquivalenceContext {
/// \brief AST contexts for which we are checking structural equivalence.
ASTContext &C1, &C2;
/// \brief The set of "tentative" equivalences between two canonical
/// declarations, mapping from a declaration in the first context to the
/// declaration in the second context that we believe to be equivalent.
llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
/// \brief Queue of declarations in the first context whose equivalence
/// with a declaration in the second context still needs to be verified.
std::deque<Decl *> DeclsToCheck;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
/// \brief Declaration (from, to) pairs that are known not to be equivalent
/// (which we have already complained about).
llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
/// \brief Whether we're being strict about the spelling of types when
/// unifying two types.
bool StrictTypeSpelling;
StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
bool StrictTypeSpelling = false)
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
: C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
StrictTypeSpelling(StrictTypeSpelling) { }
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
/// \brief Determine whether the two declarations are structurally
/// equivalent.
bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
/// \brief Determine whether the two types are structurally equivalent.
bool IsStructurallyEquivalent(QualType T1, QualType T2);
private:
/// \brief Finish checking all of the structural equivalences.
///
/// \returns true if an error occurred, false otherwise.
bool Finish();
public:
DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
return C1.getDiagnostics().Report(Loc, DiagID);
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
return C2.getDiagnostics().Report(Loc, DiagID);
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
};
}
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
QualType T1, QualType T2);
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
Decl *D1, Decl *D2);
/// \brief Determine if two APInts have the same value, after zero-extending
/// one of them (if needed!) to ensure that the bit-widths match.
static bool IsSameValue(const llvm::APInt &I1, const llvm::APInt &I2) {
if (I1.getBitWidth() == I2.getBitWidth())
return I1 == I2;
if (I1.getBitWidth() > I2.getBitWidth())
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121121
2010-12-07 16:25:34 +08:00
return I1 == I2.zext(I1.getBitWidth());
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121121
2010-12-07 16:25:34 +08:00
return I1.zext(I2.getBitWidth()) == I2;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
/// \brief Determine if two APSInts have the same value, zero- or sign-extending
/// as needed.
static bool IsSameValue(const llvm::APSInt &I1, const llvm::APSInt &I2) {
if (I1.getBitWidth() == I2.getBitWidth() && I1.isSigned() == I2.isSigned())
return I1 == I2;
// Check for a bit-width mismatch.
if (I1.getBitWidth() > I2.getBitWidth())
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121121
2010-12-07 16:25:34 +08:00
return IsSameValue(I1, I2.extend(I1.getBitWidth()));
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
else if (I2.getBitWidth() > I1.getBitWidth())
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121121
2010-12-07 16:25:34 +08:00
return IsSameValue(I1.extend(I2.getBitWidth()), I2);
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
// We have a signedness mismatch. Turn the signed value into an unsigned
// value.
if (I1.isSigned()) {
if (I1.isNegative())
return false;
return llvm::APSInt(I1, true) == I2;
}
if (I2.isNegative())
return false;
return I1 == llvm::APSInt(I2, true);
}
/// \brief Determine structural equivalence of two expressions.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
Expr *E1, Expr *E2) {
if (!E1 || !E2)
return E1 == E2;
// FIXME: Actually perform a structural comparison!
return true;
}
/// \brief Determine whether two identifiers are equivalent.
static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
const IdentifierInfo *Name2) {
if (!Name1 || !Name2)
return Name1 == Name2;
return Name1->getName() == Name2->getName();
}
/// \brief Determine whether two nested-name-specifiers are equivalent.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
NestedNameSpecifier *NNS1,
NestedNameSpecifier *NNS2) {
// FIXME: Implement!
return true;
}
/// \brief Determine whether two template arguments are equivalent.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
const TemplateArgument &Arg1,
const TemplateArgument &Arg2) {
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
if (Arg1.getKind() != Arg2.getKind())
return false;
switch (Arg1.getKind()) {
case TemplateArgument::Null:
return true;
case TemplateArgument::Type:
return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
case TemplateArgument::Integral:
if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
Arg2.getIntegralType()))
return false;
return IsSameValue(*Arg1.getAsIntegral(), *Arg2.getAsIntegral());
case TemplateArgument::Declaration:
return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
case TemplateArgument::Template:
return IsStructurallyEquivalent(Context,
Arg1.getAsTemplate(),
Arg2.getAsTemplate());
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
case TemplateArgument::TemplateExpansion:
return IsStructurallyEquivalent(Context,
Arg1.getAsTemplateOrTemplatePattern(),
Arg2.getAsTemplateOrTemplatePattern());
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
case TemplateArgument::Expression:
return IsStructurallyEquivalent(Context,
Arg1.getAsExpr(), Arg2.getAsExpr());
case TemplateArgument::Pack:
if (Arg1.pack_size() != Arg2.pack_size())
return false;
for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
if (!IsStructurallyEquivalent(Context,
Arg1.pack_begin()[I],
Arg2.pack_begin()[I]))
return false;
return true;
}
llvm_unreachable("Invalid template argument kind");
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return true;
}
/// \brief Determine structural equivalence for the common part of array
/// types.
static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
const ArrayType *Array1,
const ArrayType *Array2) {
if (!IsStructurallyEquivalent(Context,
Array1->getElementType(),
Array2->getElementType()))
return false;
if (Array1->getSizeModifier() != Array2->getSizeModifier())
return false;
if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
return false;
return true;
}
/// \brief Determine structural equivalence of two types.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
QualType T1, QualType T2) {
if (T1.isNull() || T2.isNull())
return T1.isNull() && T2.isNull();
if (!Context.StrictTypeSpelling) {
// We aren't being strict about token-to-token equivalence of types,
// so map down to the canonical type.
T1 = Context.C1.getCanonicalType(T1);
T2 = Context.C2.getCanonicalType(T2);
}
if (T1.getQualifiers() != T2.getQualifiers())
return false;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Type::TypeClass TC = T1->getTypeClass();
if (T1->getTypeClass() != T2->getTypeClass()) {
// Compare function types with prototypes vs. without prototypes as if
// both did not have prototypes.
if (T1->getTypeClass() == Type::FunctionProto &&
T2->getTypeClass() == Type::FunctionNoProto)
TC = Type::FunctionNoProto;
else if (T1->getTypeClass() == Type::FunctionNoProto &&
T2->getTypeClass() == Type::FunctionProto)
TC = Type::FunctionNoProto;
else
return false;
}
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
switch (TC) {
case Type::Builtin:
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
// FIXME: Deal with Char_S/Char_U.
if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
return false;
break;
case Type::Complex:
if (!IsStructurallyEquivalent(Context,
cast<ComplexType>(T1)->getElementType(),
cast<ComplexType>(T2)->getElementType()))
return false;
break;
case Type::Pointer:
if (!IsStructurallyEquivalent(Context,
cast<PointerType>(T1)->getPointeeType(),
cast<PointerType>(T2)->getPointeeType()))
return false;
break;
case Type::BlockPointer:
if (!IsStructurallyEquivalent(Context,
cast<BlockPointerType>(T1)->getPointeeType(),
cast<BlockPointerType>(T2)->getPointeeType()))
return false;
break;
case Type::LValueReference:
case Type::RValueReference: {
const ReferenceType *Ref1 = cast<ReferenceType>(T1);
const ReferenceType *Ref2 = cast<ReferenceType>(T2);
if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
return false;
if (Ref1->isInnerRef() != Ref2->isInnerRef())
return false;
if (!IsStructurallyEquivalent(Context,
Ref1->getPointeeTypeAsWritten(),
Ref2->getPointeeTypeAsWritten()))
return false;
break;
}
case Type::MemberPointer: {
const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
if (!IsStructurallyEquivalent(Context,
MemPtr1->getPointeeType(),
MemPtr2->getPointeeType()))
return false;
if (!IsStructurallyEquivalent(Context,
QualType(MemPtr1->getClass(), 0),
QualType(MemPtr2->getClass(), 0)))
return false;
break;
}
case Type::ConstantArray: {
const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
if (!IsSameValue(Array1->getSize(), Array2->getSize()))
return false;
if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
return false;
break;
}
case Type::IncompleteArray:
if (!IsArrayStructurallyEquivalent(Context,
cast<ArrayType>(T1),
cast<ArrayType>(T2)))
return false;
break;
case Type::VariableArray: {
const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
if (!IsStructurallyEquivalent(Context,
Array1->getSizeExpr(), Array2->getSizeExpr()))
return false;
if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
return false;
break;
}
case Type::DependentSizedArray: {
const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
if (!IsStructurallyEquivalent(Context,
Array1->getSizeExpr(), Array2->getSizeExpr()))
return false;
if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
return false;
break;
}
case Type::DependentSizedExtVector: {
const DependentSizedExtVectorType *Vec1
= cast<DependentSizedExtVectorType>(T1);
const DependentSizedExtVectorType *Vec2
= cast<DependentSizedExtVectorType>(T2);
if (!IsStructurallyEquivalent(Context,
Vec1->getSizeExpr(), Vec2->getSizeExpr()))
return false;
if (!IsStructurallyEquivalent(Context,
Vec1->getElementType(),
Vec2->getElementType()))
return false;
break;
}
case Type::Vector:
case Type::ExtVector: {
const VectorType *Vec1 = cast<VectorType>(T1);
const VectorType *Vec2 = cast<VectorType>(T2);
if (!IsStructurallyEquivalent(Context,
Vec1->getElementType(),
Vec2->getElementType()))
return false;
if (Vec1->getNumElements() != Vec2->getNumElements())
return false;
Add a variant of GCC-style vector types for ARM NEON. NEON vector types need to be mangled in a special way to comply with ARM's ABI, similar to some of the AltiVec-specific vector types. This patch is mostly just renaming a bunch of "AltiVecSpecific" things, since they will no longer be specific to AltiVec. Besides that, it just adds the new "NeonVector" enum. llvm-svn: 118724
2010-11-11 05:56:12 +08:00
if (Vec1->getVectorKind() != Vec2->getVectorKind())
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
Add a missing break. Cocoa.h can now be merged twice into the same AST context llvm-svn: 96650
2010-02-19 09:36:36 +08:00
break;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
case Type::FunctionProto: {
const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
if (Proto1->getNumArgs() != Proto2->getNumArgs())
return false;
for (unsigned I = 0, N = Proto1->getNumArgs(); I != N; ++I) {
if (!IsStructurallyEquivalent(Context,
Proto1->getArgType(I),
Proto2->getArgType(I)))
return false;
}
if (Proto1->isVariadic() != Proto2->isVariadic())
return false;
Propagate the new exception information to FunctionProtoType. Change the interface to expose the new information and deal with the enormous fallout. Introduce the new ExceptionSpecificationType value EST_DynamicNone to more easily deal with empty throw specifications. Update the tests for noexcept and fix the various bugs uncovered, such as lack of tentative parsing support. llvm-svn: 127537
2011-03-12 19:50:43 +08:00
if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
Propagate the new exception information to FunctionProtoType. Change the interface to expose the new information and deal with the enormous fallout. Introduce the new ExceptionSpecificationType value EST_DynamicNone to more easily deal with empty throw specifications. Update the tests for noexcept and fix the various bugs uncovered, such as lack of tentative parsing support. llvm-svn: 127537
2011-03-12 19:50:43 +08:00
if (Proto1->getExceptionSpecType() == EST_Dynamic) {
if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
return false;
for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
if (!IsStructurallyEquivalent(Context,
Proto1->getExceptionType(I),
Proto2->getExceptionType(I)))
return false;
}
} else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (!IsStructurallyEquivalent(Context,
Propagate the new exception information to FunctionProtoType. Change the interface to expose the new information and deal with the enormous fallout. Introduce the new ExceptionSpecificationType value EST_DynamicNone to more easily deal with empty throw specifications. Update the tests for noexcept and fix the various bugs uncovered, such as lack of tentative parsing support. llvm-svn: 127537
2011-03-12 19:50:43 +08:00
Proto1->getNoexceptExpr(),
Proto2->getNoexceptExpr()))
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
}
if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
return false;
// Fall through to check the bits common with FunctionNoProtoType.
}
case Type::FunctionNoProto: {
const FunctionType *Function1 = cast<FunctionType>(T1);
const FunctionType *Function2 = cast<FunctionType>(T2);
if (!IsStructurallyEquivalent(Context,
Function1->getResultType(),
Function2->getResultType()))
return false;
the big refactoring bits of PR3782. This introduces FunctionType::ExtInfo to hold the calling convention and the noreturn attribute. The next patch will extend it to include the regparm attribute and fix the bug. llvm-svn: 99920
2010-03-31 04:24:48 +08:00
if (Function1->getExtInfo() != Function2->getExtInfo())
return false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
break;
}
case Type::UnresolvedUsing:
if (!IsStructurallyEquivalent(Context,
cast<UnresolvedUsingType>(T1)->getDecl(),
cast<UnresolvedUsingType>(T2)->getDecl()))
return false;
break;
Introduce an AttributedType, but don't actually use it anywhere yet. The initial TreeTransform is a cop-out, but it's more-or-less equivalent to what we were doing before, or rather what we're doing now and might eventually stop doing in favor of using this type. I am simultaneously intrigued by the possibilities of rebuilding a dependent Attri llvm-svn: 122942
2011-01-06 09:58:22 +08:00
case Type::Attributed:
if (!IsStructurallyEquivalent(Context,
cast<AttributedType>(T1)->getModifiedType(),
cast<AttributedType>(T2)->getModifiedType()))
return false;
if (!IsStructurallyEquivalent(Context,
cast<AttributedType>(T1)->getEquivalentType(),
cast<AttributedType>(T2)->getEquivalentType()))
return false;
break;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Added ParenType type node. llvm-svn: 121488
2010-12-11 00:29:40 +08:00
case Type::Paren:
if (!IsStructurallyEquivalent(Context,
cast<ParenType>(T1)->getInnerType(),
cast<ParenType>(T2)->getInnerType()))
return false;
break;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
case Type::Typedef:
if (!IsStructurallyEquivalent(Context,
cast<TypedefType>(T1)->getDecl(),
cast<TypedefType>(T2)->getDecl()))
return false;
break;
case Type::TypeOfExpr:
if (!IsStructurallyEquivalent(Context,
cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
return false;
break;
case Type::TypeOf:
if (!IsStructurallyEquivalent(Context,
cast<TypeOfType>(T1)->getUnderlyingType(),
cast<TypeOfType>(T2)->getUnderlyingType()))
return false;
break;
Implement a new type node, UnaryTransformType, designed to represent a type that turns one type into another. This is used as the basis to implement __underlying_type properly - with TypeSourceInfo and proper behavior in the face of templates. llvm-svn: 132017
2011-05-25 06:41:36 +08:00
case Type::UnaryTransform:
if (!IsStructurallyEquivalent(Context,
cast<UnaryTransformType>(T1)->getUnderlyingType(),
cast<UnaryTransformType>(T1)->getUnderlyingType()))
return false;
break;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
case Type::Decltype:
if (!IsStructurallyEquivalent(Context,
cast<DecltypeType>(T1)->getUnderlyingExpr(),
cast<DecltypeType>(T2)->getUnderlyingExpr()))
return false;
break;
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
case Type::Auto:
if (!IsStructurallyEquivalent(Context,
cast<AutoType>(T1)->getDeducedType(),
cast<AutoType>(T2)->getDeducedType()))
return false;
break;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
case Type::Record:
case Type::Enum:
if (!IsStructurallyEquivalent(Context,
cast<TagType>(T1)->getDecl(),
cast<TagType>(T2)->getDecl()))
return false;
break;
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
case Type::TemplateTypeParm: {
const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
if (Parm1->getDepth() != Parm2->getDepth())
return false;
if (Parm1->getIndex() != Parm2->getIndex())
return false;
if (Parm1->isParameterPack() != Parm2->isParameterPack())
return false;
// Names of template type parameters are never significant.
break;
}
case Type::SubstTemplateTypeParm: {
const SubstTemplateTypeParmType *Subst1
= cast<SubstTemplateTypeParmType>(T1);
const SubstTemplateTypeParmType *Subst2
= cast<SubstTemplateTypeParmType>(T2);
if (!IsStructurallyEquivalent(Context,
QualType(Subst1->getReplacedParameter(), 0),
QualType(Subst2->getReplacedParameter(), 0)))
return false;
if (!IsStructurallyEquivalent(Context,
Subst1->getReplacementType(),
Subst2->getReplacementType()))
return false;
break;
}
Fix a few warnings stemming from my inability to properly fill out switch() statements. llvm-svn: 123429
2011-01-14 13:11:40 +08:00
case Type::SubstTemplateTypeParmPack: {
const SubstTemplateTypeParmPackType *Subst1
= cast<SubstTemplateTypeParmPackType>(T1);
const SubstTemplateTypeParmPackType *Subst2
= cast<SubstTemplateTypeParmPackType>(T2);
if (!IsStructurallyEquivalent(Context,
QualType(Subst1->getReplacedParameter(), 0),
QualType(Subst2->getReplacedParameter(), 0)))
return false;
if (!IsStructurallyEquivalent(Context,
Subst1->getArgumentPack(),
Subst2->getArgumentPack()))
return false;
break;
}
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
case Type::TemplateSpecialization: {
const TemplateSpecializationType *Spec1
= cast<TemplateSpecializationType>(T1);
const TemplateSpecializationType *Spec2
= cast<TemplateSpecializationType>(T2);
if (!IsStructurallyEquivalent(Context,
Spec1->getTemplateName(),
Spec2->getTemplateName()))
return false;
if (Spec1->getNumArgs() != Spec2->getNumArgs())
return false;
for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
if (!IsStructurallyEquivalent(Context,
Spec1->getArg(I), Spec2->getArg(I)))
return false;
}
break;
}
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
case Type::Elaborated: {
const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
// CHECKME: what if a keyword is ETK_None or ETK_typename ?
if (Elab1->getKeyword() != Elab2->getKeyword())
return false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (!IsStructurallyEquivalent(Context,
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
Elab1->getQualifier(),
Elab2->getQualifier()))
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
if (!IsStructurallyEquivalent(Context,
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
Elab1->getNamedType(),
Elab2->getNamedType()))
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
break;
}
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
case Type::InjectedClassName: {
const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
if (!IsStructurallyEquivalent(Context,
Make the InjectedClassNameType the canonical type of the current instantiation of a class template or class template partial specialization. That is to say, in template <class T> class A { ... }; or template <class T> class B<const T*> { ... }; make 'A<T>' and 'B<const T*>' sugar for the corresponding InjectedClassNameType when written inside the appropriate context. This allows us to track the current instantiation appropriately even inside AST routines. It also allows us to compute a DeclContext for a type much more efficiently, at some extra cost every time we write a template specialization (which can be optimized, but I've left it simple in this patch). llvm-svn: 102407
2010-04-27 08:57:59 +08:00
Inj1->getInjectedSpecializationType(),
Inj2->getInjectedSpecializationType()))
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
return false;
break;
}
Rename TypenameType to DependentNameType in anticipation of some refactoring work in this area. llvm-svn: 100019
2010-04-01 01:34:00 +08:00
case Type::DependentName: {
const DependentNameType *Typename1 = cast<DependentNameType>(T1);
const DependentNameType *Typename2 = cast<DependentNameType>(T2);
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (!IsStructurallyEquivalent(Context,
Typename1->getQualifier(),
Typename2->getQualifier()))
return false;
if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
Typename2->getIdentifier()))
return false;
break;
}
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
case Type::DependentTemplateSpecialization: {
const DependentTemplateSpecializationType *Spec1 =
cast<DependentTemplateSpecializationType>(T1);
const DependentTemplateSpecializationType *Spec2 =
cast<DependentTemplateSpecializationType>(T2);
if (!IsStructurallyEquivalent(Context,
Spec1->getQualifier(),
Spec2->getQualifier()))
return false;
if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
Spec2->getIdentifier()))
return false;
if (Spec1->getNumArgs() != Spec2->getNumArgs())
return false;
for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
if (!IsStructurallyEquivalent(Context,
Spec1->getArg(I), Spec2->getArg(I)))
return false;
}
break;
}
Introduce a new type, PackExpansionType, to capture types that are pack expansions, e.g. given template<typename... Types> struct tuple; template<typename... Types> struct tuple_of_refs { typedef tuple<Types&...> types; }; the type of the "types" typedef is a PackExpansionType whose pattern is Types&. This commit introduces support for creating pack expansions for template type arguments, as above, but not for any other kind of pack expansion, nor for any form of instantiation. llvm-svn: 122223
2010-12-20 10:24:11 +08:00
case Type::PackExpansion:
if (!IsStructurallyEquivalent(Context,
cast<PackExpansionType>(T1)->getPattern(),
cast<PackExpansionType>(T2)->getPattern()))
return false;
break;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
case Type::ObjCInterface: {
const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
if (!IsStructurallyEquivalent(Context,
Iface1->getDecl(), Iface2->getDecl()))
return false;
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
break;
}
case Type::ObjCObject: {
const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
if (!IsStructurallyEquivalent(Context,
Obj1->getBaseType(),
Obj2->getBaseType()))
return false;
if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (!IsStructurallyEquivalent(Context,
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
Obj1->getProtocol(I),
Obj2->getProtocol(I)))
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
}
break;
}
case Type::ObjCObjectPointer: {
const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
if (!IsStructurallyEquivalent(Context,
Ptr1->getPointeeType(),
Ptr2->getPointeeType()))
return false;
break;
}
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
case Type::Atomic: {
if (!IsStructurallyEquivalent(Context,
cast<AtomicType>(T1)->getValueType(),
cast<AtomicType>(T2)->getValueType()))
return false;
break;
}
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
} // end switch
return true;
}
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
/// \brief Determine structural equivalence of two fields.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
FieldDecl *Field1, FieldDecl *Field2) {
RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
if (!IsStructurallyEquivalent(Context,
Field1->getType(), Field2->getType())) {
Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(Owner2);
Context.Diag2(Field2->getLocation(), diag::note_odr_field)
<< Field2->getDeclName() << Field2->getType();
Context.Diag1(Field1->getLocation(), diag::note_odr_field)
<< Field1->getDeclName() << Field1->getType();
return false;
}
if (Field1->isBitField() != Field2->isBitField()) {
Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(Owner2);
if (Field1->isBitField()) {
Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
<< Field1->getDeclName() << Field1->getType()
<< Field1->getBitWidthValue(Context.C1);
Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
<< Field2->getDeclName();
} else {
Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
<< Field2->getDeclName() << Field2->getType()
<< Field2->getBitWidthValue(Context.C2);
Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
<< Field1->getDeclName();
}
return false;
}
if (Field1->isBitField()) {
// Make sure that the bit-fields are the same length.
unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
if (Bits1 != Bits2) {
Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(Owner2);
Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
<< Field2->getDeclName() << Field2->getType() << Bits2;
Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
<< Field1->getDeclName() << Field1->getType() << Bits1;
return false;
}
}
return true;
}
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
/// \brief Determine structural equivalence of two records.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
RecordDecl *D1, RecordDecl *D2) {
if (D1->isUnion() != D2->isUnion()) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
<< D1->getDeclName() << (unsigned)D1->getTagKind();
return false;
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
// If both declarations are class template specializations, we know
// the ODR applies, so check the template and template arguments.
ClassTemplateSpecializationDecl *Spec1
= dyn_cast<ClassTemplateSpecializationDecl>(D1);
ClassTemplateSpecializationDecl *Spec2
= dyn_cast<ClassTemplateSpecializationDecl>(D2);
if (Spec1 && Spec2) {
// Check that the specialized templates are the same.
if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
Spec2->getSpecializedTemplate()))
return false;
// Check that the template arguments are the same.
if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
return false;
for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
if (!IsStructurallyEquivalent(Context,
Spec1->getTemplateArgs().get(I),
Spec2->getTemplateArgs().get(I)))
return false;
}
// If one is a class template specialization and the other is not, these
fix a bunch of comment typos found by codespell. Patch by Luis Felipe Strano Moraes! llvm-svn: 129559
2011-04-15 13:22:18 +08:00
// structures are different.
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
else if (Spec1 || Spec2)
return false;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// Compare the definitions of these two records. If either or both are
// incomplete, we assume that they are equivalent.
D1 = D1->getDefinition();
D2 = D2->getDefinition();
if (!D1 || !D2)
return true;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
<< Context.C2.getTypeDeclType(D2);
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
<< D2CXX->getNumBases();
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
<< D1CXX->getNumBases();
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return false;
}
// Check the base classes.
for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
BaseEnd1 = D1CXX->bases_end(),
Base2 = D2CXX->bases_begin();
Base1 != BaseEnd1;
++Base1, ++Base2) {
if (!IsStructurallyEquivalent(Context,
Base1->getType(), Base2->getType())) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag2(Base2->getSourceRange().getBegin(), diag::note_odr_base)
<< Base2->getType()
<< Base2->getSourceRange();
Context.Diag1(Base1->getSourceRange().getBegin(), diag::note_odr_base)
<< Base1->getType()
<< Base1->getSourceRange();
return false;
}
// Check virtual vs. non-virtual inheritance mismatch.
if (Base1->isVirtual() != Base2->isVirtual()) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag2(Base2->getSourceRange().getBegin(),
diag::note_odr_virtual_base)
<< Base2->isVirtual() << Base2->getSourceRange();
Context.Diag1(Base1->getSourceRange().getBegin(), diag::note_odr_base)
<< Base1->isVirtual()
<< Base1->getSourceRange();
return false;
}
}
} else if (D1CXX->getNumBases() > 0) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
Context.Diag1(Base1->getSourceRange().getBegin(), diag::note_odr_base)
<< Base1->getType()
<< Base1->getSourceRange();
Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
return false;
}
}
// Check the fields for consistency.
CXXRecordDecl::field_iterator Field2 = D2->field_begin(),
Field2End = D2->field_end();
for (CXXRecordDecl::field_iterator Field1 = D1->field_begin(),
Field1End = D1->field_end();
Field1 != Field1End;
++Field1, ++Field2) {
if (Field2 == Field2End) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag1(Field1->getLocation(), diag::note_odr_field)
<< Field1->getDeclName() << Field1->getType();
Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
return false;
}
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
return false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
if (Field2 != Field2End) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag2(Field2->getLocation(), diag::note_odr_field)
<< Field2->getDeclName() << Field2->getType();
Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
return false;
}
return true;
}
/// \brief Determine structural equivalence of two enums.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
EnumDecl *D1, EnumDecl *D2) {
EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
EC2End = D2->enumerator_end();
for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
EC1End = D1->enumerator_end();
EC1 != EC1End; ++EC1, ++EC2) {
if (EC2 == EC2End) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
<< EC1->getDeclName()
<< EC1->getInitVal().toString(10);
Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
return false;
}
llvm::APSInt Val1 = EC1->getInitVal();
llvm::APSInt Val2 = EC2->getInitVal();
if (!IsSameValue(Val1, Val2) ||
!IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
<< EC2->getDeclName()
<< EC2->getInitVal().toString(10);
Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
<< EC1->getDeclName()
<< EC1->getInitVal().toString(10);
return false;
}
}
if (EC2 != EC2End) {
Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
<< Context.C2.getTypeDeclType(D2);
Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
<< EC2->getDeclName()
<< EC2->getInitVal().toString(10);
Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
return false;
}
return true;
}
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
TemplateParameterList *Params1,
TemplateParameterList *Params2) {
if (Params1->size() != Params2->size()) {
Context.Diag2(Params2->getTemplateLoc(),
diag::err_odr_different_num_template_parameters)
<< Params1->size() << Params2->size();
Context.Diag1(Params1->getTemplateLoc(),
diag::note_odr_template_parameter_list);
return false;
}
for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
Context.Diag2(Params2->getParam(I)->getLocation(),
diag::err_odr_different_template_parameter_kind);
Context.Diag1(Params1->getParam(I)->getLocation(),
diag::note_odr_template_parameter_here);
return false;
}
if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
Params2->getParam(I))) {
return false;
}
}
return true;
}
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
TemplateTypeParmDecl *D1,
TemplateTypeParmDecl *D2) {
if (D1->isParameterPack() != D2->isParameterPack()) {
Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
<< D2->isParameterPack();
Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
<< D1->isParameterPack();
return false;
}
return true;
}
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
NonTypeTemplateParmDecl *D1,
NonTypeTemplateParmDecl *D2) {
// FIXME: Enable once we have variadic templates.
#if 0
if (D1->isParameterPack() != D2->isParameterPack()) {
Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
<< D2->isParameterPack();
Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
<< D1->isParameterPack();
return false;
}
#endif
// Check types.
if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
Context.Diag2(D2->getLocation(),
diag::err_odr_non_type_parameter_type_inconsistent)
<< D2->getType() << D1->getType();
Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
<< D1->getType();
return false;
}
return true;
}
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
TemplateTemplateParmDecl *D1,
TemplateTemplateParmDecl *D2) {
// FIXME: Enable once we have variadic templates.
#if 0
if (D1->isParameterPack() != D2->isParameterPack()) {
Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
<< D2->isParameterPack();
Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
<< D1->isParameterPack();
return false;
}
#endif
// Check template parameter lists.
return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
D2->getTemplateParameters());
}
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
ClassTemplateDecl *D1,
ClassTemplateDecl *D2) {
// Check template parameters.
if (!IsStructurallyEquivalent(Context,
D1->getTemplateParameters(),
D2->getTemplateParameters()))
return false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
// Check the templated declaration.
return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
D2->getTemplatedDecl());
}
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
/// \brief Determine structural equivalence of two declarations.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
Decl *D1, Decl *D2) {
// FIXME: Check for known structural equivalences via a callback of some sort.
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// Check whether we already know that these two declarations are not
// structurally equivalent.
if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
D2->getCanonicalDecl())))
return false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
// Determine whether we've already produced a tentative equivalence for D1.
Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
if (EquivToD1)
return EquivToD1 == D2->getCanonicalDecl();
// Produce a tentative equivalence D1 <-> D2, which will be checked later.
EquivToD1 = D2->getCanonicalDecl();
Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
return true;
}
bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
Decl *D2) {
if (!::IsStructurallyEquivalent(*this, D1, D2))
return false;
return !Finish();
}
bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
QualType T2) {
if (!::IsStructurallyEquivalent(*this, T1, T2))
return false;
return !Finish();
}
bool StructuralEquivalenceContext::Finish() {
while (!DeclsToCheck.empty()) {
// Check the next declaration.
Decl *D1 = DeclsToCheck.front();
DeclsToCheck.pop_front();
Decl *D2 = TentativeEquivalences[D1];
assert(D2 && "Unrecorded tentative equivalence?");
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
bool Equivalent = true;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
// FIXME: Switch on all declaration kinds. For now, we're just going to
// check the obvious ones.
if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
// Check for equivalent structure names.
IdentifierInfo *Name1 = Record1->getIdentifier();
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (!Name1 && Record1->getTypedefNameForAnonDecl())
Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
IdentifierInfo *Name2 = Record2->getIdentifier();
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (!Name2 && Record2->getTypedefNameForAnonDecl())
Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (!::IsStructurallyEquivalent(Name1, Name2) ||
!::IsStructurallyEquivalent(*this, Record1, Record2))
Equivalent = false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
} else {
// Record/non-record mismatch.
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Equivalent = false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
} else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
// Check for equivalent enum names.
IdentifierInfo *Name1 = Enum1->getIdentifier();
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (!Name1 && Enum1->getTypedefNameForAnonDecl())
Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
IdentifierInfo *Name2 = Enum2->getIdentifier();
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (!Name2 && Enum2->getTypedefNameForAnonDecl())
Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (!::IsStructurallyEquivalent(Name1, Name2) ||
!::IsStructurallyEquivalent(*this, Enum1, Enum2))
Equivalent = false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
} else {
// Enum/non-enum mismatch
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Equivalent = false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
} else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Typedef2->getIdentifier()) ||
!::IsStructurallyEquivalent(*this,
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Typedef1->getUnderlyingType(),
Typedef2->getUnderlyingType()))
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Equivalent = false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
} else {
// Typedef/non-typedef mismatch.
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Equivalent = false;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
}
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
} else if (ClassTemplateDecl *ClassTemplate1
= dyn_cast<ClassTemplateDecl>(D1)) {
if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
ClassTemplate2->getIdentifier()) ||
!::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
Equivalent = false;
} else {
// Class template/non-class-template mismatch.
Equivalent = false;
}
} else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
Equivalent = false;
} else {
// Kind mismatch.
Equivalent = false;
}
} else if (NonTypeTemplateParmDecl *NTTP1
= dyn_cast<NonTypeTemplateParmDecl>(D1)) {
if (NonTypeTemplateParmDecl *NTTP2
= dyn_cast<NonTypeTemplateParmDecl>(D2)) {
if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
Equivalent = false;
} else {
// Kind mismatch.
Equivalent = false;
}
} else if (TemplateTemplateParmDecl *TTP1
= dyn_cast<TemplateTemplateParmDecl>(D1)) {
if (TemplateTemplateParmDecl *TTP2
= dyn_cast<TemplateTemplateParmDecl>(D2)) {
if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
Equivalent = false;
} else {
// Kind mismatch.
Equivalent = false;
}
}
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (!Equivalent) {
// Note that these two declarations are not equivalent (and we already
// know about it).
NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
D2->getCanonicalDecl()));
return true;
}
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
// FIXME: Check other declaration kinds!
}
return false;
}
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
2010-02-06 01:54:41 +08:00
//----------------------------------------------------------------------------
// Import Types
//----------------------------------------------------------------------------
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitType(const Type *T) {
Complain about types and declarations that we don't know how to import. llvm-svn: 95706
2010-02-10 06:48:33 +08:00
Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
<< T->getTypeClassName();
return QualType();
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
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
2010-02-06 01:54:41 +08:00
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;
The -fshort-wchar option causes wchar_t to become unsigned, in addition to being 16-bits in size. Implement this by splitting WChar into two enums, like we have for char. This fixes a miscompmilation of XULRunner, PR8856. llvm-svn: 122558
2010-12-26 07:25:43 +08:00
case BuiltinType::WChar_S:
case BuiltinType::WChar_U:
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
2010-02-06 01:54:41 +08:00
// 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;
Provide half floating point support as a storage only type. Lack of half FP was a regression compared to llvm-gcc. llvm-svn: 142016
2011-10-15 07:23:15 +08:00
case BuiltinType::Half: return Importer.getToContext().HalfTy;
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
2010-02-06 01:54:41 +08:00
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;
Basic, untested implementation for an "unknown any" type requested by LLDB. The idea is that you can create a VarDecl with an unknown type, or a FunctionDecl with an unknown return type, and it will still be valid to access that object as long as you explicitly cast it at every use. I'm still going back and forth about how I want to test this effectively, but I wanted to go ahead and provide a skeletal implementation for the LLDB folks' benefit and because it also improves some diagnostic goodness for placeholder expressions. llvm-svn: 129065
2011-04-07 16:22:57 +08:00
case BuiltinType::UnknownAny: return Importer.getToContext().UnknownAnyTy;
Make yet another placeholder type, this one marking that an expression is a bound member function, i.e. something of the form 'x.f' where 'f' is a non-static member function. Diagnose this in the general case. Some of the new diagnostics are probably worse than the old ones, but we now get this right much more universally, and there's certainly room for improvement in the diagnostics. llvm-svn: 130239
2011-04-27 04:42:42 +08:00
case BuiltinType::BoundMember: return Importer.getToContext().BoundMemberTy;
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
2010-02-06 01:54:41 +08:00
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();
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
return QualType();
return Importer.getToContext().getComplexType(ToElementType);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToPointeeType = Importer.Import(T->getPointeeType());
if (ToPointeeType.isNull())
return QualType();
return Importer.getToContext().getPointerType(ToPointeeType);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
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
2010-02-06 01:54:41 +08:00
// FIXME: Check for blocks support in "to" context.
QualType ToPointeeType = Importer.Import(T->getPointeeType());
if (ToPointeeType.isNull())
return QualType();
return Importer.getToContext().getBlockPointerType(ToPointeeType);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType
ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
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
2010-02-06 01:54:41 +08:00
// FIXME: Check for C++ support in "to" context.
QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
if (ToPointeeType.isNull())
return QualType();
return Importer.getToContext().getLValueReferenceType(ToPointeeType);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType
ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
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
2010-02-06 01:54:41 +08:00
// 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);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
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
2010-02-06 01:54:41 +08:00
// 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());
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
return QualType();
return Importer.getToContext().getConstantArrayType(ToElementType,
T->getSize(),
T->getSizeModifier(),
T->getIndexTypeCVRQualifiers());
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType
ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
return QualType();
return Importer.getToContext().getIncompleteArrayType(ToElementType,
T->getSizeModifier(),
T->getIndexTypeCVRQualifiers());
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
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
2010-02-06 01:54:41 +08:00
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);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
return QualType();
return Importer.getToContext().getVectorType(ToElementType,
T->getNumElements(),
Add a variant of GCC-style vector types for ARM NEON. NEON vector types need to be mangled in a special way to comply with ARM's ABI, similar to some of the AltiVec-specific vector types. This patch is mostly just renaming a bunch of "AltiVecSpecific" things, since they will no longer be specific to AltiVec. Besides that, it just adds the new "NeonVector" enum. llvm-svn: 118724
2010-11-11 05:56:12 +08:00
T->getVectorKind());
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
2010-02-06 01:54:41 +08:00
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
return QualType();
return Importer.getToContext().getExtVectorType(ToElementType,
T->getNumElements());
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType
ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
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
2010-02-06 01:54:41 +08:00
// 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();
the big refactoring bits of PR3782. This introduces FunctionType::ExtInfo to hold the calling convention and the noreturn attribute. The next patch will extend it to include the regparm attribute and fix the bug. llvm-svn: 99920
2010-03-31 04:24:48 +08:00
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
2010-02-06 01:54:41 +08:00
return Importer.getToContext().getFunctionNoProtoType(ToResultType,
the big refactoring bits of PR3782. This introduces FunctionType::ExtInfo to hold the calling convention and the noreturn attribute. The next patch will extend it to include the regparm attribute and fix the bug. llvm-svn: 99920
2010-03-31 04:24:48 +08:00
T->getExtInfo());
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
2010-02-06 01:54:41 +08:00
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToResultType = Importer.Import(T->getResultType());
if (ToResultType.isNull())
return QualType();
// Import argument types
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<QualType, 4> ArgTypes;
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
2010-02-06 01:54:41 +08:00
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
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<QualType, 4> ExceptionTypes;
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
2010-02-06 01:54:41 +08:00
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);
}
Restore r121752 without modification. llvm-svn: 121763
2010-12-14 16:05:40 +08:00
FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
EPI.Exceptions = ExceptionTypes.data();
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
2010-02-06 01:54:41 +08:00
return Importer.getToContext().getFunctionType(ToResultType, ArgTypes.data(),
Restore r121752 without modification. llvm-svn: 121763
2010-12-14 16:05:40 +08:00
ArgTypes.size(), EPI);
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
2010-02-06 01:54:41 +08:00
}
Extended the AST importer to support ParenTypes. This is necessary to support importing certain function pointer types. llvm-svn: 137311
2011-08-12 00:56:07 +08:00
QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
QualType ToInnerType = Importer.Import(T->getInnerType());
if (ToInnerType.isNull())
return QualType();
return Importer.getToContext().getParenType(ToInnerType);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
TypedefNameDecl *ToDecl
= dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
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
2010-02-06 01:54:41 +08:00
if (!ToDecl)
return QualType();
return Importer.getToContext().getTypeDeclType(ToDecl);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
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
2010-02-06 01:54:41 +08:00
Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
if (!ToExpr)
return QualType();
return Importer.getToContext().getTypeOfExprType(ToExpr);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
if (ToUnderlyingType.isNull())
return QualType();
return Importer.getToContext().getTypeOfType(ToUnderlyingType);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
// FIXME: Make sure that the "to" context supports C++0x!
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
2010-02-06 01:54:41 +08:00
Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
if (!ToExpr)
return QualType();
return Importer.getToContext().getDecltypeType(ToExpr);
}
Implement a new type node, UnaryTransformType, designed to represent a type that turns one type into another. This is used as the basis to implement __underlying_type properly - with TypeSourceInfo and proper behavior in the face of templates. llvm-svn: 132017
2011-05-25 06:41:36 +08:00
QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
QualType ToBaseType = Importer.Import(T->getBaseType());
QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
if (ToBaseType.isNull() || ToUnderlyingType.isNull())
return QualType();
return Importer.getToContext().getUnaryTransformType(ToBaseType,
ToUnderlyingType,
T->getUTTKind());
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
// FIXME: Make sure that the "to" context supports C++0x!
QualType FromDeduced = T->getDeducedType();
QualType ToDeduced;
if (!FromDeduced.isNull()) {
ToDeduced = Importer.Import(FromDeduced);
if (ToDeduced.isNull())
return QualType();
}
return Importer.getToContext().getAutoType(ToDeduced);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
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
2010-02-06 01:54:41 +08:00
RecordDecl *ToDecl
= dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
if (!ToDecl)
return QualType();
return Importer.getToContext().getTagDeclType(ToDecl);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
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
2010-02-06 01:54:41 +08:00
EnumDecl *ToDecl
= dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
if (!ToDecl)
return QualType();
return Importer.getToContext().getTagDeclType(ToDecl);
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
QualType ASTNodeImporter::VisitTemplateSpecializationType(
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
const TemplateSpecializationType *T) {
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
TemplateName ToTemplate = Importer.Import(T->getTemplateName());
if (ToTemplate.isNull())
return QualType();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 2> ToTemplateArgs;
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
return QualType();
QualType ToCanonType;
if (!QualType(T, 0).isCanonical()) {
QualType FromCanonType
= Importer.getFromContext().getCanonicalType(QualType(T, 0));
ToCanonType =Importer.Import(FromCanonType);
if (ToCanonType.isNull())
return QualType();
}
return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
ToTemplateArgs.data(),
ToTemplateArgs.size(),
ToCanonType);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
NestedNameSpecifier *ToQualifier = 0;
// Note: the qualifier in an ElaboratedType is optional.
if (T->getQualifier()) {
ToQualifier = Importer.Import(T->getQualifier());
if (!ToQualifier)
return QualType();
}
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
2010-02-06 01:54:41 +08:00
QualType ToNamedType = Importer.Import(T->getNamedType());
if (ToNamedType.isNull())
return QualType();
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
return Importer.getToContext().getElaboratedType(T->getKeyword(),
ToQualifier, ToNamedType);
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
2010-02-06 01:54:41 +08:00
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
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
2010-02-06 01:54:41 +08:00
ObjCInterfaceDecl *Class
= dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
if (!Class)
return QualType();
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
return Importer.getToContext().getObjCInterfaceType(Class);
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
QualType ToBaseType = Importer.Import(T->getBaseType());
if (ToBaseType.isNull())
return QualType();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ObjCProtocolDecl *, 4> Protocols;
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
for (ObjCObjectType::qual_iterator P = T->qual_begin(),
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
2010-02-06 01:54:41 +08:00
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);
}
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
return Importer.getToContext().getObjCObjectType(ToBaseType,
Protocols.data(),
Protocols.size());
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
2010-02-06 01:54:41 +08:00
}
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType
ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
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
2010-02-06 01:54:41 +08:00
QualType ToPointeeType = Importer.Import(T->getPointeeType());
if (ToPointeeType.isNull())
return QualType();
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
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
2010-02-06 01:54:41 +08:00
}
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
//----------------------------------------------------------------------------
// Import Declarations
//----------------------------------------------------------------------------
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
DeclContext *&LexicalDC,
DeclarationName &Name,
SourceLocation &Loc) {
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// Import the context of this declaration.
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
DC = Importer.ImportContext(D->getDeclContext());
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
if (!DC)
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
return true;
LexicalDC = DC;
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
if (D->getDeclContext() != D->getLexicalDeclContext()) {
LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
if (!LexicalDC)
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
return true;
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
}
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// Import the name of this declaration.
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Name = Importer.Import(D->getDeclName());
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
if (D->getDeclName() && !Name)
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
return true;
// Import the location of this declaration.
Loc = Importer.Import(D->getLocation());
return false;
}
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
if (!FromD)
return;
if (!ToD) {
ToD = Importer.Import(FromD);
if (!ToD)
return;
}
if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
if (FromRecord->getDefinition() && !ToRecord->getDefinition()) {
ImportDefinition(FromRecord, ToRecord);
}
}
return;
}
if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
ImportDefinition(FromEnum, ToEnum);
}
}
return;
}
}
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
void
ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
DeclarationNameInfo& To) {
// NOTE: To.Name and To.Loc are already imported.
// We only have to import To.LocInfo.
switch (To.getName().getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXUsingDirective:
return;
case DeclarationName::CXXOperatorName: {
SourceRange Range = From.getCXXOperatorNameRange();
To.setCXXOperatorNameRange(Importer.Import(Range));
return;
}
case DeclarationName::CXXLiteralOperatorName: {
SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
return;
}
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName: {
TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
To.setNamedTypeInfo(Importer.Import(FromTInfo));
return;
}
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Unknown name kind.");
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
}
}
Introduce the notion of a "minimal" import of ASTs, to better support LLDB. llvm-svn: 123723
2011-01-18 11:11:38 +08:00
void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
if (Importer.isMinimalImport() && !ForceImport) {
This patch (thanks to Doug Gregor) fixes a problem where Clang was setting the hasExternalVisibleDecls() bit for all DeclContexts it imported. This caused Clang to make unnecessary calls to findExternalVisibleDecls() when an external AST source was installed. In fact, Clang sometimes interpreted a failure by one of these spurious calls to find a Decl as meaning the Decl didn't exist, even though findExternalLexicalDecls() did locate that decl. This produced amusing errors of the form: - error: no member named 'b' in 'A'; did you mean 'b'? - Now, if hasExternalVisibleDecls() or hasExternalLexicalDecls() should be set, the external AST source must do so itself. llvm-svn: 135824
2011-07-23 07:46:03 +08:00
Importer.ImportContext(FromDC);
Introduce the notion of a "minimal" import of ASTs, to better support LLDB. llvm-svn: 123723
2011-01-18 11:11:38 +08:00
return;
}
Collect the code that imports all of the members of a declaration context into a single function, ImportDeclContext. Use it rather than explicit loops. No functionality change. llvm-svn: 96739
2010-02-22 02:24:45 +08:00
for (DeclContext::decl_iterator From = FromDC->decls_begin(),
FromEnd = FromDC->decls_end();
From != FromEnd;
++From)
Importer.Import(*From);
}
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
bool ForceImport) {
if (To->getDefinition() || To->isBeingDefined())
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
return false;
To->startDefinition();
// Add base classes.
if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<CXXBaseSpecifier *, 4> Bases;
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
for (CXXRecordDecl::base_class_iterator
Base1 = FromCXX->bases_begin(),
FromBaseEnd = FromCXX->bases_end();
Base1 != FromBaseEnd;
++Base1) {
QualType T = Importer.Import(Base1->getType());
if (T.isNull())
Fix inverted return value in the ASTImporter. No matter how much LLVM code I wrote, returning "true" on error is still unnatural. llvm-svn: 120727
2010-12-03 03:33:37 +08:00
return true;
Implement pack expansions whose pattern is a base-specifier. llvm-svn: 122782
2011-01-04 06:36:02 +08:00
SourceLocation EllipsisLoc;
if (Base1->isPackExpansion())
EllipsisLoc = Importer.Import(Base1->getEllipsisLoc());
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
// Ensure that we have a definition for the base.
ImportDefinitionIfNeeded(Base1->getType()->getAsCXXRecordDecl());
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
Bases.push_back(
new (Importer.getToContext())
CXXBaseSpecifier(Importer.Import(Base1->getSourceRange()),
Base1->isVirtual(),
Base1->isBaseOfClass(),
Base1->getAccessSpecifierAsWritten(),
Implement pack expansions whose pattern is a base-specifier. llvm-svn: 122782
2011-01-04 06:36:02 +08:00
Importer.Import(Base1->getTypeSourceInfo()),
EllipsisLoc));
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
}
if (!Bases.empty())
ToCXX->setBases(Bases.data(), Bases.size());
}
This fix (thanks to Doug Gregor) corrects a bug in ImportDefinition when replacing a previously forward-declared CXXRecordDecl with its full definition. The forward-declared type's DefinitionData had not been intialized for the forward-declared type, so adding fields to the Decl caused CXXRecordDecl::addedMember() to crash when accessing the DefinitionData. llvm-svn: 135530
2011-07-20 06:38:25 +08:00
ImportDeclContext(From, ForceImport);
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
To->completeDefinition();
Fix inverted return value in the ASTImporter. No matter how much LLVM code I wrote, returning "true" on error is still unnatural. llvm-svn: 120727
2010-12-03 03:33:37 +08:00
return false;
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
}
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
bool ForceImport) {
if (To->getDefinition() || To->isBeingDefined())
return false;
To->startDefinition();
QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
if (T.isNull())
return true;
QualType ToPromotionType = Importer.Import(From->getPromotionType());
if (ToPromotionType.isNull())
return true;
ImportDeclContext(From, ForceImport);
// FIXME: we might need to merge the number of positive or negative bits
// if the enumerator lists don't match.
To->completeDefinition(T, ToPromotionType,
From->getNumPositiveBits(),
From->getNumNegativeBits());
return false;
}
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
TemplateParameterList *Params) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ToParams;
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
ToParams.reserve(Params->size());
for (TemplateParameterList::iterator P = Params->begin(),
PEnd = Params->end();
P != PEnd; ++P) {
Decl *To = Importer.Import(*P);
if (!To)
return 0;
ToParams.push_back(cast<NamedDecl>(To));
}
return TemplateParameterList::Create(Importer.getToContext(),
Importer.Import(Params->getTemplateLoc()),
Importer.Import(Params->getLAngleLoc()),
ToParams.data(), ToParams.size(),
Importer.Import(Params->getRAngleLoc()));
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
TemplateArgument
ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
switch (From.getKind()) {
case TemplateArgument::Null:
return TemplateArgument();
case TemplateArgument::Type: {
QualType ToType = Importer.Import(From.getAsType());
if (ToType.isNull())
return TemplateArgument();
return TemplateArgument(ToType);
}
case TemplateArgument::Integral: {
QualType ToType = Importer.Import(From.getIntegralType());
if (ToType.isNull())
return TemplateArgument();
return TemplateArgument(*From.getAsIntegral(), ToType);
}
case TemplateArgument::Declaration:
if (Decl *To = Importer.Import(From.getAsDecl()))
return TemplateArgument(To);
return TemplateArgument();
case TemplateArgument::Template: {
TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
if (ToTemplate.isNull())
return TemplateArgument();
return TemplateArgument(ToTemplate);
}
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
case TemplateArgument::TemplateExpansion: {
TemplateName ToTemplate
= Importer.Import(From.getAsTemplateOrTemplatePattern());
if (ToTemplate.isNull())
return TemplateArgument();
Teach template template argument pack expansions to keep track of the number of expansions, when we know it, and propagate that information through Sema. llvm-svn: 123493
2011-01-15 07:41:42 +08:00
return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
case TemplateArgument::Expression:
if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
return TemplateArgument(ToExpr);
return TemplateArgument();
case TemplateArgument::Pack: {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 2> ToPack;
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
ToPack.reserve(From.pack_size());
if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
return TemplateArgument();
TemplateArgument *ToArgs
= new (Importer.getToContext()) TemplateArgument[ToPack.size()];
std::copy(ToPack.begin(), ToPack.end(), ToArgs);
return TemplateArgument(ToArgs, ToPack.size());
}
}
llvm_unreachable("Invalid template argument kind");
return TemplateArgument();
}
bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
unsigned NumFromArgs,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<TemplateArgument> &ToArgs) {
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
for (unsigned I = 0; I != NumFromArgs; ++I) {
TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
if (To.isNull() && !FromArgs[I].isNull())
return true;
ToArgs.push_back(To);
}
return false;
}
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
RecordDecl *ToRecord) {
Try to fix the auroraux buildbot. I suspect it has a "#define SEC" somewhere. llvm-svn: 96577
2010-02-18 21:02:13 +08:00
StructuralEquivalenceContext Ctx(Importer.getFromContext(),
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Importer.getToContext(),
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Importer.getNonEquivalentDecls());
Try to fix the auroraux buildbot. I suspect it has a "#define SEC" somewhere. llvm-svn: 96577
2010-02-18 21:02:13 +08:00
return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
}
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
Try to fix the auroraux buildbot. I suspect it has a "#define SEC" somewhere. llvm-svn: 96577
2010-02-18 21:02:13 +08:00
StructuralEquivalenceContext Ctx(Importer.getFromContext(),
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Importer.getToContext(),
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Importer.getNonEquivalentDecls());
Try to fix the auroraux buildbot. I suspect it has a "#define SEC" somewhere. llvm-svn: 96577
2010-02-18 21:02:13 +08:00
return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
}
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
ClassTemplateDecl *To) {
StructuralEquivalenceContext Ctx(Importer.getFromContext(),
Importer.getToContext(),
Importer.getNonEquivalentDecls());
return Ctx.IsStructurallyEquivalent(From, To);
}
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Decl *ASTNodeImporter::VisitDecl(Decl *D) {
Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
<< D->getDeclKindName();
return 0;
}
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
// Import the major distinguishing characteristics of this namespace.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
NamespaceDecl *MergeWithNamespace = 0;
if (!Name) {
// This is an anonymous namespace. Adopt an existing anonymous
// namespace if we can.
// FIXME: Not testable.
if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
MergeWithNamespace = TU->getAnonymousNamespace();
else
MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
} else {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
MergeWithNamespace = FoundNS;
ConflictingDecls.clear();
break;
}
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
}
if (!ConflictingDecls.empty()) {
Recommit my change to how C++ does elaborated type lookups, now with two bugfixes which fix selfhost and (hopefully) the nightly tests. llvm-svn: 102198
2010-04-24 02:46:30 +08:00
Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
ConflictingDecls.data(),
ConflictingDecls.size());
}
}
// Create the "to" namespace, if needed.
NamespaceDecl *ToNamespace = MergeWithNamespace;
if (!ToNamespace) {
Fixed NamespaceDecl source range. llvm-svn: 127242
2011-03-08 20:38:20 +08:00
ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
Importer.Import(D->getLocStart()),
Loc, Name.getAsIdentifierInfo());
Implement AST importing for C++ namespaces. llvm-svn: 96740
2010-02-22 02:26:36 +08:00
ToNamespace->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(ToNamespace);
// If this is an anonymous namespace, register it as the anonymous
// namespace within its context.
if (!Name) {
if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
TU->setAnonymousNamespace(ToNamespace);
else
cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
}
}
Importer.Imported(D, ToNamespace);
ImportDeclContext(D);
return ToNamespace;
}
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
// Import the major distinguishing characteristics of this typedef.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
// If this typedef is not in block scope, determine whether we've
// seen a typedef with the same name (that we can merge with) or any
// other entity by that name (which name lookup could conflict with).
if (!DC->isFunctionOrMethod()) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
unsigned IDNS = Decl::IDNS_Ordinary;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
continue;
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (TypedefNameDecl *FoundTypedef =
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
FoundTypedef->getUnderlyingType()))
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
return Importer.Imported(D, FoundTypedef);
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
}
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
}
if (!ConflictingDecls.empty()) {
Name = Importer.HandleNameConflict(Name, DC, IDNS,
ConflictingDecls.data(),
ConflictingDecls.size());
if (!Name)
return 0;
}
}
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// Import the underlying type of this typedef;
QualType T = Importer.Import(D->getUnderlyingType());
if (T.isNull())
return 0;
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
// Create the new typedef node.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Fixed TypedefDecl and TemplateTypeParameter source range. llvm-svn: 127119
2011-03-06 23:48:19 +08:00
SourceLocation StartL = Importer.Import(D->getLocStart());
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
TypedefNameDecl *ToTypedef;
if (IsAlias)
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
StartL, Loc,
Name.getAsIdentifierInfo(),
TInfo);
else
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
StartL, Loc,
Name.getAsIdentifierInfo(),
TInfo);
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
Set access specifiers on imported declarations. llvm-svn: 96788
2010-02-23 01:42:47 +08:00
ToTypedef->setAccess(D->getAccess());
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
ToTypedef->setLexicalDeclContext(LexicalDC);
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
Importer.Imported(D, ToTypedef);
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
LexicalDC->addDecl(ToTypedef);
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Move TypedefDecl importer to match the ordering in DeclNodes. No functionality change. llvm-svn: 95805
2010-02-11 05:10:29 +08:00
return ToTypedef;
}
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
return VisitTypedefNameDecl(D, /*IsAlias=*/false);
}
Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
return VisitTypedefNameDecl(D, /*IsAlias=*/true);
}
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
// Import the major distinguishing characteristics of this enum.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
// Figure out what enum name we're looking for.
unsigned IDNS = Decl::IDNS_Tag;
DeclarationName SearchName = Name;
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (!SearchName && D->getTypedefNameForAnonDecl()) {
SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
IDNS = Decl::IDNS_Ordinary;
} else if (Importer.getToContext().getLangOptions().CPlusPlus)
IDNS |= Decl::IDNS_Ordinary;
// We may already have an enum of the same name; try to find and match it.
if (!DC->isFunctionOrMethod() && SearchName) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(SearchName, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
Decl *Found = FoundDecls[I];
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
Found = Tag->getDecl();
}
if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
if (IsStructuralMatch(D, FoundEnum))
return Importer.Imported(D, FoundEnum);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
}
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
}
if (!ConflictingDecls.empty()) {
Name = Importer.HandleNameConflict(Name, DC, IDNS,
ConflictingDecls.data(),
ConflictingDecls.size());
}
}
// Create the enum declaration.
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
Importer.Import(D->getLocStart()),
Loc, Name.getAsIdentifierInfo(), 0,
Added struct/class syntactic info for c++0x scoped enum. llvm-svn: 120828
2010-12-04 02:54:17 +08:00
D->isScoped(), D->isScopedUsingClassTag(),
D->isFixed());
Remember declaration scope qualifiers in the AST. Imposes no memory overhead on unqualified declarations. Patch by Enea Zaffanella! Minimal adjustments: allocate the ExtInfo nodes with the ASTContext and delete them during Destroy(). I audited a bunch of Destroy methods at the same time, to ensure that the correct teardown was being done. llvm-svn: 98540
2010-03-15 18:12:16 +08:00
// Import the qualifier, if any.
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Set access specifiers on imported declarations. llvm-svn: 96788
2010-02-23 01:42:47 +08:00
D2->setAccess(D->getAccess());
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
D2->setLexicalDeclContext(LexicalDC);
Importer.Imported(D, D2);
LexicalDC->addDecl(D2);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
// Import the integer type.
QualType ToIntegerType = Importer.Import(D->getIntegerType());
if (ToIntegerType.isNull())
return 0;
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
D2->setIntegerType(ToIntegerType);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
// Import the definition
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
if (D->isCompleteDefinition() && ImportDefinition(D, D2))
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
return 0;
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return D2;
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
}
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
// If this record has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
Eliminate the ASTContext parameter from RecordDecl::getDefinition() and CXXRecordDecl::getDefinition(); it's totally unnecessary. No functionality change. llvm-svn: 95836
2010-02-11 09:04:33 +08:00
TagDecl *Definition = D->getDefinition();
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
if (Definition && Definition != D) {
Decl *ImportedDef = Importer.Import(Definition);
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
if (!ImportedDef)
return 0;
return Importer.Imported(D, ImportedDef);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
}
// Import the major distinguishing characteristics of this record.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
// Figure out what structure name we're looking for.
unsigned IDNS = Decl::IDNS_Tag;
DeclarationName SearchName = Name;
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (!SearchName && D->getTypedefNameForAnonDecl()) {
SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
IDNS = Decl::IDNS_Ordinary;
} else if (Importer.getToContext().getLangOptions().CPlusPlus)
IDNS |= Decl::IDNS_Ordinary;
// We may already have a record of the same name; try to find and match it.
Handle AST merges of incomplete class types. llvm-svn: 95941
2010-02-12 08:09:27 +08:00
RecordDecl *AdoptDecl = 0;
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
if (!DC->isFunctionOrMethod() && SearchName) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(SearchName, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
Decl *Found = FoundDecls[I];
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
Found = Tag->getDecl();
}
if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
Handle AST merges of incomplete class types. llvm-svn: 95941
2010-02-12 08:09:27 +08:00
if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
Handle AST merges of incomplete class types. llvm-svn: 95941
2010-02-12 08:09:27 +08:00
// The record types structurally match, or the "from" translation
// unit only had a forward declaration anyway; call it the same
// function.
// FIXME: For C++, we should also merge methods here.
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
return Importer.Imported(D, FoundDef);
Handle AST merges of incomplete class types. llvm-svn: 95941
2010-02-12 08:09:27 +08:00
}
} else {
// We have a forward declaration of this type, so adopt that forward
// declaration rather than building a new one.
AdoptDecl = FoundRecord;
continue;
}
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
}
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
}
if (!ConflictingDecls.empty()) {
Name = Importer.HandleNameConflict(Name, DC, IDNS,
ConflictingDecls.data(),
ConflictingDecls.size());
}
}
// Create the record declaration.
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
RecordDecl *D2 = AdoptDecl;
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
SourceLocation StartLoc = Importer.Import(D->getLocStart());
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
if (!D2) {
Hack in some really terrible C++ record PCH support that I need right now. This is required in order to test: The ASTImporter should set base classes after formally entering the definition. llvm-svn: 105401
2010-06-04 03:28:45 +08:00
if (isa<CXXRecordDecl>(D)) {
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
Handle AST merges of incomplete class types. llvm-svn: 95941
2010-02-12 08:09:27 +08:00
D->getTagKind(),
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
DC, StartLoc, Loc,
Name.getAsIdentifierInfo());
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
D2 = D2CXX;
Set access specifiers on imported declarations. llvm-svn: 96788
2010-02-23 01:42:47 +08:00
D2->setAccess(D->getAccess());
Handle AST merges of incomplete class types. llvm-svn: 95941
2010-02-12 08:09:27 +08:00
} else {
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
DC, StartLoc, Loc, Name.getAsIdentifierInfo());
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
}
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
D2->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(D2);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
}
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
Importer.Imported(D, D2);
Handle AST merges of incomplete class types. llvm-svn: 95941
2010-02-12 08:09:27 +08:00
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
if (D->isCompleteDefinition() && ImportDefinition(D, D2))
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
return 0;
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
Reimplement the structural-equality checks used to determine whether two types in different AST contexts are equivalent. Rather than transforming the type from one context into the other context, we perform a deep structural comparison of the types. This change addresses a serious problem with recursive data types like struct ListNode { int value; struct ListNode *Next; } xList; llvm-svn: 96278
2010-02-16 06:01:00 +08:00
return D2;
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
}
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
// Import the major distinguishing characteristics of this enumerator.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
return 0;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
// Determine whether there are any other declarations with the same name and
// in the same context.
if (!LexicalDC->isFunctionOrMethod()) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
unsigned IDNS = Decl::IDNS_Ordinary;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
}
if (!ConflictingDecls.empty()) {
Name = Importer.HandleNameConflict(Name, DC, IDNS,
ConflictingDecls.data(),
ConflictingDecls.size());
if (!Name)
return 0;
}
}
Expr *Init = Importer.Import(D->getInitExpr());
if (D->getInitExpr() && !Init)
return 0;
EnumConstantDecl *ToEnumerator
= EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
Name.getAsIdentifierInfo(), T,
Init, D->getInitVal());
Set access specifiers on imported declarations. llvm-svn: 96788
2010-02-23 01:42:47 +08:00
ToEnumerator->setAccess(D->getAccess());
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
ToEnumerator->setLexicalDeclContext(LexicalDC);
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
Importer.Imported(D, ToEnumerator);
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
LexicalDC->addDecl(ToEnumerator);
return ToEnumerator;
}
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
// Import the major distinguishing characteristics of this function.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
return 0;
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
// Try to find a function in our own ("to") context with the same name, same
// type, and in the same context as the function we're importing.
if (!LexicalDC->isFunctionOrMethod()) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
unsigned IDNS = Decl::IDNS_Ordinary;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
if (isExternalLinkage(FoundFunction->getLinkage()) &&
isExternalLinkage(D->getLinkage())) {
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (Importer.IsStructurallyEquivalent(D->getType(),
FoundFunction->getType())) {
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
// FIXME: Actually try to merge the body and other attributes.
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
return Importer.Imported(D, FoundFunction);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
}
// FIXME: Check for overloading more carefully, e.g., by boosting
// Sema::IsOverload out to the AST library.
// Function overloading is okay in C++.
if (Importer.getToContext().getLangOptions().CPlusPlus)
continue;
// Complain about inconsistent function types.
Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
<< Name << D->getType() << FoundFunction->getType();
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Importer.ToDiag(FoundFunction->getLocation(),
diag::note_odr_value_here)
<< FoundFunction->getType();
}
}
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
}
if (!ConflictingDecls.empty()) {
Name = Importer.HandleNameConflict(Name, DC, IDNS,
ConflictingDecls.data(),
ConflictingDecls.size());
if (!Name)
return 0;
}
}
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
DeclarationNameInfo NameInfo(Name, Loc);
// Import additional name location/type info.
ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
// Import the function parameters.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 8> Parameters;
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
P != PEnd; ++P) {
ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*P));
if (!ToP)
return 0;
Parameters.push_back(ToP);
}
// Create the imported function.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
FunctionDecl *ToFunction = 0;
if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
cast<CXXRecordDecl>(DC),
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
D->getInnerLocStart(),
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
NameInfo, T, TInfo,
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
FromConstructor->isExplicit(),
D->isInlineSpecified(),
Track in the AST whether a function is constexpr. llvm-svn: 137653
2011-08-16 05:04:07 +08:00
D->isImplicit(),
D->isConstexpr());
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
} else if (isa<CXXDestructorDecl>(D)) {
ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
cast<CXXRecordDecl>(DC),
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
D->getInnerLocStart(),
Pass TInfo to CXXDestructorDecl::Create(), just like we do for other function decls. Reviewed by rjmccall and nlewycky. llvm-svn: 116979
2010-10-21 08:44:50 +08:00
NameInfo, T, TInfo,
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
D->isInlineSpecified(),
D->isImplicit());
} else if (CXXConversionDecl *FromConversion
= dyn_cast<CXXConversionDecl>(D)) {
ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
cast<CXXRecordDecl>(DC),
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
D->getInnerLocStart(),
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
NameInfo, T, TInfo,
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
D->isInlineSpecified(),
Teach libclang's token-annotation logic about context-sensitive keywords for Objective-C+ and C++0x. llvm-svn: 127253
2011-03-09 01:10:18 +08:00
FromConversion->isExplicit(),
Track in the AST whether a function is constexpr. llvm-svn: 137653
2011-08-16 05:04:07 +08:00
D->isConstexpr(),
Teach libclang's token-annotation logic about context-sensitive keywords for Objective-C+ and C++0x. llvm-svn: 127253
2011-03-09 01:10:18 +08:00
Importer.Import(D->getLocEnd()));
Teach the ASTImporter how to create CXXMethodDecls. Somehow, this case was missed previously llvm-svn: 120289
2010-11-30 00:04:58 +08:00
} else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
cast<CXXRecordDecl>(DC),
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
D->getInnerLocStart(),
Teach the ASTImporter how to create CXXMethodDecls. Somehow, this case was missed previously llvm-svn: 120289
2010-11-30 00:04:58 +08:00
NameInfo, T, TInfo,
Method->isStatic(),
Method->getStorageClassAsWritten(),
Teach libclang's token-annotation logic about context-sensitive keywords for Objective-C+ and C++0x. llvm-svn: 127253
2011-03-09 01:10:18 +08:00
Method->isInlineSpecified(),
Track in the AST whether a function is constexpr. llvm-svn: 137653
2011-08-16 05:04:07 +08:00
D->isConstexpr(),
Teach libclang's token-annotation logic about context-sensitive keywords for Objective-C+ and C++0x. llvm-svn: 127253
2011-03-09 01:10:18 +08:00
Importer.Import(D->getLocEnd()));
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
} else {
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
D->getInnerLocStart(),
Added locations and type source info for DeclarationName. llvm-svn: 110860
2010-08-12 06:01:17 +08:00
NameInfo, T, TInfo, D->getStorageClass(),
Keep track of the actual storage specifier written on a variable or function declaration, since it may end up being changed (e.g., "extern" can become "static" if a prior declaration was static). Patch by Enea Zaffanella and Paolo Bolzoni. llvm-svn: 101826
2010-04-20 06:54:31 +08:00
D->getStorageClassAsWritten(),
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
D->isInlineSpecified(),
Track in the AST whether a function is constexpr. llvm-svn: 137653
2011-08-16 05:04:07 +08:00
D->hasWrittenPrototype(),
D->isConstexpr());
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
}
Remember declaration scope qualifiers in the AST. Imposes no memory overhead on unqualified declarations. Patch by Enea Zaffanella! Minimal adjustments: allocate the ExtInfo nodes with the ASTContext and delete them during Destroy(). I audited a bunch of Destroy methods at the same time, to ensure that the correct teardown was being done. llvm-svn: 98540
2010-03-15 18:12:16 +08:00
// Import the qualifier, if any.
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Set access specifiers on imported declarations. llvm-svn: 96788
2010-02-23 01:42:47 +08:00
ToFunction->setAccess(D->getAccess());
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
ToFunction->setLexicalDeclContext(LexicalDC);
Import three interesting bits that apply only to C++ methods. llvm-svn: 124349
2011-01-27 10:37:01 +08:00
ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
ToFunction->setTrivial(D->isTrivial());
ToFunction->setPure(D->isPure());
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
Importer.Imported(D, ToFunction);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
// Set the parameters.
for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
Parameters[I]->setOwningFunction(ToFunction);
ToFunction->addDecl(Parameters[I]);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
}
ArrayRef-ifying Function/BlockDecl's setParams llvm-svn: 140268
2011-09-22 02:16:56 +08:00
ToFunction->setParams(Parameters);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
// FIXME: Other bits to merge?
Don't add an imported function into its lexical context until *after* we've set all of its parameters. Fixes <rdar://problem/8499598>; thanks to Sean for the diagnosis. llvm-svn: 115387
2010-10-02 07:55:07 +08:00
// Add this function to the lexical context.
LexicalDC->addDecl(ToFunction);
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
return ToFunction;
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
}
Implement AST import for C++ member functions, including constructors, destructors, and conversions. Unfortunately, this cannot be tested yet, since we don't have C++ PCH support. llvm-svn: 96741
2010-02-22 02:29:16 +08:00
Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
return VisitFunctionDecl(D);
}
Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
return VisitCXXMethodDecl(D);
}
Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
return VisitCXXMethodDecl(D);
}
Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
return VisitCXXMethodDecl(D);
}
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
// Determine whether we've already imported this field.
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
if (Importer.IsStructurallyEquivalent(D->getType(),
FoundField->getType())) {
Importer.Imported(D, FoundField);
return FoundField;
}
Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
<< Name << D->getType() << FoundField->getType();
Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
<< FoundField->getType();
return 0;
}
}
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
return 0;
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Expr *BitWidth = Importer.Import(D->getBitWidth());
if (!BitWidth && D->getBitWidth())
return 0;
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
Importer.Import(D->getInnerLocStart()),
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
Loc, Name.getAsIdentifierInfo(),
Implement support for C++11 in-class initialization of non-static data members. llvm-svn: 132878
2011-06-12 01:19:42 +08:00
T, TInfo, BitWidth, D->isMutable(),
D->hasInClassInitializer());
Set access specifiers on imported declarations. llvm-svn: 96788
2010-02-23 01:42:47 +08:00
ToField->setAccess(D->getAccess());
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
ToField->setLexicalDeclContext(LexicalDC);
Implement support for C++11 in-class initialization of non-static data members. llvm-svn: 132878
2011-06-12 01:19:42 +08:00
if (ToField->hasInClassInitializer())
ToField->setInClassInitializer(D->getInClassInitializer());
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
Importer.Imported(D, ToField);
Implement basic AST merging for classes, structs, and unions in C. llvm-svn: 95833
2010-02-11 08:48:18 +08:00
LexicalDC->addDecl(ToField);
return ToField;
}
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
// Determine whether we've already imported this field.
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
if (IndirectFieldDecl *FoundField
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
= dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
Teach the ASTImporter not to import redundant fields. llvm-svn: 142009
2011-10-15 05:54:42 +08:00
if (Importer.IsStructurallyEquivalent(D->getType(),
FoundField->getType())) {
Importer.Imported(D, FoundField);
return FoundField;
}
Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
<< Name << D->getType() << FoundField->getType();
Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
<< FoundField->getType();
return 0;
}
}
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
NamedDecl **NamedChain =
new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
unsigned i = 0;
for (IndirectFieldDecl::chain_iterator PI = D->chain_begin(),
PE = D->chain_end(); PI != PE; ++PI) {
Decl* D = Importer.Import(*PI);
if (!D)
return 0;
NamedChain[i++] = cast<NamedDecl>(D);
}
IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
Importer.getToContext(), DC,
Loc, Name.getAsIdentifierInfo(), T,
NamedChain, D->getChainingSize());
ToIndirectField->setAccess(D->getAccess());
ToIndirectField->setLexicalDeclContext(LexicalDC);
Importer.Imported(D, ToIndirectField);
LexicalDC->addDecl(ToIndirectField);
return ToIndirectField;
}
Implement AST importing of Objective-C instance variables. Check superclasses when merging two Objective-C @interfaces. llvm-svn: 96420
2010-02-17 08:34:30 +08:00
Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
// Import the major distinguishing characteristics of an ivar.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
// Determine whether we've already imported this ivar
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
Implement AST importing of Objective-C instance variables. Check superclasses when merging two Objective-C @interfaces. llvm-svn: 96420
2010-02-17 08:34:30 +08:00
if (Importer.IsStructurallyEquivalent(D->getType(),
FoundIvar->getType())) {
Importer.Imported(D, FoundIvar);
return FoundIvar;
}
Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
<< Name << D->getType() << FoundIvar->getType();
Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
<< FoundIvar->getType();
return 0;
}
}
// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Expr *BitWidth = Importer.Import(D->getBitWidth());
if (!BitWidth && D->getBitWidth())
return 0;
Sema/Obj-C: Narrow type of ObjCIvarDecl::Create, and check additional invariants on the provided DeclContext. - Doug, please see the FIXME in DeclObjC.cpp -- I am not sure what the right fix is. llvm-svn: 100213
2010-04-03 04:10:03 +08:00
ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
cast<ObjCContainerDecl>(DC),
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Importer.Import(D->getInnerLocStart()),
Implement AST importing of Objective-C instance variables. Check superclasses when merging two Objective-C @interfaces. llvm-svn: 96420
2010-02-17 08:34:30 +08:00
Loc, Name.getAsIdentifierInfo(),
T, TInfo, D->getAccessControl(),
Added PCH/ASTImporter code for ObjCIvarDecl's field. llvm-svn: 108627
2010-07-18 02:35:47 +08:00
BitWidth, D->getSynthesize());
Implement AST importing of Objective-C instance variables. Check superclasses when merging two Objective-C @interfaces. llvm-svn: 96420
2010-02-17 08:34:30 +08:00
ToIvar->setLexicalDeclContext(LexicalDC);
Importer.Imported(D, ToIvar);
LexicalDC->addDecl(ToIvar);
return ToIvar;
}
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
return 0;
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// Try to find a variable in our own ("to") context with the same name and
// in the same context as the variable we're importing.
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
if (D->isFileVarDecl()) {
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
VarDecl *MergeWithVar = 0;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
unsigned IDNS = Decl::IDNS_Ordinary;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// We have found a variable that we may need to merge with. Check it.
if (isExternalLinkage(FoundVar->getLinkage()) &&
isExternalLinkage(D->getLinkage())) {
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (Importer.IsStructurallyEquivalent(D->getType(),
FoundVar->getType())) {
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
MergeWithVar = FoundVar;
break;
}
Simplify incomplete-array merging code in the AST importer, thanks to Daniel's suggestion. llvm-svn: 95987
2010-02-13 01:23:39 +08:00
const ArrayType *FoundArray
= Importer.getToContext().getAsArrayType(FoundVar->getType());
const ArrayType *TArray
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
= Importer.getToContext().getAsArrayType(D->getType());
Simplify incomplete-array merging code in the AST importer, thanks to Daniel's suggestion. llvm-svn: 95987
2010-02-13 01:23:39 +08:00
if (FoundArray && TArray) {
if (isa<IncompleteArrayType>(FoundArray) &&
isa<ConstantArrayType>(TArray)) {
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
Simplify incomplete-array merging code in the AST importer, thanks to Daniel's suggestion. llvm-svn: 95987
2010-02-13 01:23:39 +08:00
FoundVar->setType(T);
MergeWithVar = FoundVar;
break;
} else if (isa<IncompleteArrayType>(TArray) &&
isa<ConstantArrayType>(FoundArray)) {
MergeWithVar = FoundVar;
break;
Teach AST merging that variables with incomplete array types can be merged with variables of constant array types. Also, make sure that we call DiagnosticClient's BeginSourceFile/EndSourceFile, so that it has a LangOptions to work with. llvm-svn: 95782
2010-02-11 01:16:49 +08:00
}
}
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
<< Name << D->getType() << FoundVar->getType();
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
<< FoundVar->getType();
}
}
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
}
if (MergeWithVar) {
// An equivalent variable with external linkage has been found. Link
// the two declarations, then merge them.
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
Importer.Imported(D, MergeWithVar);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
if (VarDecl *DDef = D->getDefinition()) {
if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
Importer.ToDiag(ExistingDef->getLocation(),
diag::err_odr_variable_multiple_def)
<< Name;
Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
} else {
Expr *Init = Importer.Import(DDef->getInit());
Eliminate a bunch of unnecessary ASTContexts from members functions of Decl subclasses. No functionality change. llvm-svn: 95841
2010-02-11 09:19:42 +08:00
MergeWithVar->setInit(Init);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
}
}
return MergeWithVar;
}
if (!ConflictingDecls.empty()) {
Name = Importer.HandleNameConflict(Name, DC, IDNS,
ConflictingDecls.data(),
ConflictingDecls.size());
if (!Name)
return 0;
}
}
Implement AST importing and merging for typedefs. As part of this, provide a lame implementation for importing TypeSourceInfos. llvm-svn: 95783
2010-02-11 01:47:19 +08:00
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// Create the imported variable.
Implement AST importing and merging for typedefs. As part of this, provide a lame implementation for importing TypeSourceInfos. llvm-svn: 95783
2010-02-11 01:47:19 +08:00
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
Importer.Import(D->getInnerLocStart()),
Loc, Name.getAsIdentifierInfo(),
T, TInfo,
Keep track of the actual storage specifier written on a variable or function declaration, since it may end up being changed (e.g., "extern" can become "static" if a prior declaration was static). Patch by Enea Zaffanella and Paolo Bolzoni. llvm-svn: 101826
2010-04-20 06:54:31 +08:00
D->getStorageClass(),
D->getStorageClassAsWritten());
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Set access specifiers on imported declarations. llvm-svn: 96788
2010-02-23 01:42:47 +08:00
ToVar->setAccess(D->getAccess());
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
ToVar->setLexicalDeclContext(LexicalDC);
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
Importer.Imported(D, ToVar);
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
LexicalDC->addDecl(ToVar);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// Merge the initializer.
// FIXME: Can we really import any initializer? Alternatively, we could force
// ourselves to import every declaration of a variable and then only use
// getInit() here.
Eliminate a bunch of unnecessary ASTContexts from members functions of Decl subclasses. No functionality change. llvm-svn: 95841
2010-02-11 09:19:42 +08:00
ToVar->setInit(Importer.Import(const_cast<Expr *>(D->getAnyInitializer())));
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
// FIXME: Other bits to merge?
return ToVar;
}
Implement AST importing of ImplicitParamDecls, despite the sad fact that we can't test it yet. llvm-svn: 96516
2010-02-18 05:22:52 +08:00
Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
// Parameters are created in the translation unit's context, then moved
// into the function declaration's context afterward.
DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
return 0;
// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());
// Import the parameter's type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
// Create the imported parameter.
ImplicitParamDecl *ToParm
= ImplicitParamDecl::Create(Importer.getToContext(), DC,
Loc, Name.getAsIdentifierInfo(),
T);
return Importer.Imported(D, ToParm);
}
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
// Parameters are created in the translation unit's context, then moved
// into the function declaration's context afterward.
DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
Implement AST importing and merging for typedefs. As part of this, provide a lame implementation for importing TypeSourceInfos. llvm-svn: 95783
2010-02-11 01:47:19 +08:00
// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
return 0;
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());
// Import the parameter's type.
QualType T = Importer.Import(D->getType());
Implement AST importing and merging for typedefs. As part of this, provide a lame implementation for importing TypeSourceInfos. llvm-svn: 95783
2010-02-11 01:47:19 +08:00
if (T.isNull())
return 0;
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
// Create the imported parameter.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Importer.Import(D->getInnerLocStart()),
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
Loc, Name.getAsIdentifierInfo(),
T, TInfo, D->getStorageClass(),
Keep track of the actual storage specifier written on a variable or function declaration, since it may end up being changed (e.g., "extern" can become "static" if a prior declaration was static). Patch by Enea Zaffanella and Paolo Bolzoni. llvm-svn: 101826
2010-04-20 06:54:31 +08:00
D->getStorageClassAsWritten(),
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
/*FIXME: Default argument*/ 0);
Remember whether a ParmVarDecl was spelled with a default argument or whether it inherited one from a previous declaration. Patch by Enea Zaffanella! llvm-svn: 98362
2010-03-13 02:31:32 +08:00
ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
return Importer.Imported(D, ToParm);
Implement basic support for merging function declarations across translation units. llvm-svn: 95794
2010-02-11 03:54:31 +08:00
}
Implement AST importing and merging for typedefs. As part of this, provide a lame implementation for importing TypeSourceInfos. llvm-svn: 95783
2010-02-11 01:47:19 +08:00
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
// Import the major distinguishing characteristics of a method.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
continue;
// Check return types.
if (!Importer.IsStructurallyEquivalent(D->getResultType(),
FoundMethod->getResultType())) {
Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
<< D->isInstanceMethod() << Name
<< D->getResultType() << FoundMethod->getResultType();
Importer.ToDiag(FoundMethod->getLocation(),
diag::note_odr_objc_method_here)
<< D->isInstanceMethod() << Name;
return 0;
}
// Check the number of parameters.
if (D->param_size() != FoundMethod->param_size()) {
Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
<< D->isInstanceMethod() << Name
<< D->param_size() << FoundMethod->param_size();
Importer.ToDiag(FoundMethod->getLocation(),
diag::note_odr_objc_method_here)
<< D->isInstanceMethod() << Name;
return 0;
}
// Check parameter types.
for (ObjCMethodDecl::param_iterator P = D->param_begin(),
PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
P != PEnd; ++P, ++FoundP) {
if (!Importer.IsStructurallyEquivalent((*P)->getType(),
(*FoundP)->getType())) {
Importer.FromDiag((*P)->getLocation(),
diag::err_odr_objc_method_param_type_inconsistent)
<< D->isInstanceMethod() << Name
<< (*P)->getType() << (*FoundP)->getType();
Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
<< (*FoundP)->getType();
return 0;
}
}
// Check variadic/non-variadic.
// Check the number of parameters.
if (D->isVariadic() != FoundMethod->isVariadic()) {
Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
<< D->isInstanceMethod() << Name;
Importer.ToDiag(FoundMethod->getLocation(),
diag::note_odr_objc_method_here)
<< D->isInstanceMethod() << Name;
return 0;
}
// FIXME: Any other bits we need to merge?
return Importer.Imported(D, FoundMethod);
}
}
// Import the result type.
QualType ResultTy = Importer.Import(D->getResultType());
if (ResultTy.isNull())
return 0;
Keep track of type source information in the return type of an Objective-C method declaration, e.g., for - (Foo *)myMethod; we now have TypeSourceInfo for the Foo*. llvm-svn: 97942
2010-03-08 22:59:44 +08:00
TypeSourceInfo *ResultTInfo = Importer.Import(D->getResultTypeSourceInfo());
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
ObjCMethodDecl *ToMethod
= ObjCMethodDecl::Create(Importer.getToContext(),
Loc,
Importer.Import(D->getLocEnd()),
Name.getObjCSelector(),
Keep track of type source information in the return type of an Objective-C method declaration, e.g., for - (Foo *)myMethod; we now have TypeSourceInfo for the Foo*. llvm-svn: 97942
2010-03-08 22:59:44 +08:00
ResultTy, ResultTInfo, DC,
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
D->isInstanceMethod(),
D->isVariadic(),
D->isSynthesized(),
Mark objc methods that are implicitly declared for properties (not user-declared) as implicit. This results in libclang ignoring such methods. llvm-svn: 137852
2011-08-18 03:25:08 +08:00
D->isImplicit(),
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
D->isDefined(),
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
D->getImplementationControl(),
D->hasRelatedResultType());
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
// FIXME: When we decide to merge method definitions, we'll need to
// deal with implicit parameters.
// Import the parameters
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 5> ToParams;
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
for (ObjCMethodDecl::param_iterator FromP = D->param_begin(),
FromPEnd = D->param_end();
FromP != FromPEnd;
++FromP) {
ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*FromP));
if (!ToP)
return 0;
ToParams.push_back(ToP);
}
// Set the parameters.
for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
ToParams[I]->setOwningFunction(ToMethod);
ToMethod->addDecl(ToParams[I]);
}
Allow getting all source locations of selector identifiers in a ObjCMethodDecl. Instead of always storing all source locations for the selector identifiers we check whether all the identifiers are in a "standard" position; "standard" position is -Immediately before the arguments: -(id)first:(int)x second:(int)y; -With a space between the arguments: -(id)first: (int)x second: (int)y; -For nullary selectors, immediately before ';': -(void)release; In such cases we infer the locations instead of storing them. llvm-svn: 140989
2011-10-03 14:37:04 +08:00
SmallVector<SourceLocation, 12> SelLocs;
D->getSelectorLocs(SelLocs);
ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
ToMethod->setLexicalDeclContext(LexicalDC);
Importer.Imported(D, ToMethod);
LexicalDC->addDecl(ToMethod);
return ToMethod;
}
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
// Import the major distinguishing characteristics of a category.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
ObjCInterfaceDecl *ToInterface
= cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
if (!ToInterface)
return 0;
// Determine if we've already encountered this category.
ObjCCategoryDecl *MergeWithCategory
= ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
ObjCCategoryDecl *ToCategory = MergeWithCategory;
if (!ToCategory) {
ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
Improve location fidelity of objc decls. -Add the location of the class name to all objc container decls, not just ObjCInterfaceDecl. -Make objc decls consistent with the rest of the NamedDecls and have getLocation() point to the class name, not the location of '@'. llvm-svn: 141061
2011-10-04 12:48:02 +08:00
Importer.Import(D->getAtStartLoc()),
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
Loc,
Importer.Import(D->getCategoryNameLoc()),
Remove a few mutating ObjCCategoryDecl methods. Remove -setClassInterface -setNextClassCategory -insertNextClassCategory and combine them in the Create function. llvm-svn: 138817
2011-08-31 03:43:26 +08:00
Name.getAsIdentifierInfo(),
ToInterface);
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
ToCategory->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(ToCategory);
Importer.Imported(D, ToCategory);
// Import protocols
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ObjCProtocolDecl *, 4> Protocols;
SmallVector<SourceLocation, 4> ProtocolLocs;
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
= D->protocol_loc_begin();
for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
FromProtoEnd = D->protocol_end();
FromProto != FromProtoEnd;
++FromProto, ++FromProtoLoc) {
ObjCProtocolDecl *ToProto
= cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
if (!ToProto)
return 0;
Protocols.push_back(ToProto);
ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
}
// FIXME: If we're merging, make sure that the protocol list is the same.
ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
ProtocolLocs.data(), Importer.getToContext());
} else {
Importer.Imported(D, ToCategory);
}
// Import all of the members of this category.
Collect the code that imports all of the members of a declaration context into a single function, ImportDeclContext. Use it rather than explicit loops. No functionality change. llvm-svn: 96739
2010-02-22 02:24:45 +08:00
ImportDeclContext(D);
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
// If we have an implementation, import it as well.
if (D->getImplementation()) {
ObjCCategoryImplDecl *Impl
Fix two thinkos and add a test for importing the AST of a category implementation. llvm-svn: 121263
2010-12-09 00:41:55 +08:00
= cast_or_null<ObjCCategoryImplDecl>(
Importer.Import(D->getImplementation()));
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
if (!Impl)
return 0;
ToCategory->setImplementation(Impl);
}
return ToCategory;
}
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
// Import the major distinguishing characteristics of a protocol.
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
ObjCProtocolDecl *MergeWithProtocol = 0;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
break;
}
ObjCProtocolDecl *ToProto = MergeWithProtocol;
if (!ToProto || ToProto->isForwardDecl()) {
if (!ToProto) {
Improve location fidelity of objc decls. -Add the location of the class name to all objc container decls, not just ObjCInterfaceDecl. -Make objc decls consistent with the rest of the NamedDecls and have getLocation() point to the class name, not the location of '@'. llvm-svn: 141061
2011-10-04 12:48:02 +08:00
ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
Name.getAsIdentifierInfo(), Loc,
Importer.Import(D->getAtStartLoc()));
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
ToProto->setForwardDecl(D->isForwardDecl());
ToProto->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(ToProto);
}
Importer.Imported(D, ToProto);
// Import protocols
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ObjCProtocolDecl *, 4> Protocols;
SmallVector<SourceLocation, 4> ProtocolLocs;
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
ObjCProtocolDecl::protocol_loc_iterator
FromProtoLoc = D->protocol_loc_begin();
for (ObjCProtocolDecl::protocol_iterator FromProto = D->protocol_begin(),
FromProtoEnd = D->protocol_end();
FromProto != FromProtoEnd;
++FromProto, ++FromProtoLoc) {
ObjCProtocolDecl *ToProto
= cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
if (!ToProto)
return 0;
Protocols.push_back(ToProto);
ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
}
// FIXME: If we're merging, make sure that the protocol list is the same.
ToProto->setProtocolList(Protocols.data(), Protocols.size(),
ProtocolLocs.data(), Importer.getToContext());
} else {
Importer.Imported(D, ToProto);
}
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
// Import all of the members of this protocol.
Collect the code that imports all of the members of a declaration context into a single function, ImportDeclContext. Use it rather than explicit loops. No functionality change. llvm-svn: 96739
2010-02-22 02:24:45 +08:00
ImportDeclContext(D);
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
return ToProto;
}
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
// Import the major distinguishing characteristics of an @interface.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
ObjCInterfaceDecl *MergeWithIface = 0;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
break;
}
ObjCInterfaceDecl *ToIface = MergeWithIface;
if (!ToIface || ToIface->isForwardDecl()) {
if (!ToIface) {
Improve location fidelity of objc decls. -Add the location of the class name to all objc container decls, not just ObjCInterfaceDecl. -Make objc decls consistent with the rest of the NamedDecls and have getLocation() point to the class name, not the location of '@'. llvm-svn: 141061
2011-10-04 12:48:02 +08:00
ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
Importer.Import(D->getAtStartLoc()),
Name.getAsIdentifierInfo(), Loc,
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
D->isForwardDecl(),
D->isImplicitInterfaceDecl());
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
ToIface->setForwardDecl(D->isForwardDecl());
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
ToIface->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(ToIface);
}
Importer.Imported(D, ToIface);
if (D->getSuperClass()) {
ObjCInterfaceDecl *Super
= cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getSuperClass()));
if (!Super)
return 0;
ToIface->setSuperClass(Super);
ToIface->setSuperClassLoc(Importer.Import(D->getSuperClassLoc()));
}
// Import protocols
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ObjCProtocolDecl *, 4> Protocols;
SmallVector<SourceLocation, 4> ProtocolLocs;
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
ObjCInterfaceDecl::protocol_loc_iterator
FromProtoLoc = D->protocol_loc_begin();
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
// FIXME: Should we be usng all_referenced_protocol_begin() here?
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
for (ObjCInterfaceDecl::protocol_iterator FromProto = D->protocol_begin(),
FromProtoEnd = D->protocol_end();
FromProto != FromProtoEnd;
++FromProto, ++FromProtoLoc) {
ObjCProtocolDecl *ToProto
= cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
if (!ToProto)
return 0;
Protocols.push_back(ToProto);
ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
}
// FIXME: If we're merging, make sure that the protocol list is the same.
ToIface->setProtocolList(Protocols.data(), Protocols.size(),
ProtocolLocs.data(), Importer.getToContext());
// Import @end range
ToIface->setAtEndRange(Importer.Import(D->getAtEndRange()));
} else {
Importer.Imported(D, ToIface);
Implement AST importing of Objective-C instance variables. Check superclasses when merging two Objective-C @interfaces. llvm-svn: 96420
2010-02-17 08:34:30 +08:00
// Check for consistency of superclasses.
DeclarationName FromSuperName, ToSuperName;
if (D->getSuperClass())
FromSuperName = Importer.Import(D->getSuperClass()->getDeclName());
if (ToIface->getSuperClass())
ToSuperName = ToIface->getSuperClass()->getDeclName();
if (FromSuperName != ToSuperName) {
Importer.ToDiag(ToIface->getLocation(),
diag::err_odr_objc_superclass_inconsistent)
<< ToIface->getDeclName();
if (ToIface->getSuperClass())
Importer.ToDiag(ToIface->getSuperClassLoc(),
diag::note_odr_objc_superclass)
<< ToIface->getSuperClass()->getDeclName();
else
Importer.ToDiag(ToIface->getLocation(),
diag::note_odr_objc_missing_superclass);
if (D->getSuperClass())
Importer.FromDiag(D->getSuperClassLoc(),
diag::note_odr_objc_superclass)
<< D->getSuperClass()->getDeclName();
else
Importer.FromDiag(D->getLocation(),
diag::note_odr_objc_missing_superclass);
return 0;
}
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
}
AST import of Objective-C categories. llvm-svn: 96551
2010-02-18 09:47:50 +08:00
// Import categories. When the categories themselves are imported, they'll
// hook themselves into this interface.
for (ObjCCategoryDecl *FromCat = D->getCategoryList(); FromCat;
FromCat = FromCat->getNextClassCategory())
Importer.Import(FromCat);
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
// Import all of the members of this class.
Collect the code that imports all of the members of a declaration context into a single function, ImportDeclContext. Use it rather than explicit loops. No functionality change. llvm-svn: 96739
2010-02-22 02:24:45 +08:00
ImportDeclContext(D);
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
// If we have an @implementation, import it as well.
if (D->getImplementation()) {
Extern the ASTImporter to import @implementation declarations. llvm-svn: 121097
2010-12-07 09:26:03 +08:00
ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
Importer.Import(D->getImplementation()));
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
if (!Impl)
return 0;
ToIface->setImplementation(Impl);
}
AST import for Objective-C protocols llvm-svn: 96478
2010-02-18 00:12:00 +08:00
return ToIface;
Skeleton for importing Objective-C classes llvm-svn: 96306
2010-02-16 09:20:57 +08:00
}
Implement ASTImporter support for Objective-C category implementations. llvm-svn: 121139
2010-12-07 23:32:12 +08:00
Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
Importer.Import(D->getCategoryDecl()));
if (!Category)
return 0;
ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
if (!ToImpl) {
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
return 0;
ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
Importer.Import(D->getIdentifier()),
Improve location fidelity of objc decls. -Add the location of the class name to all objc container decls, not just ObjCInterfaceDecl. -Make objc decls consistent with the rest of the NamedDecls and have getLocation() point to the class name, not the location of '@'. llvm-svn: 141061
2011-10-04 12:48:02 +08:00
Category->getClassInterface(),
Importer.Import(D->getLocation()),
Importer.Import(D->getAtStartLoc()));
Implement ASTImporter support for Objective-C category implementations. llvm-svn: 121139
2010-12-07 23:32:12 +08:00
DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
if (!LexicalDC)
return 0;
ToImpl->setLexicalDeclContext(LexicalDC);
}
LexicalDC->addDecl(ToImpl);
Category->setImplementation(ToImpl);
}
Importer.Imported(D, ToImpl);
Fix two thinkos and add a test for importing the AST of a category implementation. llvm-svn: 121263
2010-12-09 00:41:55 +08:00
ImportDeclContext(D);
Implement ASTImporter support for Objective-C category implementations. llvm-svn: 121139
2010-12-07 23:32:12 +08:00
return ToImpl;
}
Extern the ASTImporter to import @implementation declarations. llvm-svn: 121097
2010-12-07 09:26:03 +08:00
Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
// Find the corresponding interface.
ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
Importer.Import(D->getClassInterface()));
if (!Iface)
return 0;
// Import the superclass, if any.
ObjCInterfaceDecl *Super = 0;
if (D->getSuperClass()) {
Super = cast_or_null<ObjCInterfaceDecl>(
Importer.Import(D->getSuperClass()));
if (!Super)
return 0;
}
ObjCImplementationDecl *Impl = Iface->getImplementation();
if (!Impl) {
// We haven't imported an implementation yet. Create a new @implementation
// now.
Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
Importer.ImportContext(D->getDeclContext()),
Improve location fidelity of objc decls. -Add the location of the class name to all objc container decls, not just ObjCInterfaceDecl. -Make objc decls consistent with the rest of the NamedDecls and have getLocation() point to the class name, not the location of '@'. llvm-svn: 141061
2011-10-04 12:48:02 +08:00
Iface, Super,
Extern the ASTImporter to import @implementation declarations. llvm-svn: 121097
2010-12-07 09:26:03 +08:00
Importer.Import(D->getLocation()),
Improve location fidelity of objc decls. -Add the location of the class name to all objc container decls, not just ObjCInterfaceDecl. -Make objc decls consistent with the rest of the NamedDecls and have getLocation() point to the class name, not the location of '@'. llvm-svn: 141061
2011-10-04 12:48:02 +08:00
Importer.Import(D->getAtStartLoc()));
Extern the ASTImporter to import @implementation declarations. llvm-svn: 121097
2010-12-07 09:26:03 +08:00
if (D->getDeclContext() != D->getLexicalDeclContext()) {
DeclContext *LexicalDC
= Importer.ImportContext(D->getLexicalDeclContext());
if (!LexicalDC)
return 0;
Impl->setLexicalDeclContext(LexicalDC);
}
// Associate the implementation with the class it implements.
Iface->setImplementation(Impl);
Importer.Imported(D, Iface->getImplementation());
} else {
Importer.Imported(D, Iface->getImplementation());
// Verify that the existing @implementation has the same superclass.
if ((Super && !Impl->getSuperClass()) ||
(!Super && Impl->getSuperClass()) ||
(Super && Impl->getSuperClass() &&
Super->getCanonicalDecl() != Impl->getSuperClass())) {
Importer.ToDiag(Impl->getLocation(),
diag::err_odr_objc_superclass_inconsistent)
<< Iface->getDeclName();
// FIXME: It would be nice to have the location of the superclass
// below.
if (Impl->getSuperClass())
Importer.ToDiag(Impl->getLocation(),
diag::note_odr_objc_superclass)
<< Impl->getSuperClass()->getDeclName();
else
Importer.ToDiag(Impl->getLocation(),
diag::note_odr_objc_missing_superclass);
if (D->getSuperClass())
Importer.FromDiag(D->getLocation(),
diag::note_odr_objc_superclass)
<< D->getSuperClass()->getDeclName();
else
Importer.FromDiag(D->getLocation(),
diag::note_odr_objc_missing_superclass);
return 0;
}
}
// Import all of the members of this @implementation.
ImportDeclContext(D);
return Impl;
}
Implement AST merging for Objective-C properties. llvm-svn: 96483
2010-02-18 02:02:10 +08:00
Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
// Import the major distinguishing characteristics of an @property.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
// Check whether we have already imported this property.
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
Implement AST merging for Objective-C properties. llvm-svn: 96483
2010-02-18 02:02:10 +08:00
if (ObjCPropertyDecl *FoundProp
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
= dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
Implement AST merging for Objective-C properties. llvm-svn: 96483
2010-02-18 02:02:10 +08:00
// Check property types.
if (!Importer.IsStructurallyEquivalent(D->getType(),
FoundProp->getType())) {
Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
<< Name << D->getType() << FoundProp->getType();
Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
<< FoundProp->getType();
return 0;
}
// FIXME: Check property attributes, getters, setters, etc.?
// Consider these properties to be equivalent.
Importer.Imported(D, FoundProp);
return FoundProp;
}
}
// Import the type.
Remember type source information for Objective C property declarations. llvm-svn: 105484
2010-06-05 04:50:08 +08:00
TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
if (!T)
Implement AST merging for Objective-C properties. llvm-svn: 96483
2010-02-18 02:02:10 +08:00
return 0;
// Create the new property.
ObjCPropertyDecl *ToProperty
= ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
Name.getAsIdentifierInfo(),
Importer.Import(D->getAtLoc()),
T,
D->getPropertyImplementation());
Importer.Imported(D, ToProperty);
ToProperty->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(ToProperty);
ToProperty->setPropertyAttributes(D->getPropertyAttributes());
Patch to provide separate ASTs for multiple ObjC class extension declarations (implements radar 7928731). llvm-svn: 106597
2010-06-23 07:20:40 +08:00
ToProperty->setPropertyAttributesAsWritten(
D->getPropertyAttributesAsWritten());
Implement AST merging for Objective-C properties. llvm-svn: 96483
2010-02-18 02:02:10 +08:00
ToProperty->setGetterName(Importer.Import(D->getGetterName()));
ToProperty->setSetterName(Importer.Import(D->getSetterName()));
ToProperty->setGetterMethodDecl(
cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
ToProperty->setSetterMethodDecl(
cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
ToProperty->setPropertyIvarDecl(
cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
return ToProperty;
}
Implement AST import for Objective-C property implementations (@synthesize and @dynamic). llvm-svn: 121159
2010-12-08 02:32:03 +08:00
Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
Importer.Import(D->getPropertyDecl()));
if (!Property)
return 0;
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
return 0;
// Import the lexical declaration context.
DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
if (!LexicalDC)
return 0;
}
ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
if (!InImpl)
return 0;
// Import the ivar (for an @synthesize).
ObjCIvarDecl *Ivar = 0;
if (D->getPropertyIvarDecl()) {
Ivar = cast_or_null<ObjCIvarDecl>(
Importer.Import(D->getPropertyIvarDecl()));
if (!Ivar)
return 0;
}
ObjCPropertyImplDecl *ToImpl
= InImpl->FindPropertyImplDecl(Property->getIdentifier());
if (!ToImpl) {
ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
Importer.Import(D->getLocStart()),
Importer.Import(D->getLocation()),
Property,
D->getPropertyImplementation(),
Ivar,
Importer.Import(D->getPropertyIvarDeclLoc()));
ToImpl->setLexicalDeclContext(LexicalDC);
Importer.Imported(D, ToImpl);
LexicalDC->addDecl(ToImpl);
} else {
// Check that we have the same kind of property implementation (@synthesize
// vs. @dynamic).
if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
Importer.ToDiag(ToImpl->getLocation(),
diag::err_odr_objc_property_impl_kind_inconsistent)
<< Property->getDeclName()
<< (ToImpl->getPropertyImplementation()
== ObjCPropertyImplDecl::Dynamic);
Importer.FromDiag(D->getLocation(),
diag::note_odr_objc_property_impl_kind)
<< D->getPropertyDecl()->getDeclName()
<< (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
return 0;
}
// For @synthesize, check that we have the same
if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
Ivar != ToImpl->getPropertyIvarDecl()) {
Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
diag::err_odr_objc_synthesize_ivar_inconsistent)
<< Property->getDeclName()
<< ToImpl->getPropertyIvarDecl()->getDeclName()
<< Ivar->getDeclName();
Importer.FromDiag(D->getPropertyIvarDeclLoc(),
diag::note_odr_objc_synthesize_ivar_here)
<< D->getPropertyIvarDecl()->getDeclName();
return 0;
}
// Merge the existing implementation with the new implementation.
Importer.Imported(D, ToImpl);
}
return ToImpl;
}
AST import for forward declarations of Objective-C protocols llvm-svn: 96555
2010-02-18 10:12:22 +08:00
Decl *
ASTNodeImporter::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) {
// Import the context of this declaration.
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
return 0;
DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
if (!LexicalDC)
return 0;
}
// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ObjCProtocolDecl *, 4> Protocols;
SmallVector<SourceLocation, 4> Locations;
AST import for forward declarations of Objective-C protocols llvm-svn: 96555
2010-02-18 10:12:22 +08:00
ObjCForwardProtocolDecl::protocol_loc_iterator FromProtoLoc
= D->protocol_loc_begin();
for (ObjCForwardProtocolDecl::protocol_iterator FromProto
= D->protocol_begin(), FromProtoEnd = D->protocol_end();
FromProto != FromProtoEnd;
++FromProto, ++FromProtoLoc) {
ObjCProtocolDecl *ToProto
= cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
if (!ToProto)
continue;
Protocols.push_back(ToProto);
Locations.push_back(Importer.Import(*FromProtoLoc));
}
ObjCForwardProtocolDecl *ToForward
= ObjCForwardProtocolDecl::Create(Importer.getToContext(), DC, Loc,
Protocols.data(), Protocols.size(),
Locations.data());
ToForward->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(ToForward);
Importer.Imported(D, ToForward);
return ToForward;
}
Implement import of forward declarations of Objective-C classes llvm-svn: 96554
2010-02-18 10:04:09 +08:00
Decl *ASTNodeImporter::VisitObjCClassDecl(ObjCClassDecl *D) {
// Import the context of this declaration.
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
return 0;
DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
if (!LexicalDC)
return 0;
}
// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());
objective-c: Treat top-level objective-c declarations , such as list of forward @class decls, in a DeclGroup node. Deal with its consequence throught clang. This is in preparation for more Sema work ahead. // rdar://8843851. Feel free to reverse if it breaks something important and I am unavailable. llvm-svn: 138709
2011-08-28 04:50:59 +08:00
ObjCClassDecl::ObjCClassRef *From = D->getForwardDecl();
ObjCInterfaceDecl *ToIface
= cast_or_null<ObjCInterfaceDecl>(Importer.Import(From->getInterface()));
Implement import of forward declarations of Objective-C classes llvm-svn: 96554
2010-02-18 10:04:09 +08:00
ObjCClassDecl *ToClass = ObjCClassDecl::Create(Importer.getToContext(), DC,
objective-c: Treat top-level objective-c declarations , such as list of forward @class decls, in a DeclGroup node. Deal with its consequence throught clang. This is in preparation for more Sema work ahead. // rdar://8843851. Feel free to reverse if it breaks something important and I am unavailable. llvm-svn: 138709
2011-08-28 04:50:59 +08:00
Loc,
ToIface,
Importer.Import(From->getLocation()));
Implement import of forward declarations of Objective-C classes llvm-svn: 96554
2010-02-18 10:04:09 +08:00
ToClass->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(ToClass);
Importer.Imported(D, ToClass);
return ToClass;
}
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
// For template arguments, we adopt the translation unit as our declaration
// context. This context will be fixed when the actual template declaration
// is created.
// FIXME: Import default argument.
return TemplateTypeParmDecl::Create(Importer.getToContext(),
Importer.getToContext().getTranslationUnitDecl(),
Fixed TypedefDecl and TemplateTypeParameter source range. llvm-svn: 127119
2011-03-06 23:48:19 +08:00
Importer.Import(D->getLocStart()),
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
Importer.Import(D->getLocation()),
D->getDepth(),
D->getIndex(),
Importer.Import(D->getIdentifier()),
D->wasDeclaredWithTypename(),
D->isParameterPack());
}
Decl *
ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
return 0;
// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());
// Import the type of this declaration.
QualType T = Importer.Import(D->getType());
if (T.isNull())
return 0;
// Import type-source information.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
if (D->getTypeSourceInfo() && !TInfo)
return 0;
// FIXME: Import default argument.
return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
Importer.getToContext().getTranslationUnitDecl(),
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Importer.Import(D->getInnerLocStart()),
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
Loc, D->getDepth(), D->getPosition(),
Name.getAsIdentifierInfo(),
Add an AST representation for non-type template parameter packs, e.g., template<typename T, unsigned ...Dims> struct multi_array; along with semantic analysis support for finding unexpanded non-type template parameter packs in types, expressions, and so on. Template instantiation involving non-type template parameter packs probably doesn't work yet. That'll come soon. llvm-svn: 122527
2010-12-24 07:51:58 +08:00
T, D->isParameterPack(), TInfo);
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
}
Decl *
ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
return 0;
// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());
// Import template parameters.
TemplateParameterList *TemplateParams
= ImportTemplateParameterList(D->getTemplateParameters());
if (!TemplateParams)
return 0;
// FIXME: Import default argument.
return TemplateTemplateParmDecl::Create(Importer.getToContext(),
Importer.getToContext().getTranslationUnitDecl(),
Loc, D->getDepth(), D->getPosition(),
Implement support for template template parameter packs, e.g., template<template<class> class ...Metafunctions> struct apply_to_each; llvm-svn: 122874
2011-01-05 23:48:55 +08:00
D->isParameterPack(),
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
Name.getAsIdentifierInfo(),
TemplateParams);
}
Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
// If this record has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
CXXRecordDecl *Definition
= cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
if (Definition && Definition != D->getTemplatedDecl()) {
Decl *ImportedDef
= Importer.Import(Definition->getDescribedClassTemplate());
if (!ImportedDef)
return 0;
return Importer.Imported(D, ImportedDef);
}
// Import the major distinguishing characteristics of this class template.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
return 0;
// We may already have a template of the same name; try to find and match it.
if (!DC->isFunctionOrMethod()) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NamedDecl *, 4> ConflictingDecls;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
llvm::SmallVector<NamedDecl *, 2> FoundDecls;
DC->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
continue;
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
Decl *Found = FoundDecls[I];
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
if (ClassTemplateDecl *FoundTemplate
= dyn_cast<ClassTemplateDecl>(Found)) {
if (IsStructuralMatch(D, FoundTemplate)) {
// The class templates structurally match; call it the same template.
// FIXME: We may be filling in a forward declaration here. Handle
// this case!
Importer.Imported(D->getTemplatedDecl(),
FoundTemplate->getTemplatedDecl());
return Importer.Imported(D, FoundTemplate);
}
}
Teach the ASTImporter to perform DeclContext lookups in a way that avoids loading data from an external source, since those lookups were causing some "interesting" recursion in LLDB. This code is not efficient. I plan to remedy this inefficiency in a follow-up commit. llvm-svn: 142023
2011-10-15 08:10:27 +08:00
ConflictingDecls.push_back(FoundDecls[I]);
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
}
if (!ConflictingDecls.empty()) {
Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
ConflictingDecls.data(),
ConflictingDecls.size());
}
if (!Name)
return 0;
}
CXXRecordDecl *DTemplated = D->getTemplatedDecl();
// Create the declaration that is being templated.
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
DTemplated->getTagKind(),
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
DC, StartLoc, IdLoc,
Name.getAsIdentifierInfo());
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
D2Templated->setAccess(DTemplated->getAccess());
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
D2Templated->setLexicalDeclContext(LexicalDC);
// Create the class template declaration itself.
TemplateParameterList *TemplateParams
= ImportTemplateParameterList(D->getTemplateParameters());
if (!TemplateParams)
return 0;
ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
Loc, Name, TemplateParams,
D2Templated,
/*PrevDecl=*/0);
D2Templated->setDescribedClassTemplate(D2);
D2->setAccess(D->getAccess());
D2->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(D2);
// Note the relationship between the class templates.
Importer.Imported(D, D2);
Importer.Imported(DTemplated, D2Templated);
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
if (DTemplated->isCompleteDefinition() &&
!D2Templated->isCompleteDefinition()) {
Implement basic AST importing and merging support for class template declarations. llvm-svn: 120448
2010-12-01 03:14:50 +08:00
// FIXME: Import definition!
}
return D2;
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
ClassTemplateSpecializationDecl *D) {
// If this record has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
TagDecl *Definition = D->getDefinition();
if (Definition && Definition != D) {
Decl *ImportedDef = Importer.Import(Definition);
if (!ImportedDef)
return 0;
return Importer.Imported(D, ImportedDef);
}
ClassTemplateDecl *ClassTemplate
= cast_or_null<ClassTemplateDecl>(Importer.Import(
D->getSpecializedTemplate()));
if (!ClassTemplate)
return 0;
// Import the context of this declaration.
DeclContext *DC = ClassTemplate->getDeclContext();
if (!DC)
return 0;
DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
if (!LexicalDC)
return 0;
}
// Import the location of this declaration.
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
SourceLocation StartLoc = Importer.Import(D->getLocStart());
SourceLocation IdLoc = Importer.Import(D->getLocation());
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
// Import template arguments.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 2> TemplateArgs;
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
if (ImportTemplateArguments(D->getTemplateArgs().data(),
D->getTemplateArgs().size(),
TemplateArgs))
return 0;
// Try to find an existing specialization with these template arguments.
void *InsertPos = 0;
ClassTemplateSpecializationDecl *D2
= ClassTemplate->findSpecialization(TemplateArgs.data(),
TemplateArgs.size(), InsertPos);
if (D2) {
// We already have a class template specialization with these template
// arguments.
// FIXME: Check for specialization vs. instantiation errors.
if (RecordDecl *FoundDef = D2->getDefinition()) {
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
// The record types structurally match, or the "from" translation
// unit only had a forward declaration anyway; call it the same
// function.
return Importer.Imported(D, FoundDef);
}
}
} else {
// Create a new specialization.
D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
D->getTagKind(), DC,
Fixed InnerLocStart. llvm-svn: 127330
2011-03-09 22:09:51 +08:00
StartLoc, IdLoc,
ClassTemplate,
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
TemplateArgs.data(),
TemplateArgs.size(),
/*PrevDecl=*/0);
D2->setSpecializationKind(D->getSpecializationKind());
// Add this specialization to the class template.
ClassTemplate->AddSpecialization(D2, InsertPos);
// Import the qualifier, if any.
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
// Add the specialization to this context.
D2->setLexicalDeclContext(LexicalDC);
LexicalDC->addDecl(D2);
}
Importer.Imported(D, D2);
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
if (D->isCompleteDefinition() && ImportDefinition(D, D2))
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
return 0;
return D2;
}
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
//----------------------------------------------------------------------------
// Import Statements
//----------------------------------------------------------------------------
Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
<< S->getStmtClassName();
return 0;
}
//----------------------------------------------------------------------------
// Import Expressions
//----------------------------------------------------------------------------
Expr *ASTNodeImporter::VisitExpr(Expr *E) {
Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
<< E->getStmtClassName();
return 0;
}
AST import for DeclRefExprs llvm-svn: 96646
2010-02-19 09:17:02 +08:00
Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
if (!ToD)
return 0;
Add an optional field attached to a DeclRefExpr which points back to the Decl actually found via name lookup & overload resolution when that Decl is different from the ValueDecl which is actually referenced by the expression. This can be used by AST consumers to correctly attribute references to the spelling location of a using declaration, and otherwise gain insight into the name resolution performed by Clang. The public interface to DRE is kept as narrow as possible: we provide a getFoundDecl() which always returns a NamedDecl, either the ValueDecl referenced or the new, more precise NamedDecl if present. This way AST clients can code against getFoundDecl without know when exactly the AST has a split representation. For an example of the data this provides consider: % cat x.cc namespace N1 { struct S {}; void f(const S&); } void test(N1::S s) { f(s); using N1::f; f(s); } % ./bin/clang -fsyntax-only -Xclang -ast-dump x.cc [...] void test(N1::S s) (CompoundStmt 0x5b02010 <x.cc:5:20, line:9:1> (CallExpr 0x5b01df0 <line:6:3, col:6> 'void' (ImplicitCastExpr 0x5b01dd8 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01d80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)')) (ImplicitCastExpr 0x5b01e20 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01d58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S'))) (DeclStmt 0x5b01ee0 <line:7:3, col:14> 0x5b01e40 "UsingN1::;") (CallExpr 0x5b01fc8 <line:8:3, col:6> 'void' (ImplicitCastExpr 0x5b01fb0 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01f80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)' (UsingShadow 0x5b01ea0 'f'))) (ImplicitCastExpr 0x5b01ff8 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01f58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S')))) Now we can tell that the second call is 'using' (no pun intended) the using declaration, and *which* using declaration it sees. Without this, we can mistake calls that go through using declarations for ADL calls, and have no way to attribute names looked up with using declarations to the appropriate UsingDecl. llvm-svn: 130670
2011-05-02 07:48:14 +08:00
NamedDecl *FoundD = 0;
if (E->getDecl() != E->getFoundDecl()) {
FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
if (!FoundD)
return 0;
}
AST import for DeclRefExprs llvm-svn: 96646
2010-02-19 09:17:02 +08:00
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
Added a flag to identify resolved overloaded function references. llvm-svn: 141171
2011-10-05 15:56:41 +08:00
DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
Importer.Import(E->getQualifierLoc()),
ToD,
Importer.Import(E->getLocation()),
T, E->getValueKind(),
FoundD,
/*FIXME:TemplateArgs=*/0);
if (E->hadMultipleCandidates())
DRE->setHadMultipleCandidates(true);
return DRE;
AST import for DeclRefExprs llvm-svn: 96646
2010-02-19 09:17:02 +08:00
}
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
Fix the memory leak of FloatingLiteral/IntegerLiteral. For large floats/integers, APFloat/APInt will allocate memory from the heap to represent these numbers. Unfortunately, when we use a BumpPtrAllocator to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with the APFloat/APInt values will never get freed. I introduce the class 'APNumericStorage' which uses ASTContext's allocator for memory allocation and is used internally by FloatingLiteral/IntegerLiteral. Fixes rdar://7637185 llvm-svn: 112361
2010-08-28 17:06:06 +08:00
return IntegerLiteral::Create(Importer.getToContext(),
E->getValue(), T,
Importer.Import(E->getLocation()));
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
}
AST import for character literals llvm-svn: 96557
2010-02-18 10:21:22 +08:00
Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
Add support for C++0x unicode string and character literals, from Craig Topper! llvm-svn: 136210
2011-07-27 13:40:30 +08:00
return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
E->getKind(), T,
AST import for character literals llvm-svn: 96557
2010-02-18 10:21:22 +08:00
Importer.Import(E->getLocation()));
}
AST import of parenthesized expressions, unary operators, binary operators, and compound assignment operators. llvm-svn: 96643
2010-02-19 09:07:06 +08:00
Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
return 0;
return new (Importer.getToContext())
ParenExpr(Importer.Import(E->getLParen()),
Importer.Import(E->getRParen()),
SubExpr);
}
Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
return 0;
return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
Calculate the value kind of an expression when it's created and store it on the expression node. Also store an "object kind", which distinguishes ordinary "addressed" l-values (like variable references and pointer dereferences) and bitfield, @property, and vector-component l-values. Currently we're not using these for much, but I aim to switch pretty much everything calculating l-valueness over to them. For now they shouldn't necessarily be trusted. llvm-svn: 119685
2010-11-18 14:31:45 +08:00
T, E->getValueKind(),
E->getObjectKind(),
AST import of parenthesized expressions, unary operators, binary operators, and compound assignment operators. llvm-svn: 96643
2010-02-19 09:07:06 +08:00
Importer.Import(E->getOperatorLoc()));
}
Add support for the OpenCL vec_step operator, by generalising and extending the existing support for sizeof and alignof. Original patch by Guy Benyei. llvm-svn: 127475
2011-03-12 03:24:49 +08:00
Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
UnaryExprOrTypeTraitExpr *E) {
AST import for sizeof and alignof expressions llvm-svn: 96647
2010-02-19 09:24:23 +08:00
QualType ResultType = Importer.Import(E->getType());
if (E->isArgumentType()) {
TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
if (!TInfo)
return 0;
Add support for the OpenCL vec_step operator, by generalising and extending the existing support for sizeof and alignof. Original patch by Guy Benyei. llvm-svn: 127475
2011-03-12 03:24:49 +08:00
return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
TInfo, ResultType,
AST import for sizeof and alignof expressions llvm-svn: 96647
2010-02-19 09:24:23 +08:00
Importer.Import(E->getOperatorLoc()),
Importer.Import(E->getRParenLoc()));
}
Expr *SubExpr = Importer.Import(E->getArgumentExpr());
if (!SubExpr)
return 0;
Add support for the OpenCL vec_step operator, by generalising and extending the existing support for sizeof and alignof. Original patch by Guy Benyei. llvm-svn: 127475
2011-03-12 03:24:49 +08:00
return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
SubExpr, ResultType,
AST import for sizeof and alignof expressions llvm-svn: 96647
2010-02-19 09:24:23 +08:00
Importer.Import(E->getOperatorLoc()),
Importer.Import(E->getRParenLoc()));
}
AST import of parenthesized expressions, unary operators, binary operators, and compound assignment operators. llvm-svn: 96643
2010-02-19 09:07:06 +08:00
Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
Expr *LHS = Importer.Import(E->getLHS());
if (!LHS)
return 0;
Expr *RHS = Importer.Import(E->getRHS());
if (!RHS)
return 0;
return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
Calculate the value kind of an expression when it's created and store it on the expression node. Also store an "object kind", which distinguishes ordinary "addressed" l-values (like variable references and pointer dereferences) and bitfield, @property, and vector-component l-values. Currently we're not using these for much, but I aim to switch pretty much everything calculating l-valueness over to them. For now they shouldn't necessarily be trusted. llvm-svn: 119685
2010-11-18 14:31:45 +08:00
T, E->getValueKind(),
E->getObjectKind(),
AST import of parenthesized expressions, unary operators, binary operators, and compound assignment operators. llvm-svn: 96643
2010-02-19 09:07:06 +08:00
Importer.Import(E->getOperatorLoc()));
}
Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
QualType CompLHSType = Importer.Import(E->getComputationLHSType());
if (CompLHSType.isNull())
return 0;
QualType CompResultType = Importer.Import(E->getComputationResultType());
if (CompResultType.isNull())
return 0;
Expr *LHS = Importer.Import(E->getLHS());
if (!LHS)
return 0;
Expr *RHS = Importer.Import(E->getRHS());
if (!RHS)
return 0;
return new (Importer.getToContext())
CompoundAssignOperator(LHS, RHS, E->getOpcode(),
Calculate the value kind of an expression when it's created and store it on the expression node. Also store an "object kind", which distinguishes ordinary "addressed" l-values (like variable references and pointer dereferences) and bitfield, @property, and vector-component l-values. Currently we're not using these for much, but I aim to switch pretty much everything calculating l-valueness over to them. For now they shouldn't necessarily be trusted. llvm-svn: 119685
2010-11-18 14:31:45 +08:00
T, E->getValueKind(),
E->getObjectKind(),
CompLHSType, CompResultType,
AST import of parenthesized expressions, unary operators, binary operators, and compound assignment operators. llvm-svn: 96643
2010-02-19 09:07:06 +08:00
Importer.Import(E->getOperatorLoc()));
}
Make helpers static. llvm-svn: 128339
2011-03-26 20:38:21 +08:00
static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
Store inheritance paths after CastExprs instead of inside them. This takes some trickery since CastExpr has subclasses (and indeed, is abstract). Also, smoosh the CastKind into the bitfield from Expr. Drops two words of storage from Expr in the common case of expressions which don't need inheritance paths. Avoids a separate allocation and another word of overhead in cases needing inheritance paths. Also has the advantage of not leaking memory, since destructors for AST nodes are never run. llvm-svn: 110507
2010-08-07 14:22:56 +08:00
if (E->path_empty()) return false;
// TODO: import cast paths
return true;
}
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
return 0;
Store inheritance paths after CastExprs instead of inside them. This takes some trickery since CastExpr has subclasses (and indeed, is abstract). Also, smoosh the CastKind into the bitfield from Expr. Drops two words of storage from Expr in the common case of expressions which don't need inheritance paths. Avoids a separate allocation and another word of overhead in cases needing inheritance paths. Also has the advantage of not leaking memory, since destructors for AST nodes are never run. llvm-svn: 110507
2010-08-07 14:22:56 +08:00
CXXCastPath BasePath;
if (ImportCastPath(E, BasePath))
return 0;
return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
More incremental progress towards not including Expr.h in Sema.h. llvm-svn: 112044
2010-08-25 18:28:54 +08:00
SubExpr, &BasePath, E->getValueKind());
Implement AST importing and merging for enumeration types and enumerators, along with ImplicitCastExprs to make it work. llvm-svn: 96024
2010-02-13 06:17:39 +08:00
}
AST import for CStyleCastExpr. With this, we can import Cocoa.h into an empty context llvm-svn: 96648
2010-02-19 09:32:14 +08:00
Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
return 0;
Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
return 0;
TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
if (!TInfo && E->getTypeInfoAsWritten())
return 0;
Store inheritance paths after CastExprs instead of inside them. This takes some trickery since CastExpr has subclasses (and indeed, is abstract). Also, smoosh the CastKind into the bitfield from Expr. Drops two words of storage from Expr in the common case of expressions which don't need inheritance paths. Avoids a separate allocation and another word of overhead in cases needing inheritance paths. Also has the advantage of not leaking memory, since destructors for AST nodes are never run. llvm-svn: 110507
2010-08-07 14:22:56 +08:00
CXXCastPath BasePath;
if (ImportCastPath(E, BasePath))
return 0;
Calculate the value kind of an expression when it's created and store it on the expression node. Also store an "object kind", which distinguishes ordinary "addressed" l-values (like variable references and pointer dereferences) and bitfield, @property, and vector-component l-values. Currently we're not using these for much, but I aim to switch pretty much everything calculating l-valueness over to them. For now they shouldn't necessarily be trusted. llvm-svn: 119685
2010-11-18 14:31:45 +08:00
return CStyleCastExpr::Create(Importer.getToContext(), T,
E->getValueKind(), E->getCastKind(),
Store inheritance paths after CastExprs instead of inside them. This takes some trickery since CastExpr has subclasses (and indeed, is abstract). Also, smoosh the CastKind into the bitfield from Expr. Drops two words of storage from Expr in the common case of expressions which don't need inheritance paths. Avoids a separate allocation and another word of overhead in cases needing inheritance paths. Also has the advantage of not leaking memory, since destructors for AST nodes are never run. llvm-svn: 110507
2010-08-07 14:22:56 +08:00
SubExpr, &BasePath, TInfo,
Importer.Import(E->getLParenLoc()),
Importer.Import(E->getRParenLoc()));
AST import for CStyleCastExpr. With this, we can import Cocoa.h into an empty context llvm-svn: 96648
2010-02-19 09:32:14 +08:00
}
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
Introduce the notion of a "minimal" import of ASTs, to better support LLDB. llvm-svn: 123723
2011-01-18 11:11:38 +08:00
ASTContext &FromContext, FileManager &FromFileManager,
bool MinimalImport)
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
2010-02-06 01:54:41 +08:00
: ToContext(ToContext), FromContext(FromContext),
Introduce the notion of a "minimal" import of ASTs, to better support LLDB. llvm-svn: 123723
2011-01-18 11:11:38 +08:00
ToFileManager(ToFileManager), FromFileManager(FromFileManager),
Minimal(MinimalImport)
{
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
ImportedDecls[FromContext.getTranslationUnitDecl()]
= ToContext.getTranslationUnitDecl();
}
ASTImporter::~ASTImporter() { }
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
2010-02-06 01:54:41 +08:00
QualType ASTImporter::Import(QualType FromT) {
if (FromT.isNull())
return QualType();
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
const Type *fromTy = FromT.getTypePtr();
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
2010-02-06 01:54:41 +08:00
Cache imported types llvm-svn: 95543
2010-02-08 23:18:58 +08:00
// Check whether we've already imported this type.
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
llvm::DenseMap<const Type *, const Type *>::iterator Pos
= ImportedTypes.find(fromTy);
Cache imported types llvm-svn: 95543
2010-02-08 23:18:58 +08:00
if (Pos != ImportedTypes.end())
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
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
2010-02-06 01:54:41 +08:00
Cache imported types llvm-svn: 95543
2010-02-08 23:18:58 +08:00
// Import the type
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
2010-02-06 01:54:41 +08:00
ASTNodeImporter Importer(*this);
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
QualType ToT = Importer.Visit(fromTy);
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
2010-02-06 01:54:41 +08:00
if (ToT.isNull())
return ToT;
Cache imported types llvm-svn: 95543
2010-02-08 23:18:58 +08:00
// Record the imported type.
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
ImportedTypes[fromTy] = ToT.getTypePtr();
Cache imported types llvm-svn: 95543
2010-02-08 23:18:58 +08:00
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
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
2010-02-06 01:54:41 +08:00
}
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
Implement AST importing and merging for typedefs. As part of this, provide a lame implementation for importing TypeSourceInfos. llvm-svn: 95783
2010-02-11 01:47:19 +08:00
if (!FromTSI)
return FromTSI;
// FIXME: For now we just create a "trivial" type source info based
Add source location information to C++ base specifiers. llvm-svn: 109396
2010-07-27 00:56:01 +08:00
// on the type and a single location. Implement a real version of this.
Implement AST importing and merging for typedefs. As part of this, provide a lame implementation for importing TypeSourceInfos. llvm-svn: 95783
2010-02-11 01:47:19 +08:00
QualType T = Import(FromTSI->getType());
if (T.isNull())
return 0;
return ToContext.getTrivialTypeSourceInfo(T,
Renamed misleading getSourceRange -> getLocalSourceRange and getFullSourceRange -> getSourceRange for TypeLoc. llvm-svn: 104220
2010-05-20 18:00:11 +08:00
FromTSI->getTypeLoc().getSourceRange().getBegin());
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
}
Decl *ASTImporter::Import(Decl *FromD) {
if (!FromD)
return 0;
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
ASTNodeImporter Importer(*this);
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
// Check whether we've already imported this declaration.
llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
if (Pos != ImportedDecls.end()) {
Decl *ToD = Pos->second;
Importer.ImportDefinitionIfNeeded(FromD, ToD);
return ToD;
}
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
// Import the type
Decl *ToD = Importer.Visit(FromD);
if (!ToD)
return 0;
// Record the imported declaration.
ImportedDecls[FromD] = ToD;
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
// Keep track of anonymous tags that have an associated typedef.
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (FromTag->getTypedefNameForAnonDecl())
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
AnonTagsWithPendingTypedefs.push_back(FromTag);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
} else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
// When we've finished transforming a typedef, see whether it was the
// typedef for an anonymous tag.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
for (SmallVector<TagDecl *, 4>::iterator
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
FromTag = AnonTagsWithPendingTypedefs.begin(),
FromTagEnd = AnonTagsWithPendingTypedefs.end();
FromTag != FromTagEnd; ++FromTag) {
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
// We found the typedef for an anonymous tag; link them.
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
AnonTagsWithPendingTypedefs.erase(FromTag);
break;
}
}
}
}
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
return ToD;
}
DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
if (!FromDC)
return FromDC;
return cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
}
Expr *ASTImporter::Import(Expr *FromE) {
if (!FromE)
return 0;
return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
}
Stmt *ASTImporter::Import(Stmt *FromS) {
if (!FromS)
return 0;
When AST merging for record declarations fails, warn about the incompatibility and show where the structural differences are. For example: struct1.c:36:8: warning: type 'struct S7' has incompatible definitions in different translation units struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct1.c:36:33: note: bit-field 'j' with type 'unsigned int' and length 8 here struct S7 { int i : 8; unsigned j : 8; } x7; ^ struct2.c:33:33: note: bit-field 'j' with type 'unsigned int' and length 16 here struct S7 { int i : 8; unsigned j : 16; } x7; ^ There are a few changes to make this work: - ASTImporter now has only a single Diagnostic object, not multiple diagnostic objects. Otherwise, having a warning/error printed via one Diagnostic and its note printed on the other Diagnostic could cause the note to be suppressed. - Implemented import functionality for IntegerLiteral (along with general support for statements and expressions) llvm-svn: 95900
2010-02-12 03:21:55 +08:00
// Check whether we've already imported this declaration.
llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
if (Pos != ImportedStmts.end())
return Pos->second;
// Import the type
ASTNodeImporter Importer(*this);
Stmt *ToS = Importer.Visit(FromS);
if (!ToS)
return 0;
// Record the imported declaration.
ImportedStmts[FromS] = ToS;
return ToS;
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
}
NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
if (!FromNNS)
return 0;
ASTImporter support for NestedNameSpecifier, from Olaf Krzikalla llvm-svn: 130307
2011-04-28 00:48:40 +08:00
NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
switch (FromNNS->getKind()) {
case NestedNameSpecifier::Identifier:
if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
return NestedNameSpecifier::Create(ToContext, prefix, II);
}
return 0;
case NestedNameSpecifier::Namespace:
if (NamespaceDecl *NS =
cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
return NestedNameSpecifier::Create(ToContext, prefix, NS);
}
return 0;
case NestedNameSpecifier::NamespaceAlias:
if (NamespaceAliasDecl *NSAD =
cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
}
return 0;
case NestedNameSpecifier::Global:
return NestedNameSpecifier::GlobalSpecifier(ToContext);
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
QualType T = Import(QualType(FromNNS->getAsType(), 0u));
if (!T.isNull()) {
bool bTemplate = FromNNS->getKind() ==
NestedNameSpecifier::TypeSpecWithTemplate;
return NestedNameSpecifier::Create(ToContext, prefix,
bTemplate, T.getTypePtr());
}
}
return 0;
}
llvm_unreachable("Invalid nested name specifier kind");
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
return 0;
}
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
// FIXME: Implement!
return NestedNameSpecifierLoc();
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
TemplateName ASTImporter::Import(TemplateName From) {
switch (From.getKind()) {
case TemplateName::Template:
if (TemplateDecl *ToTemplate
= cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
return TemplateName(ToTemplate);
return TemplateName();
case TemplateName::OverloadedTemplate: {
OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
UnresolvedSet<2> ToTemplates;
for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
E = FromStorage->end();
I != E; ++I) {
if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
ToTemplates.addDecl(To);
else
return TemplateName();
}
return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
ToTemplates.end());
}
case TemplateName::QualifiedTemplate: {
QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
if (!Qualifier)
return TemplateName();
if (TemplateDecl *ToTemplate
= cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
return ToContext.getQualifiedTemplateName(Qualifier,
QTN->hasTemplateKeyword(),
ToTemplate);
return TemplateName();
}
case TemplateName::DependentTemplate: {
DependentTemplateName *DTN = From.getAsDependentTemplateName();
NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
if (!Qualifier)
return TemplateName();
if (DTN->isIdentifier()) {
return ToContext.getDependentTemplateName(Qualifier,
Import(DTN->getIdentifier()));
}
return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
}
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 16:33:18 +08:00
case TemplateName::SubstTemplateTemplateParm: {
SubstTemplateTemplateParmStorage *subst
= From.getAsSubstTemplateTemplateParm();
TemplateTemplateParmDecl *param
= cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
if (!param)
return TemplateName();
TemplateName replacement = Import(subst->getReplacement());
if (replacement.isNull()) return TemplateName();
return ToContext.getSubstTemplateTemplateParm(param, replacement);
}
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 14:45:20 +08:00
case TemplateName::SubstTemplateTemplateParmPack: {
SubstTemplateTemplateParmPackStorage *SubstPack
= From.getAsSubstTemplateTemplateParmPack();
TemplateTemplateParmDecl *Param
= cast_or_null<TemplateTemplateParmDecl>(
Import(SubstPack->getParameterPack()));
if (!Param)
return TemplateName();
ASTNodeImporter Importer(*this);
TemplateArgument ArgPack
= Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
if (ArgPack.isNull())
return TemplateName();
return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
}
llvm_unreachable("Invalid template name kind");
return TemplateName();
}
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
if (FromLoc.isInvalid())
return SourceLocation();
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
SourceManager &FromSM = FromContext.getSourceManager();
// For now, map everything down to its spelling location, so that we
Switch comments and assert text in AST from 'instantiation' to 'expansion'. llvm-svn: 135224
2011-07-15 08:04:35 +08:00
// don't have to import macro expansions.
// FIXME: Import macro expansions!
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
FromLoc = FromSM.getSpellingLoc(FromLoc);
std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
SourceManager &ToSM = ToContext.getSourceManager();
return ToSM.getLocForStartOfFile(Import(Decomposed.first))
Rename SourceLocation::getFileLocWithOffset -> getLocWithOffset. It already works (and is useful with) macro locs as well. llvm-svn: 140057
2011-09-20 04:40:19 +08:00
.getLocWithOffset(Decomposed.second);
Introduce a testbed for merging multiple ASTs into a single AST context with the AST importer. WIP, still useless but at least it has a test. llvm-svn: 95683
2010-02-10 03:21:46 +08:00
}
SourceRange ASTImporter::Import(SourceRange FromRange) {
return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
}
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
FileID ASTImporter::Import(FileID FromID) {
Make the FileID import map key on FileID. llvm-svn: 115118
2010-09-30 09:03:06 +08:00
llvm::DenseMap<FileID, FileID>::iterator Pos
= ImportedFileIDs.find(FromID);
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
if (Pos != ImportedFileIDs.end())
return Pos->second;
SourceManager &FromSM = FromContext.getSourceManager();
SourceManager &ToSM = ToContext.getSourceManager();
const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
Switch comments and assert text in AST from 'instantiation' to 'expansion'. llvm-svn: 135224
2011-07-15 08:04:35 +08:00
assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
// Include location of this file.
SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
// Map the FileID for to the "to" source manager.
FileID ToID;
const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
if (Cache->OrigEntry) {
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
// FIXME: We probably want to use getVirtualFile(), so we don't hit the
// disk again
// FIXME: We definitely want to re-use the existing MemoryBuffer, rather
// than mmap the files several times.
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
ToID = ToSM.createFileID(Entry, ToIncludeLoc,
FromSLoc.getFile().getFileCharacteristic());
} else {
// FIXME: We want to re-use the existing MemoryBuffer!
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
const llvm::MemoryBuffer *
FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
llvm::MemoryBuffer *ToBuf
Match MemoryBuffer API changes. llvm-svn: 100484
2010-04-06 06:42:27 +08:00
= llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
FromBuf->getBufferIdentifier());
ToID = ToSM.createFileIDForMemBuffer(ToBuf);
}
Make the FileID import map key on FileID. llvm-svn: 115118
2010-09-30 09:03:06 +08:00
ImportedFileIDs[FromID] = ToID;
Implement basic support for importing source locations from one AST into another AST, including their include history. Here's an example error that involves a conflict merging a variable with different types in two translation units (diagnosed in the third AST context into which everything is merged). /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var2.c:3:5: error: external variable 'x2' declared with incompatible types in different translation units ('int' vs. 'double') int x2; ^ In file included from /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.c:3: /Volumes/Data/dgregor/Projects/llvm/tools/clang/test/ASTMerge/Inputs/var1.h:1:8: note: declared here with type 'double' double x2; ^ Although we maintain include history, we do not maintain macro instantiation history across a merge. Instead, we map down to the spelling location (for now!). llvm-svn: 95732
2010-02-10 08:15:17 +08:00
return ToID;
}
Introduce the notion of a "minimal" import of ASTs, to better support LLDB. llvm-svn: 123723
2011-01-18 11:11:38 +08:00
void ASTImporter::ImportDefinition(Decl *From) {
Decl *To = Import(From);
if (!To)
return;
if (DeclContext *FromDC = cast<DeclContext>(From)) {
ASTNodeImporter Importer(*this);
This fix (thanks to Doug Gregor) corrects a bug in ImportDefinition when replacing a previously forward-declared CXXRecordDecl with its full definition. The forward-declared type's DefinitionData had not been intialized for the forward-declared type, so adding fields to the Decl caused CXXRecordDecl::addedMember() to crash when accessing the DefinitionData. llvm-svn: 135530
2011-07-20 06:38:25 +08:00
if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
if (!ToRecord->getDefinition()) {
Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
/*ForceImport=*/true);
return;
}
}
Teach the ASTImporter to cope with cases where we have already imported a forward declaration, but later the full definition of the same entity becomes available. When this happens, import the definition. llvm-svn: 136537
2011-07-30 07:31:30 +08:00
if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
if (!ToEnum->getDefinition()) {
Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
/*ForceImport=*/true);
return;
}
}
Introduce the notion of a "minimal" import of ASTs, to better support LLDB. llvm-svn: 123723
2011-01-18 11:11:38 +08:00
Importer.ImportDeclContext(FromDC, true);
}
}
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
2010-02-06 01:54:41 +08:00
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();
}
Implement AST import support for class template specializations. llvm-svn: 120523
2010-12-01 09:36:18 +08:00
IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
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
2010-02-06 01:54:41 +08:00
if (!FromId)
return 0;
return &ToContext.Idents.get(FromId->getName());
}
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
Selector ASTImporter::Import(Selector FromSel) {
if (FromSel.isNull())
return Selector();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<IdentifierInfo *, 4> Idents;
Implement AST importing and checking for Objective-C method declarations. llvm-svn: 96442
2010-02-17 10:12:47 +08:00
Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
}
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
DeclContext *DC,
unsigned IDNS,
NamedDecl **Decls,
unsigned NumDecls) {
return Name;
}
DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
return ToContext.getDiagnostics().Report(Loc, DiagID);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
}
DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
return FromContext.getDiagnostics().Report(Loc, DiagID);
Implement basic importing and merging of variable declarations within the AST importer. This doesn't actually do anything (yet), because we don't have driver logic for merging ASTs. llvm-svn: 95570
2010-02-09 05:09:39 +08:00
}
Funnel changes to the ImportedDecls list in the ASTImporter through a single Imported function, in preparation for fixing a serious design flaw. llvm-svn: 96044
2010-02-13 07:44:20 +08:00
Decl *ASTImporter::Imported(Decl *From, Decl *To) {
ImportedDecls[From] = To;
return To;
Add newline. llvm-svn: 96116
2010-02-14 04:24:39 +08:00
}
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To) {
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
llvm::DenseMap<const Type *, const Type *>::iterator Pos
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
= ImportedTypes.find(From.getTypePtr());
if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
return true;
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls);
Try to fix the auroraux buildbot. I suspect it has a "#define SEC" somewhere. llvm-svn: 96577
2010-02-18 21:02:13 +08:00
return Ctx.IsStructurallyEquivalent(From, To);
Cope with anonymous tags defined within declarators by structurally comparing their types under the assumption that they are equivalent, rather than importing the types and then checking for compatibility. A few minor tweaks here: - Teach structural matching to handle compatibility between function types with prototypes and those without prototypes. - Teach structural matching that an incomplete record decl is the same as any other record decl with the same name. - Keep track of pairs of declarations that we have already checked (but failed to find as structurally matching), so we don't emit diagnostics repeatedly. - When importing a typedef of an anonymous tag, be sure to link the imported tag type to its typedef. With these changes, we survive a repeated import of <stdlib.h> and <stdio.h>. Alas, the ASTNodeImporter is getting a little grotty. llvm-svn: 96298
2010-02-16 07:54:17 +08:00
}