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

876 lines
30 KiB
C++
Raw Normal View History

move ASTBuilder.h/cpp to be a private Sema.h/cpp files, not part of the interface exported by libast. llvm-svn: 39154
2006-11-10 12:58:55 +08:00
//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
Start adding support for printing out parser callbacks and adding ast building llvm-svn: 38933
2006-08-17 13:51:27 +08:00
//
// The LLVM Compiler Infrastructure
//
Don't attribute in file headers anymore. See llvmdev for the discussion of this change. llvm-svn: 45410
2007-12-30 03:59:25 +08:00
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
Start adding support for printing out parser callbacks and adding ast building llvm-svn: 38933
2006-08-17 13:51:27 +08:00
//
//===----------------------------------------------------------------------===//
//
move ASTBuilder.h/cpp to be a private Sema.h/cpp files, not part of the interface exported by libast. llvm-svn: 39154
2006-11-10 12:58:55 +08:00
// This file implements the actions class which performs semantic analysis and
// builds an AST out of a parse stream.
Start adding support for printing out parser callbacks and adding ast building llvm-svn: 38933
2006-08-17 13:51:27 +08:00
//
//===----------------------------------------------------------------------===//
move ASTBuilder.h/cpp to be a private Sema.h/cpp files, not part of the interface exported by libast. llvm-svn: 39154
2006-11-10 12:58:55 +08:00
#include "Sema.h"
PR3679 - handle #pragma weak llvm-svn: 77573
2009-07-30 11:15:39 +08:00
#include "llvm/ADT/DenseMap.h"
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
#include "llvm/ADT/APFloat.h"
Explictly track tentative definitions within Sema, then hand those tentative definitions off to the ASTConsumer at the end of the translation unit. Eliminate CodeGen's internal tracking of tentative definitions, and instead hook into ASTConsumer::CompleteTentativeDefinition. Also, tweak the definition-deferal logic for C++, where there are no tentative definitions. Fixes <rdar://problem/6808352>, and will make it much easier for precompiled headers to cope with tentative definitions in the future. llvm-svn: 69681
2009-04-22 01:11:58 +08:00
#include "clang/AST/ASTConsumer.h"
introduce a new ASTContext class to hold long-lived ast nodes. llvm-svn: 39161
2006-11-10 14:20:45 +08:00
#include "clang/AST/ASTContext.h"
More #include cleaning - Drop {Decl.h,DeclObjC.h,IdentifierTable.h} from Expr.h - Moved Sema::getCurMethodDecl() out of line (dependent on ObjCMethodDecl via dyn_cast). llvm-svn: 54629
2008-08-11 13:35:13 +08:00
#include "clang/AST/DeclObjC.h"
More #include cleaning - Drop Expr.h,RecordLayout.h from ASTContext.h (for DeclBase.h and SourceLocation.h) - Move ASTContext constructor into implementation llvm-svn: 54627
2008-08-11 12:54:23 +08:00
#include "clang/AST/Expr.h"
Initial support for semantic analysis and AST building for StringExpr nodes. llvm-svn: 38960
2006-10-06 13:22:26 +08:00
#include "clang/Lex/Preprocessor.h"
Add a RequireCompleteType variant that takes a PartialDiagnostic. The old RequireCompleteType now creates a PartialDiagnostic and calls the new function. llvm-svn: 80165
2009-08-27 06:33:56 +08:00
#include "clang/Basic/PartialDiagnostic.h"
only support int128_t on 64-bit and larger targets. 32-bit targets don't have support for __divti3 and friends. llvm-svn: 70480
2009-04-30 14:18:40 +08:00
#include "clang/Basic/TargetInfo.h"
Implement first cut of ASTBuilder class. llvm-svn: 38938
2006-08-18 13:17:52 +08:00
using namespace clang;
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
/// Determines whether we should have an a.k.a. clause when
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
/// pretty-printing a type. There are three main criteria:
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
///
/// 1) Some types provide very minimal sugar that doesn't impede the
/// user's understanding --- for example, elaborated type
/// specifiers. If this is all the sugar we see, we don't want an
/// a.k.a. clause.
/// 2) Some types are technically sugared but are much more familiar
/// when seen in their sugared form --- for example, va_list,
/// vector types, and the magic Objective C types. We don't
/// want to desugar these, even if we do produce an a.k.a. clause.
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
/// 3) Some types may have already been desugared previously in this diagnostic.
/// if this is the case, doing another "aka" would just be clutter.
///
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
static bool ShouldAKA(ASTContext &Context, QualType QT,
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
const Diagnostic::ArgumentValue *PrevArgs,
unsigned NumPrevArgs,
QualType &DesugaredQT) {
QualType InputTy = QT;
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
bool AKA = false;
QualifierCollector Qc;
while (true) {
const Type *Ty = Qc.strip(QT);
// Don't aka just because we saw an elaborated type...
if (isa<ElaboratedType>(Ty)) {
QT = cast<ElaboratedType>(Ty)->desugar();
continue;
}
// ...or a qualified name type...
if (isa<QualifiedNameType>(Ty)) {
QT = cast<QualifiedNameType>(Ty)->desugar();
continue;
}
// ...or a substituted template type parameter.
if (isa<SubstTemplateTypeParmType>(Ty)) {
QT = cast<SubstTemplateTypeParmType>(Ty)->desugar();
continue;
}
// Don't desugar template specializations.
if (isa<TemplateSpecializationType>(Ty))
break;
// Don't desugar magic Objective-C types.
if (QualType(Ty,0) == Context.getObjCIdType() ||
QualType(Ty,0) == Context.getObjCClassType() ||
QualType(Ty,0) == Context.getObjCSelType() ||
QualType(Ty,0) == Context.getObjCProtoType())
break;
// Don't desugar va_list.
if (QualType(Ty,0) == Context.getBuiltinVaListType())
break;
// Otherwise, do a single-step desugar.
QualType Underlying;
bool IsSugar = false;
switch (Ty->getTypeClass()) {
#define ABSTRACT_TYPE(Class, Base)
#define TYPE(Class, Base) \
case Type::Class: { \
const Class##Type *CTy = cast<Class##Type>(Ty); \
if (CTy->isSugared()) { \
IsSugar = true; \
Underlying = CTy->desugar(); \
} \
break; \
}
#include "clang/AST/TypeNodes.def"
}
// If it wasn't sugared, we're done.
if (!IsSugar)
break;
// If the desugared type is a vector type, we don't want to expand
// it, it will turn into an attribute mess. People want their "vec4".
if (isa<VectorType>(Underlying))
break;
// Otherwise, we're tearing through something opaque; note that
// we'll eventually need an a.k.a. clause and keep going.
AKA = true;
QT = Underlying;
continue;
}
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
// If we never tore through opaque sugar, don't print aka.
if (!AKA) return false;
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
// If we did, check to see if we already desugared this type in this
// diagnostic. If so, don't do it again.
for (unsigned i = 0; i != NumPrevArgs; ++i) {
// TODO: Handle ak_declcontext case.
if (PrevArgs[i].first == Diagnostic::ak_qualtype) {
void *Ptr = (void*)PrevArgs[i].second;
QualType PrevTy(QualType::getFromOpaquePtr(Ptr));
if (PrevTy == InputTy)
return false;
}
}
DesugaredQT = Qc.apply(QT);
return true;
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
}
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
/// \brief Convert the given type to a string suitable for printing as part of
/// a diagnostic.
///
/// \param Context the context in which the type was allocated
/// \param Ty the type to print
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
static std::string
ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty,
const Diagnostic::ArgumentValue *PrevArgs,
unsigned NumPrevArgs) {
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
// FIXME: Playing with std::string is really slow.
std::string S = Ty.getAsString(Context.PrintingPolicy);
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
// Consider producing an a.k.a. clause if removing all the direct
// sugar gives us something "significantly different".
QualType DesugaredTy;
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
if (ShouldAKA(Context, Ty, PrevArgs, NumPrevArgs, DesugaredTy)) {
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
S = "'"+S+"' (aka '";
S += DesugaredTy.getAsString(Context.PrintingPolicy);
S += "')";
return S;
}
S = "'" + S + "'";
return S;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// ConvertQualTypeToStringFn - This function is used to pretty print the
Add support for sending QualType's directly into diags and convert two diags over to use this. QualTypes implicitly print single quotes around them for uniformity and future extension. Doing this requires a little function pointer dance to prevent libbasic from depending on libast. llvm-svn: 59907
2008-11-23 17:13:29 +08:00
/// specified QualType as a string in diagnostics.
add support for inserting a DeclarationName into a diagnostic directly without calling getAsString(). This implicitly puts quotes around the name, so diagnostics need to be tweaked to accommodate this. llvm-svn: 59916
2008-11-24 04:28:15 +08:00
static void ConvertArgToStringFn(Diagnostic::ArgumentKind Kind, intptr_t Val,
Fix a long standard problem with clang retaining "too much" sugar information about types. We often print diagnostics where we say "foo_t" is bad, but the user doesn't know how foo_t is declared (because it is a typedef). Fix this by expanding sugar when present in a diagnostic (and not one of a few special cases, like vectors). Before: t.m:5:2: error: invalid operands to binary expression ('typeof(P)' and 'typeof(F)') MAX(P, F); ^~~~~~~~~ t.m:1:78: note: instantiated from: #define MAX(A,B) ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; }) ^ After: t.m:5:2: error: invalid operands to binary expression ('typeof(P)' (aka 'struct mystruct') and 'typeof(F)' (aka 'float')) MAX(P, F); ^~~~~~~~~ t.m:1:78: note: instantiated from: #define MAX(A,B) ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; }) ^ llvm-svn: 65081
2009-02-20 07:45:49 +08:00
const char *Modifier, unsigned ModLen,
const char *Argument, unsigned ArgLen,
teach FormatDiagnostic to aggregate previously formatted arguments and pass them down into the ArgToStringFn implementation. This allows redundancy across operands to a diagnostic to be eliminated. This isn't used yet, so no functionality change. llvm-svn: 84602
2009-10-20 13:25:22 +08:00
const Diagnostic::ArgumentValue *PrevArgs,
unsigned NumPrevArgs,
replace a dirty hack with a clean solution. Too bad we can't use Blocks for our callbacks ;-) llvm-svn: 65083
2009-02-20 07:53:20 +08:00
llvm::SmallVectorImpl<char> &Output,
void *Cookie) {
ASTContext &Context = *static_cast<ASTContext*>(Cookie);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add support for inserting a DeclarationName into a diagnostic directly without calling getAsString(). This implicitly puts quotes around the name, so diagnostics need to be tweaked to accommodate this. llvm-svn: 59916
2008-11-24 04:28:15 +08:00
std::string S;
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
bool NeedQuotes = true;
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
switch (Kind) {
default: assert(0 && "unknown ArgumentKind");
case Diagnostic::ak_qualtype: {
Fix a long standard problem with clang retaining "too much" sugar information about types. We often print diagnostics where we say "foo_t" is bad, but the user doesn't know how foo_t is declared (because it is a typedef). Fix this by expanding sugar when present in a diagnostic (and not one of a few special cases, like vectors). Before: t.m:5:2: error: invalid operands to binary expression ('typeof(P)' and 'typeof(F)') MAX(P, F); ^~~~~~~~~ t.m:1:78: note: instantiated from: #define MAX(A,B) ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; }) ^ After: t.m:5:2: error: invalid operands to binary expression ('typeof(P)' (aka 'struct mystruct') and 'typeof(F)' (aka 'float')) MAX(P, F); ^~~~~~~~~ t.m:1:78: note: instantiated from: #define MAX(A,B) ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; }) ^ llvm-svn: 65081
2009-02-20 07:45:49 +08:00
assert(ModLen == 0 && ArgLen == 0 &&
"Invalid modifier for QualType argument");
add support for inserting a DeclarationName into a diagnostic directly without calling getAsString(). This implicitly puts quotes around the name, so diagnostics need to be tweaked to accommodate this. llvm-svn: 59916
2008-11-24 04:28:15 +08:00
QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val)));
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
S = ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, NumPrevArgs);
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
NeedQuotes = false;
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
break;
}
case Diagnostic::ak_declarationname: {
add support for inserting a DeclarationName into a diagnostic directly without calling getAsString(). This implicitly puts quotes around the name, so diagnostics need to be tweaked to accommodate this. llvm-svn: 59916
2008-11-24 04:28:15 +08:00
DeclarationName N = DeclarationName::getFromOpaqueInteger(Val);
S = N.getAsString();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename Selector::getName() to Selector::getAsString(), and add a new NamedDecl::getAsString() method. Change uses of Selector::getName() to just pass in a Selector where possible (e.g. to diagnostics) instead of going through an std::string. This also adds new formatters for objcinstance and objcclass as described in the dox. llvm-svn: 59933
2008-11-24 11:33:13 +08:00
if (ModLen == 9 && !memcmp(Modifier, "objcclass", 9) && ArgLen == 0)
S = '+' + S;
else if (ModLen == 12 && !memcmp(Modifier, "objcinstance", 12) && ArgLen==0)
S = '-' + S;
else
assert(ModLen == 0 && ArgLen == 0 &&
"Invalid modifier for DeclarationName argument");
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
break;
}
case Diagnostic::ak_nameddecl: {
When stringizing a NamedDecl for a diagnostic, treat the template specialization types differently. llvm-svn: 81512
2009-09-11 14:45:03 +08:00
bool Qualified;
Implement semantic analysis for the GNU flexible array initialization extension. The interaction with designated initializers is a bit... interesting... but we follow GNU's lead and don't permit too much crazy code in this area. Also, make the "excess initializers" error message a bit more informative. Addresses PR2561: http://llvm.org/bugs/show_bug.cgi?id=2561 llvm-svn: 63785
2009-02-05 06:46:25 +08:00
if (ModLen == 1 && Modifier[0] == 'q' && ArgLen == 0)
When stringizing a NamedDecl for a diagnostic, treat the template specialization types differently. llvm-svn: 81512
2009-09-11 14:45:03 +08:00
Qualified = true;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
else {
Implement semantic analysis for the GNU flexible array initialization extension. The interaction with designated initializers is a bit... interesting... but we follow GNU's lead and don't permit too much crazy code in this area. Also, make the "excess initializers" error message a bit more informative. Addresses PR2561: http://llvm.org/bugs/show_bug.cgi?id=2561 llvm-svn: 63785
2009-02-05 06:46:25 +08:00
assert(ModLen == 0 && ArgLen == 0 &&
Some name-lookup-related fixes, from Piotr Rak! - Changes Lookup*Name functions to return NamedDecls, instead of Decls. Unfortunately my recent statement that it will simplify lot of code, was not quite right, but it simplifies some... - Makes MergeLookupResult SmallPtrSet instead of vector, following Douglas suggestions. - Adds %qN format for printing qualified names to Diagnostic. - Avoids searching for using-directives in Scopes, which are not DeclScope, during unqualified name lookup. llvm-svn: 63739
2009-02-05 01:27:36 +08:00
"Invalid modifier for NamedDecl* argument");
When stringizing a NamedDecl for a diagnostic, treat the template specialization types differently. llvm-svn: 81512
2009-09-11 14:45:03 +08:00
Qualified = false;
Implement semantic analysis for the GNU flexible array initialization extension. The interaction with designated initializers is a bit... interesting... but we follow GNU's lead and don't permit too much crazy code in this area. Also, make the "excess initializers" error message a bit more informative. Addresses PR2561: http://llvm.org/bugs/show_bug.cgi?id=2561 llvm-svn: 63785
2009-02-05 06:46:25 +08:00
}
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
reinterpret_cast<NamedDecl*>(Val)->
getNameForDiagnostic(S, Context.PrintingPolicy, Qualified);
break;
}
case Diagnostic::ak_nestednamespec: {
Improve diagnostics and recovery when the nested-name-specifier of a qualified name does not actually refer into a class/class template/class template partial specialization. Improve printing of nested-name-specifiers to eliminate redudant qualifiers. Also, make it possible to output a nested-name-specifier through a DiagnosticBuilder, although there are relatively few places that will use this leeway. llvm-svn: 80056
2009-08-26 08:04:55 +08:00
llvm::raw_string_ostream OS(S);
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
reinterpret_cast<NestedNameSpecifier*>(Val)->print(OS,
Context.PrintingPolicy);
Improve diagnostics when the parser encounters a declarator with an unknown type name, e.g., foo::bar x; when "bar" does not refer to a type in "foo". With this change, the parser now calls into the action to perform diagnostics and can try to recover by substituting in an appropriate type. For example, this allows us to easily diagnose some missing "typename" specifiers, which we now do: test/SemaCXX/unknown-type-name.cpp:29:1: error: missing 'typename' prior to dependent type name 'A<T>::type' A<T>::type A<T>::f() { return type(); } ^~~~~~~~~~ typename Fixes PR3990. llvm-svn: 84053
2009-10-14 07:27:22 +08:00
NeedQuotes = false;
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
break;
}
case Diagnostic::ak_declcontext: {
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
DeclContext *DC = reinterpret_cast<DeclContext *> (Val);
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
assert(DC && "Should never have a null declaration context");
if (DC->isTranslationUnit()) {
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
// FIXME: Get these strings from some localized place
if (Context.getLangOptions().CPlusPlus)
S = "the global namespace";
else
S = "the global scope";
} else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) {
Implement PR5242: don't desugar a type more than once in a diagnostic. This implements a framework that allows us to use information about previously substituted values to simplify subsequent ones. Maybe this would be useful for C++'y stuff, who knows. We now get: t.c:4:21: error: invalid operands to binary expression ('size_t' (aka 'unsigned long *') and 'size_t') return (size_t) 0 + (size_t) 0; ~~~~~~~~~~ ^ ~~~~~~~~~~ on the testcase. Note that size_t is only aka'd once. llvm-svn: 84604
2009-10-20 13:36:05 +08:00
S = ConvertTypeToDiagnosticString(Context, Context.getTypeDeclType(Type),
PrevArgs, NumPrevArgs);
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
} else {
// FIXME: Get these strings from some localized place
NamedDecl *ND = cast<NamedDecl>(DC);
if (isa<NamespaceDecl>(ND))
S += "namespace ";
else if (isa<ObjCMethodDecl>(ND))
S += "method ";
else if (isa<FunctionDecl>(ND))
S += "function ";
S += "'";
ND->getNameForDiagnostic(S, Context.PrintingPolicy, true);
S += "'";
}
code cleanup, convert if tree to switch etc. llvm-svn: 84599
2009-10-20 13:12:36 +08:00
NeedQuotes = false;
break;
}
add support for inserting a DeclarationName into a diagnostic directly without calling getAsString(). This implicitly puts quotes around the name, so diagnostics need to be tweaked to accommodate this. llvm-svn: 59916
2008-11-24 04:28:15 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
if (NeedQuotes)
Output.push_back('\'');
Add support for sending QualType's directly into diags and convert two diags over to use this. QualTypes implicitly print single quotes around them for uniformity and future extension. Doing this requires a little function pointer dance to prevent libbasic from depending on libast. llvm-svn: 59907
2008-11-23 17:13:29 +08:00
Output.append(S.begin(), S.end());
Unify our diagnostic printing for errors of the form, "we didn't like what we found when we looked into <blah>", where <blah> is a DeclContext*. We can now format DeclContext*'s in nice ways, e.g., "namespace N", "the global namespace", "'class Foo'". This is part of PR3990, but we're not quite there yet. llvm-svn: 84028
2009-10-14 05:16:44 +08:00
if (NeedQuotes)
Output.push_back('\'');
Add support for sending QualType's directly into diags and convert two diags over to use this. QualTypes implicitly print single quotes around them for uniformity and future extension. Doing this requires a little function pointer dance to prevent libbasic from depending on libast. llvm-svn: 59907
2008-11-23 17:13:29 +08:00
}
This reworks some of the Diagnostic interfaces a bit to change how diagnostics are formed. In particular, a diagnostic with all its strings and ranges is now packaged up and sent to DiagnosticClients as a DiagnosticInfo instead of as a ton of random stuff. This has the benefit of simplifying the interface, making it more extensible, and allowing us to do more checking for things like access past the end of the various arrays passed in. In addition to introducing DiagnosticInfo, this also substantially changes how Diagnostic::Report works. Instead of being passed in all of the info required to issue a diagnostic, Report now takes only the required info (a location and ID) and returns a fresh DiagnosticInfo *by value*. The caller is then free to stuff strings and ranges into the DiagnosticInfo with the << operator. When the dtor runs on the DiagnosticInfo object (which should happen at the end of the statement), the diagnostic is actually emitted with all of the accumulated information. This is a somewhat tricky dance, but it means that the accumulated DiagnosticInfo is allowed to keep pointers to other expression temporaries without those pointers getting invalidated. This is just the minimal change to get this stuff working, but this will allow us to eliminate the zillions of variant "Diag" methods scattered throughout (e.g.) sema. For example, instead of calling: Diag(BuiltinLoc, diag::err_overload_no_match, typeNames, SourceRange(BuiltinLoc, RParenLoc)); We will soon be able to just do: Diag(BuiltinLoc, diag::err_overload_no_match) << typeNames << SourceRange(BuiltinLoc, RParenLoc)); This scales better to support arbitrary types being passed in (not just strings) in a type-safe way. Go operator overloading?! llvm-svn: 59502
2008-11-18 15:04:44 +08:00
static inline RecordDecl *CreateStructDecl(ASTContext &C, const char *Name) {
Make sure to create CXX record decls for the implicit Obj-C type declarations. This lets us compile Cocoa.h as Objective-C++ llvm-svn: 55261
2008-08-24 06:20:38 +08:00
if (C.getLangOptions().CPlusPlus)
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
return CXXRecordDecl::Create(C, TagDecl::TK_struct,
Make sure to create CXX record decls for the implicit Obj-C type declarations. This lets us compile Cocoa.h as Objective-C++ llvm-svn: 55261
2008-08-24 06:20:38 +08:00
C.getTranslationUnitDecl(),
Remove "NextDecl" from RecordDecl. This change touches many files that where RecordDecl or CXXRecordDecl was constructed, always with an argument of 'NULL' for the previous declaration. The motivation behind this change is that chaining the RecordDecls is simply unnecessary. Once we create multiple RecordDecls for the same struct/union/class, clients that care about all the declarations of the same struct can build a back map by seeing which Decls refer to the same RecordType. llvm-svn: 55821
2008-09-05 09:34:33 +08:00
SourceLocation(), &C.Idents.get(Name));
Switch several more Sema Diag methods over. This simplifies the __builtin_prefetch code to only emit one diagnostic per builtin_prefetch. While this has nothing to do with the rest of the patch, the code seemed like overkill when I was updating it. llvm-svn: 59588
2008-11-19 13:08:23 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
return RecordDecl::Create(C, TagDecl::TK_struct,
Switch several more Sema Diag methods over. This simplifies the __builtin_prefetch code to only emit one diagnostic per builtin_prefetch. While this has nothing to do with the rest of the patch, the code seemed like overkill when I was updating it. llvm-svn: 59588
2008-11-19 13:08:23 +08:00
C.getTranslationUnitDecl(),
SourceLocation(), &C.Idents.get(Name));
Make sure to create CXX record decls for the implicit Obj-C type declarations. This lets us compile Cocoa.h as Objective-C++ llvm-svn: 55261
2008-08-24 06:20:38 +08:00
}
Implement a more sensible strategy for ObjC built-in types (addressing a long standing FIXME in Sema::GetObjcIdType()). This removes several gross hacks to work around the previous "lazy" behavior. Two notes: - MinimalActions still needs to be taught about the built-in types (This breaks one of the -noop test cases). I started this, then added a FIXME. - I didn't convert Sema::GetObjcProtoType() yet. llvm-svn: 43567
2007-11-01 02:42:27 +08:00
void Sema::ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) {
TUScope = S;
Unifies the name-lookup mechanisms used in various parts of the AST and separates lexical name lookup from qualified name lookup. In particular: * Make DeclContext the central data structure for storing and looking up declarations within existing declarations, e.g., members of structs/unions/classes, enumerators in C++0x enums, members of C++ namespaces, and (later) members of Objective-C interfaces/implementations. DeclContext uses a lazily-constructed data structure optimized for fast lookup (array for small contexts, hash table for larger contexts). * Implement C++ qualified name lookup in terms of lookup into DeclContext. * Implement C++ unqualified name lookup in terms of qualified+unqualified name lookup (since unqualified lookup is not purely lexical in C++!) * Limit the use of the chains of declarations stored in IdentifierInfo to those names declared lexically. * Eliminate CXXFieldDecl, collapsing its behavior into FieldDecl. (FieldDecl is now a ScopedDecl). * Make RecordDecl into a DeclContext and eliminates its Members/NumMembers fields (since one can just iterate through the DeclContext to get the fields). llvm-svn: 60878
2008-12-12 00:49:14 +08:00
PushDeclContext(S, Context.getTranslationUnitDecl());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
only support int128_t on 64-bit and larger targets. 32-bit targets don't have support for __divti3 and friends. llvm-svn: 70480
2009-04-30 14:18:40 +08:00
if (PP.getTargetInfo().getPointerWidth(0) >= 64) {
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TypeSourceInfo *TInfo;
Preserve type source information in TypedefDecls. Preserve it across template instantiation. Preserve it through PCH. Show it off to the indexer. I'm healthily ignoring the vector type cases because we don't have a sensible TypeLoc implementation for them anyway. llvm-svn: 84994
2009-10-24 16:00:42 +08:00
only support int128_t on 64-bit and larger targets. 32-bit targets don't have support for __divti3 and friends. llvm-svn: 70480
2009-04-30 14:18:40 +08:00
// Install [u]int128_t for 64-bit targets.
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TInfo = Context.getTrivialTypeSourceInfo(Context.Int128Ty);
only support int128_t on 64-bit and larger targets. 32-bit targets don't have support for __divti3 and friends. llvm-svn: 70480
2009-04-30 14:18:40 +08:00
PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
SourceLocation(),
&Context.Idents.get("__int128_t"),
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TInfo), TUScope);
Preserve type source information in TypedefDecls. Preserve it across template instantiation. Preserve it through PCH. Show it off to the indexer. I'm healthily ignoring the vector type cases because we don't have a sensible TypeLoc implementation for them anyway. llvm-svn: 84994
2009-10-24 16:00:42 +08:00
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TInfo = Context.getTrivialTypeSourceInfo(Context.UnsignedInt128Ty);
only support int128_t on 64-bit and larger targets. 32-bit targets don't have support for __divti3 and friends. llvm-svn: 70480
2009-04-30 14:18:40 +08:00
PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
SourceLocation(),
&Context.Idents.get("__uint128_t"),
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TInfo), TUScope);
only support int128_t on 64-bit and larger targets. 32-bit targets don't have support for __divti3 and friends. llvm-svn: 70480
2009-04-30 14:18:40 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
pass the astconsumer into Sema's ctor, clean up some stuff in Sema::ActOnTranslationUnitScope. The various ObjC pieces at the top of Sema.cpp should be moved into SemaObjC or something. llvm-svn: 46787
2008-02-06 08:46:58 +08:00
if (!PP.getLangOptions().ObjC1) return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add a comment to Sema::ActOnTranslationUnitScope(). llvm-svn: 73450
2009-06-16 08:20:10 +08:00
// Built-in ObjC types may already be set by PCHReader (hence isNull checks).
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
if (Context.getObjCSelType().isNull()) {
This patch implements objective-c's 'SEL' type as a built-in type and fixes a long-standing code gen. crash reported in at least two PRs and a radar. (radar 7405040 and pr5025). There are couple of remaining issues that I would like for Ted. and Doug to look at: Ted, please look at failure in Analysis/MissingDealloc.m. I have temporarily added an expected-warning to make the test pass. This tests has a declaration of 'SEL' type which may not co-exist with the new changes. Doug, please look at a FIXME in PCHWriter.cpp/PCHReader.cpp. I think the changes which I have ifdef'ed out are correct. They need be considered for in a few Indexer/PCH test cases. llvm-svn: 89561
2009-11-22 03:53:08 +08:00
// Create the built-in typedef for 'SEL'.
Make 'SEL' pointer to a builtin type and not an objective-c pointer type. This was a serious mishap and luckily, Ted's test caught that (and patch fixes the test case). llvm-svn: 89680
2009-11-24 02:04:25 +08:00
QualType SelT = Context.getPointerType(Context.ObjCBuiltinSelTy);
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TypeSourceInfo *SelInfo = Context.getTrivialTypeSourceInfo(SelT);
Preserve type source information in TypedefDecls. Preserve it across template instantiation. Preserve it through PCH. Show it off to the indexer. I'm healthily ignoring the vector type cases because we don't have a sensible TypeLoc implementation for them anyway. llvm-svn: 84994
2009-10-24 16:00:42 +08:00
TypedefDecl *SelTypedef
= TypedefDecl::Create(Context, CurContext, SourceLocation(),
&Context.Idents.get("SEL"), SelInfo);
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
PushOnScopeChains(SelTypedef, TUScope);
Context.setObjCSelType(Context.getTypeDeclType(SelTypedef));
Allow user re-definition of SEL as well as accessing its fields. This fixes pr5611. llvm-svn: 89895
2009-11-26 07:07:42 +08:00
Context.ObjCSelRedefinitionType = Context.getObjCSelType();
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
}
"This moves built-in Objective-C types up the scope chains to where they can be replaced by versions included from the runtime library's headers." This makes it ok to use @"foo" without a declaration for NSConstantString. Patch by David Chisnall! llvm-svn: 52593
2008-06-22 04:20:39 +08:00
// Synthesize "@class Protocol;
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
if (Context.getObjCProtoType().isNull()) {
ObjCInterfaceDecl *ProtocolDecl =
ObjCInterfaceDecl::Create(Context, CurContext, SourceLocation(),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
&Context.Idents.get("Protocol"),
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
SourceLocation(), true);
Context.setObjCProtoType(Context.getObjCInterfaceType(ProtocolDecl));
Do not enter forward class 'Protocol' in decl context. Will do it later. Fixes pr5552. llvm-svn: 89269
2009-11-19 07:15:37 +08:00
PushOnScopeChains(ProtocolDecl, TUScope, false);
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
}
Implement the ObjC pseudo built-in types as clang "BuiltinType's". I say pseudo built-in types, since Sema still injects a typedef for recognition (i.e. they aren't truly built-ins from a parser perspective). This removes the static data/methods on ObjCObjectPointerType while preserving the nice API (no need to fiddle with ASTContext:-). This patch also adds Type::isObjCBuiltinType(). This should be the last fairly large patch related to recrafting the ObjC type system. The follow-on patches should be fairly small. llvm-svn: 75808
2009-07-16 02:40:39 +08:00
// Create the built-in typedef for 'id'.
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
if (Context.getObjCIdType().isNull()) {
Preserve type source information in TypedefDecls. Preserve it across template instantiation. Preserve it through PCH. Show it off to the indexer. I'm healthily ignoring the vector type cases because we don't have a sensible TypeLoc implementation for them anyway. llvm-svn: 84994
2009-10-24 16:00:42 +08:00
QualType IdT = Context.getObjCObjectPointerType(Context.ObjCBuiltinIdTy);
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TypeSourceInfo *IdInfo = Context.getTrivialTypeSourceInfo(IdT);
Preserve type source information in TypedefDecls. Preserve it across template instantiation. Preserve it through PCH. Show it off to the indexer. I'm healthily ignoring the vector type cases because we don't have a sensible TypeLoc implementation for them anyway. llvm-svn: 84994
2009-10-24 16:00:42 +08:00
TypedefDecl *IdTypedef
= TypedefDecl::Create(Context, CurContext, SourceLocation(),
&Context.Idents.get("id"), IdInfo);
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
PushOnScopeChains(IdTypedef, TUScope);
Context.setObjCIdType(Context.getTypeDeclType(IdTypedef));
Initial patch to support definitions of id and Class from headers in Objective-C code. This currently breaks test/SemaObjC/id-isa-ref.m and issues some spurious warnings when you attempt to assign a struct objc_class* value to a Class variable. The test case probably should fail as it's written, because without the definition of Class the compiler should not assume struct objc_class* is a valid receiver type, but it's left broken because it would be nice if we could get that passing too for the special case of isa. Approved by snaroff. llvm-svn: 79248
2009-08-18 00:35:33 +08:00
Context.ObjCIdRedefinitionType = Context.getObjCIdType();
PCH support for all of the predefined Objective-C types, such as id, SEL, Class, Protocol, CFConstantString, and __objcFastEnumerationState. With this, we can now run the Objective-C methods and properties PCH tests. llvm-svn: 69932
2009-04-24 06:29:11 +08:00
}
Implement the ObjC pseudo built-in types as clang "BuiltinType's". I say pseudo built-in types, since Sema still injects a typedef for recognition (i.e. they aren't truly built-ins from a parser perspective). This removes the static data/methods on ObjCObjectPointerType while preserving the nice API (no need to fiddle with ASTContext:-). This patch also adds Type::isObjCBuiltinType(). This should be the last fairly large patch related to recrafting the ObjC type system. The follow-on patches should be fairly small. llvm-svn: 75808
2009-07-16 02:40:39 +08:00
// Create the built-in typedef for 'Class'.
This patch includes a conceptually simple, but very intrusive/pervasive change. The idea is to segregate Objective-C "object" pointers from general C pointers (utilizing the recently added ObjCObjectPointerType). The fun starts in Sema::GetTypeForDeclarator(), where "SomeInterface *" is now represented by a single AST node (rather than a PointerType whose Pointee is an ObjCInterfaceType). Since a significant amount of code assumed ObjC object pointers where based on C pointers/structs, this patch is very tedious. It should also explain why it is hard to accomplish this in smaller, self-contained patches. This patch does most of the "heavy lifting" related to moving from PointerType->ObjCObjectPointerType. It doesn't include all potential "cleanups". The good news is additional cleanups can be done later (some are noted in the code). This patch is so large that I didn't want to include any changes that are purely aesthetic. By making the ObjC types truly built-in, they are much easier to work with (and require fewer "hacks"). For example, there is no need for ASTContext::isObjCIdStructType() or ASTContext::isObjCClassStructType()! We believe this change (and the follow-up cleanups) will pay dividends over time. Given the amount of code change, I do expect some fallout from this change (though it does pass all of the clang tests). If you notice any problems, please let us know asap! Thanks. llvm-svn: 75314
2009-07-11 07:34:53 +08:00
if (Context.getObjCClassType().isNull()) {
Preserve type source information in TypedefDecls. Preserve it across template instantiation. Preserve it through PCH. Show it off to the indexer. I'm healthily ignoring the vector type cases because we don't have a sensible TypeLoc implementation for them anyway. llvm-svn: 84994
2009-10-24 16:00:42 +08:00
QualType ClassType
= Context.getObjCObjectPointerType(Context.ObjCBuiltinClassTy);
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TypeSourceInfo *ClassInfo = Context.getTrivialTypeSourceInfo(ClassType);
Preserve type source information in TypedefDecls. Preserve it across template instantiation. Preserve it through PCH. Show it off to the indexer. I'm healthily ignoring the vector type cases because we don't have a sensible TypeLoc implementation for them anyway. llvm-svn: 84994
2009-10-24 16:00:42 +08:00
TypedefDecl *ClassTypedef
= TypedefDecl::Create(Context, CurContext, SourceLocation(),
&Context.Idents.get("Class"), ClassInfo);
This patch includes a conceptually simple, but very intrusive/pervasive change. The idea is to segregate Objective-C "object" pointers from general C pointers (utilizing the recently added ObjCObjectPointerType). The fun starts in Sema::GetTypeForDeclarator(), where "SomeInterface *" is now represented by a single AST node (rather than a PointerType whose Pointee is an ObjCInterfaceType). Since a significant amount of code assumed ObjC object pointers where based on C pointers/structs, this patch is very tedious. It should also explain why it is hard to accomplish this in smaller, self-contained patches. This patch does most of the "heavy lifting" related to moving from PointerType->ObjCObjectPointerType. It doesn't include all potential "cleanups". The good news is additional cleanups can be done later (some are noted in the code). This patch is so large that I didn't want to include any changes that are purely aesthetic. By making the ObjC types truly built-in, they are much easier to work with (and require fewer "hacks"). For example, there is no need for ASTContext::isObjCIdStructType() or ASTContext::isObjCClassStructType()! We believe this change (and the follow-up cleanups) will pay dividends over time. Given the amount of code change, I do expect some fallout from this change (though it does pass all of the clang tests). If you notice any problems, please let us know asap! Thanks. llvm-svn: 75314
2009-07-11 07:34:53 +08:00
PushOnScopeChains(ClassTypedef, TUScope);
Context.setObjCClassType(Context.getTypeDeclType(ClassTypedef));
Initial patch to support definitions of id and Class from headers in Objective-C code. This currently breaks test/SemaObjC/id-isa-ref.m and issues some spurious warnings when you attempt to assign a struct objc_class* value to a Class variable. The test case probably should fail as it's written, because without the definition of Class the compiler should not assume struct objc_class* is a valid receiver type, but it's left broken because it would be nice if we could get that passing too for the special case of isa. Approved by snaroff. llvm-svn: 79248
2009-08-18 00:35:33 +08:00
Context.ObjCClassRedefinitionType = Context.getObjCClassType();
This patch includes a conceptually simple, but very intrusive/pervasive change. The idea is to segregate Objective-C "object" pointers from general C pointers (utilizing the recently added ObjCObjectPointerType). The fun starts in Sema::GetTypeForDeclarator(), where "SomeInterface *" is now represented by a single AST node (rather than a PointerType whose Pointee is an ObjCInterfaceType). Since a significant amount of code assumed ObjC object pointers where based on C pointers/structs, this patch is very tedious. It should also explain why it is hard to accomplish this in smaller, self-contained patches. This patch does most of the "heavy lifting" related to moving from PointerType->ObjCObjectPointerType. It doesn't include all potential "cleanups". The good news is additional cleanups can be done later (some are noted in the code). This patch is so large that I didn't want to include any changes that are purely aesthetic. By making the ObjC types truly built-in, they are much easier to work with (and require fewer "hacks"). For example, there is no need for ASTContext::isObjCIdStructType() or ASTContext::isObjCClassStructType()! We believe this change (and the follow-up cleanups) will pay dividends over time. Given the amount of code change, I do expect some fallout from this change (though it does pass all of the clang tests). If you notice any problems, please let us know asap! Thanks. llvm-svn: 75314
2009-07-11 07:34:53 +08:00
}
Patch to implement AST generation for objective-c's @selector expression. llvm-svn: 43038
2007-10-17 04:40:23 +08:00
}
- Make sure default return/argument types (for methods) default to "id". - Cache the "id" type in Sema...initialize ObjcIdType and TUScope (oops). - Fix ActOnInstanceMessage to allow for "id" type receivers...still work to do (next). llvm-svn: 42842
2007-10-11 05:53:07 +08:00
When building a PCH file, don't perform end-of-translation-unit wrap-up (e.g., turning tentative definitions into definitions). Also, very that, when we actually use the PCH file, we get the ride code generation for tentative definitions and definitions that show up in the PCH file. llvm-svn: 69043
2009-04-15 00:27:31 +08:00
Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
Rework Sema code completion interface. - Provide Sema in callbacks, instead of requiring it in constructor. This eliminates the need for a factory function. Clients now just pass the object to consume the results in directly. - CodeCompleteConsumer is cheap to construct, so building it whenever we are doing code completion is reasonable. Doug, please review. llvm-svn: 87099
2009-11-13 16:58:20 +08:00
bool CompleteTranslationUnit,
CodeCompleteConsumer *CodeCompleter)
inline Sema::getLangOptions, rdar://6515190. This speeds up fsyntax-only with PTH by 3%. llvm-svn: 62774
2009-01-23 03:21:44 +08:00
: LangOpts(pp.getLangOptions()), PP(pp), Context(ctxt), Consumer(consumer),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
Rework Sema code completion interface. - Provide Sema in callbacks, instead of requiring it in constructor. This eliminates the need for a factory function. Clients now just pass the object to consume the results in directly. - CodeCompleteConsumer is cheap to construct, so building it whenever we are doing code completion is reasonable. Doug, please review. llvm-svn: 87099
2009-11-13 16:58:20 +08:00
ExternalSource(0), CodeCompleter(CodeCompleter), CurContext(0),
Change our basic strategy for avoiding deprecation warnings when the decl use appears in a deprecated context. In the new strategy, we emit the warnings as usual unless we're currently parsing a declaration, where "declaration" is restricted to mean a decl group or a few special cases in Objective C. If we *are* parsing a declaration, we queue up the deprecation warnings until the declaration has been completely parsed, and then emit them only if the decl is not deprecated. We also standardize the bookkeeping for deprecation so as to avoid special cases. llvm-svn: 85998
2009-11-04 10:18:39 +08:00
PreDeclaratorDC(0), CurBlock(0), PackContext(0), ParsingDeclDepth(0),
Initial implementation of a code-completion interface in Clang. In essence, code completion is triggered by a magic "code completion" token produced by the lexer [*], which the parser recognizes at certain points in the grammar. The parser then calls into the Action object with the appropriate CodeCompletionXXX action. Sema implements the CodeCompletionXXX callbacks by performing minimal translation, then forwarding them to a CodeCompletionConsumer subclass, which uses the results of semantic analysis to provide code-completion results. At present, only a single, "printing" code completion consumer is available, for regression testing and debugging. However, the design is meant to permit other code-completion consumers. This initial commit contains two code-completion actions: one for member access, e.g., "x." or "p->", and one for nested-name-specifiers, e.g., "std::". More code-completion actions will follow, along with improved gathering of code-completion results for the various contexts. [*] In the current -code-completion-dump testing/debugging mode, the file is truncated at the completion point and EOF is translated into "code completion". llvm-svn: 82166
2009-09-18 05:32:03 +08:00
IdResolver(pp.getLangOptions()), StdNamespace(0), StdBadAlloc(0),
Refactor our handling of expression evaluation contexts, so that Sema maintains a stack of evaluation contexts rather than having the parser do it. This change made it simpler to track in which contexts temporaries were created, so that we could... "Forget" about temporaries created within unevaluated contexts, so that we don't build a CXXExprWithTemporaries and, therefore, destroy the integral-constness of our expressions. Fixes PR5609. llvm-svn: 89908
2009-11-26 08:44:06 +08:00
GlobalNewDeleteDeclared(false),
Introduce a stack of instantiation scopes that are used to store the mapping from variable declarations that occur within templates to their instantiated counterparts llvm-svn: 71799
2009-05-15 05:44:34 +08:00
CompleteTranslationUnit(CompleteTranslationUnit),
Improve diagnostics when a default template argument does not match with its corresponding template parameter. This can happen when we performed some substitution into the default template argument and what we had doesn't match any more, e.g., template<int> struct A; template<typename T, template<T> class X = A> class B; B<long> b; Previously, we'd emit a pretty but disembodied diagnostic showing how the default argument didn't match the template parameter. The diagnostic was good, but nothing tied it to the *use* of the default argument in "B<long>". This commit fixes that. Also, tweak the counting of active template instantiations to avoid counting non-instantiation records, such as those we create for (surprise!) checking default arguments, instantiating default arguments, and performing substitutions as part of template argument deduction. llvm-svn: 86884
2009-11-12 05:54:23 +08:00
NumSFINAEErrors(0), NonInstantiationEntries(0),
CurrentInstantiationScope(0)
{
- Make sure default return/argument types (for methods) default to "id". - Cache the "id" type in Sema...initialize ObjcIdType and TUScope (oops). - Fix ActOnInstanceMessage to allow for "id" type receivers...still work to do (next). llvm-svn: 42842
2007-10-11 05:53:07 +08:00
TUScope = 0;
Add Sema support for C++ classes. llvm-svn: 52956
2008-07-01 18:37:29 +08:00
if (getLangOptions().CPlusPlus)
FieldCollector.reset(new CXXFieldCollector());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add support for sending QualType's directly into diags and convert two diags over to use this. QualTypes implicitly print single quotes around them for uniformity and future extension. Doing this requires a little function pointer dance to prevent libbasic from depending on libast. llvm-svn: 59907
2008-11-23 17:13:29 +08:00
// Tell diagnostics how to render things from the AST library.
replace a dirty hack with a clean solution. Too bad we can't use Blocks for our callbacks ;-) llvm-svn: 65083
2009-02-20 07:53:20 +08:00
PP.getDiagnostics().SetArgToStringFn(ConvertArgToStringFn, &Context);
Refactor our handling of expression evaluation contexts, so that Sema maintains a stack of evaluation contexts rather than having the parser do it. This change made it simpler to track in which contexts temporaries were created, so that we could... "Forget" about temporaries created within unevaluated contexts, so that we don't build a CXXExprWithTemporaries and, therefore, destroy the integral-constness of our expressions. Fixes PR5609. llvm-svn: 89908
2009-11-26 08:44:06 +08:00
ExprEvalContexts.push_back(
ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0));
Make Sema's use of the preprocessor explicit (rather than assume the prerocessor will be available via ASTContext). - Removed the public data member "PP" in ASTContext. - Changed ASTContext's contructor to take TargetInfo/IdentifierTable explicitly. - Implicitly create an ASTContext in Sema's constructor. This simplifies the clients job (and makes ASTContext more private). --As a side effect, added a "PrintStats" hook to Sema. To support this level of encapsulation, ASTContext is always dynamically allocated (by Sema). Previously, ASTContext was being allocated on the stack. I don't believe this should be a performance issue (since ASTContext is fairly course grain and tied to the lifetime of Sema currently). llvm-svn: 39345
2007-02-28 09:22:02 +08:00
}
introduce a new ASTContext class to hold long-lived ast nodes. llvm-svn: 39161
2006-11-10 14:20:45 +08:00
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
/// Retrieves the width and signedness of the given integer type,
/// or returns false if it is not an integer type.
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
///
/// \param T must be canonical
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
static bool getIntProperties(ASTContext &C, const Type *T,
unsigned &BitWidth, bool &Signed) {
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
assert(T->isCanonicalUnqualified());
if (const VectorType *VT = dyn_cast<VectorType>(T))
T = VT->getElementType().getTypePtr();
if (const ComplexType *CT = dyn_cast<ComplexType>(T))
T = CT->getElementType().getTypePtr();
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) {
if (!BT->isInteger()) return false;
BitWidth = C.getIntWidth(QualType(T, 0));
Signed = BT->isSignedInteger();
return true;
}
if (const FixedWidthIntType *FWIT = dyn_cast<FixedWidthIntType>(T)) {
BitWidth = FWIT->getWidth();
Signed = FWIT->isSigned();
return true;
}
return false;
}
/// Checks whether the given value will have the same value if it it
/// is truncated to the given width, then extended back to the
/// original width.
static bool IsSameIntAfterCast(const llvm::APSInt &value,
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
unsigned TargetWidth) {
unsigned SourceWidth = value.getBitWidth();
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
llvm::APSInt truncated = value;
truncated.trunc(TargetWidth);
truncated.extend(SourceWidth);
return (truncated == value);
}
/// Checks whether the given value will have the same value if it
/// is truncated to the given width, then extended back to the original
/// width.
///
/// The value might be a vector or a complex.
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
static bool IsSameIntAfterCast(const APValue &value, unsigned TargetWidth) {
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
if (value.isInt())
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
return IsSameIntAfterCast(value.getInt(), TargetWidth);
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
if (value.isVector()) {
for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i)
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
if (!IsSameIntAfterCast(value.getVectorElt(i), TargetWidth))
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
return false;
return true;
}
Fix PR 5422: handle lvalue results when evaluating 'based' ptrtoints as part of the -Wconversion check. llvm-svn: 86891
2009-11-12 06:52:37 +08:00
if (value.isComplexInt()) {
return IsSameIntAfterCast(value.getComplexIntReal(), TargetWidth) &&
IsSameIntAfterCast(value.getComplexIntImag(), TargetWidth);
}
// This can happen with lossless casts to intptr_t of "based" lvalues.
// Assume it might use arbitrary bits.
assert(value.isLValue());
return false;
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
}
/// Checks whether the given value, which currently has the given
/// source semantics, has the same value when coerced through the
/// target semantics.
static bool IsSameFloatAfterCast(const llvm::APFloat &value,
const llvm::fltSemantics &Src,
const llvm::fltSemantics &Tgt) {
llvm::APFloat truncated = value;
bool ignored;
truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
return truncated.bitwiseIsEqual(value);
}
/// Checks whether the given value, which currently has the given
/// source semantics, has the same value when coerced through the
/// target semantics.
///
/// The value might be a vector of floats (or a complex number).
static bool IsSameFloatAfterCast(const APValue &value,
const llvm::fltSemantics &Src,
const llvm::fltSemantics &Tgt) {
if (value.isFloat())
return IsSameFloatAfterCast(value.getFloat(), Src, Tgt);
if (value.isVector()) {
for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i)
if (!IsSameFloatAfterCast(value.getVectorElt(i), Src, Tgt))
return false;
return true;
}
assert(value.isComplexFloat());
return (IsSameFloatAfterCast(value.getComplexFloatReal(), Src, Tgt) &&
IsSameFloatAfterCast(value.getComplexFloatImag(), Src, Tgt));
}
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
/// Determines if it's reasonable for the given expression to be truncated
/// down to the given integer width.
/// * Boolean expressions are automatically white-listed.
/// * Arithmetic operations on implicitly-promoted operands of the
/// target width or less are okay --- not because the results are
/// actually guaranteed to fit within the width, but because the
/// user is effectively pretending that the operations are closed
/// within the implicitly-promoted type.
static bool IsExprValueWithinWidth(ASTContext &C, Expr *E, unsigned Width) {
E = E->IgnoreParens();
#ifndef NDEBUG
{
const Type *ETy = E->getType()->getCanonicalTypeInternal().getTypePtr();
unsigned EWidth;
bool ESigned;
if (!getIntProperties(C, ETy, EWidth, ESigned))
assert(0 && "expression not of integer type");
// The caller should never let this happen.
assert(EWidth > Width && "called on expr whose type is too small");
}
#endif
// Strip implicit casts off.
while (isa<ImplicitCastExpr>(E)) {
E = cast<ImplicitCastExpr>(E)->getSubExpr();
const Type *ETy = E->getType()->getCanonicalTypeInternal().getTypePtr();
unsigned EWidth;
bool ESigned;
if (!getIntProperties(C, ETy, EWidth, ESigned))
return false;
if (EWidth <= Width)
return true;
}
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
switch (BO->getOpcode()) {
// Boolean-valued operations are white-listed.
case BinaryOperator::LAnd:
case BinaryOperator::LOr:
case BinaryOperator::LT:
case BinaryOperator::GT:
case BinaryOperator::LE:
case BinaryOperator::GE:
case BinaryOperator::EQ:
case BinaryOperator::NE:
return true;
// Operations with opaque sources are black-listed.
case BinaryOperator::PtrMemD:
case BinaryOperator::PtrMemI:
return false;
// Left shift gets black-listed based on a judgement call.
case BinaryOperator::Shl:
return false;
// Various special cases.
case BinaryOperator::Shr:
return IsExprValueWithinWidth(C, BO->getLHS(), Width);
case BinaryOperator::Comma:
return IsExprValueWithinWidth(C, BO->getRHS(), Width);
case BinaryOperator::Sub:
if (BO->getLHS()->getType()->isPointerType())
return false;
// fallthrough
// Any other operator is okay if the operands are
// promoted from expressions of appropriate size.
default:
return IsExprValueWithinWidth(C, BO->getLHS(), Width) &&
IsExprValueWithinWidth(C, BO->getRHS(), Width);
}
}
if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
switch (UO->getOpcode()) {
// Boolean-valued operations are white-listed.
case UnaryOperator::LNot:
return true;
// Operations with opaque sources are black-listed.
case UnaryOperator::Deref:
case UnaryOperator::AddrOf: // should be impossible
return false;
case UnaryOperator::OffsetOf:
return false;
default:
return IsExprValueWithinWidth(C, UO->getSubExpr(), Width);
}
}
// Don't diagnose if the expression is an integer constant
// whose value in the target type is the same as it was
// in the original type.
Expr::EvalResult result;
if (E->Evaluate(result, C))
if (IsSameIntAfterCast(result.Val, Width))
return true;
return false;
}
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
static void DiagnoseImpCast(Sema &S, Expr *E, QualType T, unsigned diag) {
S.Diag(E->getExprLoc(), diag) << E->getType() << T << E->getSourceRange();
}
/// Implements -Wconversion.
static void CheckImplicitConversion(Sema &S, Expr *E, QualType T) {
// Don't diagnose in unevaluated contexts.
Refactor our handling of expression evaluation contexts, so that Sema maintains a stack of evaluation contexts rather than having the parser do it. This change made it simpler to track in which contexts temporaries were created, so that we could... "Forget" about temporaries created within unevaluated contexts, so that we don't build a CXXExprWithTemporaries and, therefore, destroy the integral-constness of our expressions. Fixes PR5609. llvm-svn: 89908
2009-11-26 08:44:06 +08:00
if (S.ExprEvalContexts.back().Context == Sema::Unevaluated)
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
return;
// Don't diagnose for value-dependent expressions.
if (E->isValueDependent())
return;
const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr();
const Type *Target = S.Context.getCanonicalType(T).getTypePtr();
// Never diagnose implicit casts to bool.
if (Target->isSpecificBuiltinType(BuiltinType::Bool))
return;
// Strip vector types.
if (isa<VectorType>(Source)) {
if (!isa<VectorType>(Target))
return DiagnoseImpCast(S, E, T, diag::warn_impcast_vector_scalar);
Source = cast<VectorType>(Source)->getElementType().getTypePtr();
Target = cast<VectorType>(Target)->getElementType().getTypePtr();
}
// Strip complex types.
if (isa<ComplexType>(Source)) {
if (!isa<ComplexType>(Target))
return DiagnoseImpCast(S, E, T, diag::warn_impcast_complex_scalar);
Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
Target = cast<ComplexType>(Target)->getElementType().getTypePtr();
}
const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
// If the source is floating point...
if (SourceBT && SourceBT->isFloatingPoint()) {
// ...and the target is floating point...
if (TargetBT && TargetBT->isFloatingPoint()) {
// ...then warn if we're dropping FP rank.
// Builtin FP kinds are ordered by increasing FP rank.
if (SourceBT->getKind() > TargetBT->getKind()) {
// Don't warn about float constants that are precisely
// representable in the target type.
Expr::EvalResult result;
if (E->Evaluate(result, S.Context)) {
// Value might be a float, a float vector, or a float complex.
if (IsSameFloatAfterCast(result.Val,
S.Context.getFloatTypeSemantics(QualType(TargetBT, 0)),
S.Context.getFloatTypeSemantics(QualType(SourceBT, 0))))
return;
}
DiagnoseImpCast(S, E, T, diag::warn_impcast_float_precision);
}
return;
}
// If the target is integral, always warn.
if ((TargetBT && TargetBT->isInteger()) ||
isa<FixedWidthIntType>(Target))
// TODO: don't warn for integer values?
return DiagnoseImpCast(S, E, T, diag::warn_impcast_float_integer);
return;
}
unsigned SourceWidth, TargetWidth;
bool SourceSigned, TargetSigned;
if (!getIntProperties(S.Context, Source, SourceWidth, SourceSigned) ||
!getIntProperties(S.Context, Target, TargetWidth, TargetSigned))
return;
if (SourceWidth > TargetWidth) {
Improve -Wconversion by permitting binary operations on values of the target type (or smaller) to stay "closed" within the type. llvm-svn: 86356
2009-11-07 16:15:46 +08:00
if (IsExprValueWithinWidth(S.Context, E, TargetWidth))
return;
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
Support -Wshorten-64-to-32 for integer types only, which seems to satisfy the core requirements. Fixes rdar://problem/6389954 llvm-svn: 86364
2009-11-07 17:03:53 +08:00
// People want to build with -Wshorten-64-to-32 and not -Wconversion
// and by god we'll let them.
if (SourceWidth == 64 && TargetWidth == 32)
return DiagnoseImpCast(S, E, T, diag::warn_impcast_integer_64_32);
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
return DiagnoseImpCast(S, E, T, diag::warn_impcast_integer_precision);
}
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Move promoteExprToType from being a static method in SemaExpr.cpp to being a method named ImpCastExprToType in Sema. Use this method to insert implicit casts for case statements from their operand type to the condition type of the switch. This fixes a crash on test/CodeGen/statements.c, reported by Eli Friedman. llvm-svn: 46083
2008-01-17 03:17:22 +08:00
/// If there is already an implicit cast, merge into the existing one.
Vector codegen improvements llvm-svn: 62458
2009-01-18 14:42:49 +08:00
/// If isLvalue, the result of the cast is an lvalue.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty,
Get rid of the CastInfo struct. llvm-svn: 81839
2009-09-15 13:13:45 +08:00
CastExpr::CastKind Kind, bool isLvalue) {
Generate error if we try to implicit cast between different address spaces llvm-svn: 55765
2008-09-04 16:38:01 +08:00
QualType ExprTy = Context.getCanonicalType(Expr->getType());
QualType TypeTy = Context.getCanonicalType(Ty);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Generate error if we try to implicit cast between different address spaces llvm-svn: 55765
2008-09-04 16:38:01 +08:00
if (ExprTy == TypeTy)
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
if (Expr->getType()->isPointerType() && Ty->isPointerType()) {
QualType ExprBaseType = cast<PointerType>(ExprTy)->getPointeeType();
QualType BaseType = cast<PointerType>(TypeTy)->getPointeeType();
Generate error if we try to implicit cast between different address spaces llvm-svn: 55765
2008-09-04 16:38:01 +08:00
if (ExprBaseType.getAddressSpace() != BaseType.getAddressSpace()) {
remove one more old-style Diag method. llvm-svn: 59589
2008-11-19 13:27:50 +08:00
Diag(Expr->getExprLoc(), diag::err_implicit_pointer_address_space_cast)
<< Expr->getSourceRange();
Generate error if we try to implicit cast between different address spaces llvm-svn: 55765
2008-09-04 16:38:01 +08:00
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement -Wconversion. Off by default, in the non-gcc group. There's significant work left to be done to reduce the false-positive rate here. llvm-svn: 86326
2009-11-07 11:30:10 +08:00
CheckImplicitConversion(*this, Expr, Ty);
Implement support for operator overloading using candidate operator functions for built-in operators, e.g., the builtin bool operator==(int const*, int const*) can be used for the expression "x1 == x2" given: struct X { operator int const*(); } x1, x2; The scheme for handling these built-in operators is relatively simple: for each candidate required by the standard, create a special kind of candidate function for the built-in. If overload resolution picks the built-in operator, we perform the appropriate conversions on the arguments and then let the normal built-in operator take care of it. There may be some optimization opportunity left: if we can reduce the number of built-in operator overloads we generate, overload resolution for these cases will go faster. However, one must be careful when doing this: GCC generates too few operator overloads in our little test program, and fails to compile it because none of the overloads it generates match. Note that we only support operator overload for non-member binary operators at the moment. The other operators will follow. As part of this change, ImplicitCastExpr can now be an lvalue. llvm-svn: 59148
2008-11-13 01:17:38 +08:00
if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(Expr)) {
Only reuse an already existing ImplicitCastExpr if the cast kinds are the same. llvm-svn: 81841
2009-09-15 13:28:24 +08:00
if (ImpCast->getCastKind() == Kind) {
ImpCast->setType(Ty);
ImpCast->setLvalueCast(isLvalue);
return;
}
}
Expr = new (Context) ImplicitCastExpr(Ty, Kind, Expr, isLvalue);
Move promoteExprToType from being a static method in SemaExpr.cpp to being a method named ImpCastExprToType in Sema. Use this method to insert implicit casts for case statements from their operand type to the condition type of the switch. This fixes a crash on test/CodeGen/statements.c, reported by Eli Friedman. llvm-svn: 46083
2008-01-17 03:17:22 +08:00
}
add actions for deleting expr/stmt nodes. llvm-svn: 41635
2007-08-31 12:53:24 +08:00
void Sema::DeleteExpr(ExprTy *E) {
Initial implementation of semantic analysis and ASTs for C99 designated initializers. This implementation should cover all of the constraints in C99 6.7.8, including long, complex designations and computing the size of incomplete array types initialized with a designated initializer. Please see the new test-case and holler if you find cases where this doesn't work. There are still some wrinkles with GNU's anonymous structs and anonymous unions (it isn't clear how these should work; we'll just follow GCC's lead) and with designated initializers for the members of a union. I'll tackle those very soon. CodeGen is still nonexistent, and there's some leftover code in the parser's representation of designators that I'll also need to clean up. llvm-svn: 62737
2009-01-22 08:58:24 +08:00
if (E) static_cast<Expr*>(E)->Destroy(Context);
add actions for deleting expr/stmt nodes. llvm-svn: 41635
2007-08-31 12:53:24 +08:00
}
void Sema::DeleteStmt(StmtTy *S) {
Initial implementation of semantic analysis and ASTs for C99 designated initializers. This implementation should cover all of the constraints in C99 6.7.8, including long, complex designations and computing the size of incomplete array types initialized with a designated initializer. Please see the new test-case and holler if you find cases where this doesn't work. There are still some wrinkles with GNU's anonymous structs and anonymous unions (it isn't clear how these should work; we'll just follow GCC's lead) and with designated initializers for the members of a union. I'll tackle those very soon. CodeGen is still nonexistent, and there's some leftover code in the parser's representation of designators that I'll also need to clean up. llvm-svn: 62737
2009-01-22 08:58:24 +08:00
if (S) static_cast<Stmt*>(S)->Destroy(Context);
add actions for deleting expr/stmt nodes. llvm-svn: 41635
2007-08-31 12:53:24 +08:00
}
make sure that ParseAST invokes the action for end of translation unit. llvm-svn: 55222
2008-08-23 11:19:52 +08:00
/// ActOnEndOfTranslationUnit - This is called at the very end of the
/// translation unit when EOF is reached and all but the top-level scope is
/// popped.
void Sema::ActOnEndOfTranslationUnit() {
Rework how virtual member functions are marked. If a class has no key function, we now wait until the end of the translation unit to mark its virtual member functions as references. This lays the groundwork for fixing PR5557. llvm-svn: 90752
2009-12-07 16:24:59 +08:00
while (1) {
// C++: Perform implicit template instantiations.
//
// FIXME: When we perform these implicit instantiations, we do not carefully
// keep track of the point of instantiation (C++ [temp.point]). This means
// that name lookup that occurs within the template instantiation will
// always happen at the end of the translation unit, so it will find
// some names that should not be found. Although this is common behavior
// for C++ compilers, it is technically wrong. In the future, we either need
// to be able to filter the results of name lookup or we need to perform
// template instantiations earlier.
PerformPendingImplicitInstantiations();
/// If ProcessPendingClassesWithUnmarkedVirtualMembers ends up marking
/// any virtual member functions it might lead to more pending template
/// instantiations, which is why we need to loop here.
if (!ProcessPendingClassesWithUnmarkedVirtualMembers())
break;
}
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// Check for #pragma weak identifiers that were never declared
// FIXME: This will cause diagnostics to be emitted in a non-determinstic
// order! Iterating over a densemap like this is bad.
PR3679 - handle #pragma weak llvm-svn: 77573
2009-07-30 11:15:39 +08:00
for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
I = WeakUndeclaredIdentifiers.begin(),
E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
if (I->second.getUsed()) continue;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
<< I->first;
PR3679 - handle #pragma weak llvm-svn: 77573
2009-07-30 11:15:39 +08:00
}
When building a PCH file, don't perform end-of-translation-unit wrap-up (e.g., turning tentative definitions into definitions). Also, very that, when we actually use the PCH file, we get the ride code generation for tentative definitions and definitions that show up in the PCH file. llvm-svn: 69043
2009-04-15 00:27:31 +08:00
if (!CompleteTranslationUnit)
return;
Add type checking for tentative definitions at the end of the translation unit. Thread the various declarations of variables via VarDecl::getPreviousDeclaration. llvm-svn: 66601
2009-03-11 07:43:53 +08:00
// C99 6.9.2p2:
// A declaration of an identifier for an object that has file
// scope without an initializer, and without a storage-class
// specifier or with the storage-class specifier static,
// constitutes a tentative definition. If a translation unit
// contains one or more tentative definitions for an identifier,
// and the translation unit contains no external definition for
// that identifier, then the behavior is exactly as if the
// translation unit contains a file scope declaration of that
// identifier, with the composite type as of the end of the
// translation unit, with an initializer equal to 0.
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
for (unsigned i = 0, e = TentativeDefinitionList.size(); i != e; ++i) {
VarDecl *VD = TentativeDefinitions.lookup(TentativeDefinitionList[i]);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// If the tentative definition was completed, it will be in the list, but
// not the map.
if (VD == 0 || VD->isInvalidDecl() || !VD->isTentativeDefinition(Context))
Explictly track tentative definitions within Sema, then hand those tentative definitions off to the ASTConsumer at the end of the translation unit. Eliminate CodeGen's internal tracking of tentative definitions, and instead hook into ASTConsumer::CompleteTentativeDefinition. Also, tweak the definition-deferal logic for C++, where there are no tentative definitions. Fixes <rdar://problem/6808352>, and will make it much easier for precompiled headers to cope with tentative definitions in the future. llvm-svn: 69681
2009-04-22 01:11:58 +08:00
continue;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (const IncompleteArrayType *ArrayT
Explictly track tentative definitions within Sema, then hand those tentative definitions off to the ASTConsumer at the end of the translation unit. Eliminate CodeGen's internal tracking of tentative definitions, and instead hook into ASTConsumer::CompleteTentativeDefinition. Also, tweak the definition-deferal logic for C++, where there are no tentative definitions. Fixes <rdar://problem/6808352>, and will make it much easier for precompiled headers to cope with tentative definitions in the future. llvm-svn: 69681
2009-04-22 01:11:58 +08:00
= Context.getAsIncompleteArrayType(VD->getType())) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (RequireCompleteType(VD->getLocation(),
Explictly track tentative definitions within Sema, then hand those tentative definitions off to the ASTConsumer at the end of the translation unit. Eliminate CodeGen's internal tracking of tentative definitions, and instead hook into ASTConsumer::CompleteTentativeDefinition. Also, tweak the definition-deferal logic for C++, where there are no tentative definitions. Fixes <rdar://problem/6808352>, and will make it much easier for precompiled headers to cope with tentative definitions in the future. llvm-svn: 69681
2009-04-22 01:11:58 +08:00
ArrayT->getElementType(),
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
diag::err_tentative_def_incomplete_type_arr)) {
Explictly track tentative definitions within Sema, then hand those tentative definitions off to the ASTConsumer at the end of the translation unit. Eliminate CodeGen's internal tracking of tentative definitions, and instead hook into ASTConsumer::CompleteTentativeDefinition. Also, tweak the definition-deferal logic for C++, where there are no tentative definitions. Fixes <rdar://problem/6808352>, and will make it much easier for precompiled headers to cope with tentative definitions in the future. llvm-svn: 69681
2009-04-22 01:11:58 +08:00
VD->setInvalidDecl();
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
continue;
Add type checking for tentative definitions at the end of the translation unit. Thread the various declarations of variables via VarDecl::getPreviousDeclaration. llvm-svn: 66601
2009-03-11 07:43:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// Set the length of the array to 1 (C99 6.9.2p5).
Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
Remove the ConstantArrayType subtypes. This information is preserved in the TypeLoc records for declarations; it should not be necessary to represent it directly in the type system. Please complain if you were using these classes and feel you can't replicate previous functionality using the TypeLoc API. llvm-svn: 84222
2009-10-16 08:14:28 +08:00
QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
One, ArrayType::Normal, 0);
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
VD->setType(T);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
} else if (RequireCompleteType(VD->getLocation(), VD->getType(),
Explictly track tentative definitions within Sema, then hand those tentative definitions off to the ASTConsumer at the end of the translation unit. Eliminate CodeGen's internal tracking of tentative definitions, and instead hook into ASTConsumer::CompleteTentativeDefinition. Also, tweak the definition-deferal logic for C++, where there are no tentative definitions. Fixes <rdar://problem/6808352>, and will make it much easier for precompiled headers to cope with tentative definitions in the future. llvm-svn: 69681
2009-04-22 01:11:58 +08:00
diag::err_tentative_def_incomplete_type))
VD->setInvalidDecl();
// Notify the consumer that we've completed a tentative definition.
if (!VD->isInvalidDecl())
Consumer.CompleteTentativeDefinition(VD);
Add type checking for tentative definitions at the end of the translation unit. Thread the various declarations of variables via VarDecl::getPreviousDeclaration. llvm-svn: 66601
2009-03-11 07:43:53 +08:00
}
make sure that ParseAST invokes the action for end of translation unit. llvm-svn: 55222
2008-08-23 11:19:52 +08:00
}
move semantic analysis of break/continue out of the parser into the sema class. llvm-svn: 39157
2006-11-10 13:17:58 +08:00
//===----------------------------------------------------------------------===//
// Helper functions.
//===----------------------------------------------------------------------===//
Factor some code to get the "function level" DeclContext out into a separate function. llvm-svn: 78478
2009-08-09 01:45:02 +08:00
DeclContext *Sema::getFunctionLevelDeclContext() {
getFunctionLevelDeclContext needs to get the previous DeclContext if EnterDeclaratorContext has been called. Fixes PR4694. (Doug, please review) llvm-svn: 78480
2009-08-09 01:48:49 +08:00
DeclContext *DC = PreDeclaratorDC ? PreDeclaratorDC : CurContext;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Factor some code to get the "function level" DeclContext out into a separate function. llvm-svn: 78478
2009-08-09 01:45:02 +08:00
while (isa<BlockDecl>(DC))
DC = DC->getParent();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Factor some code to get the "function level" DeclContext out into a separate function. llvm-svn: 78478
2009-08-09 01:45:02 +08:00
return DC;
}
change getCurFunctionDecl to skip through Block contexts to find the containing block. Introduce a new getCurFunctionOrMethodDecl method to check to see if we're in a function or objc method. Minor cleanups to other related places. This fixes rdar://6405429. llvm-svn: 60564
2008-12-05 07:50:19 +08:00
/// getCurFunctionDecl - If inside of a function body, this returns a pointer
/// to the function decl for the function being parsed. If we're currently
/// in a 'block', this returns the containing context.
FunctionDecl *Sema::getCurFunctionDecl() {
Factor some code to get the "function level" DeclContext out into a separate function. llvm-svn: 78478
2009-08-09 01:45:02 +08:00
DeclContext *DC = getFunctionLevelDeclContext();
change getCurFunctionDecl to skip through Block contexts to find the containing block. Introduce a new getCurFunctionOrMethodDecl method to check to see if we're in a function or objc method. Minor cleanups to other related places. This fixes rdar://6405429. llvm-svn: 60564
2008-12-05 07:50:19 +08:00
return dyn_cast<FunctionDecl>(DC);
}
More #include cleaning - Drop {Decl.h,DeclObjC.h,IdentifierTable.h} from Expr.h - Moved Sema::getCurMethodDecl() out of line (dependent on ObjCMethodDecl via dyn_cast). llvm-svn: 54629
2008-08-11 13:35:13 +08:00
ObjCMethodDecl *Sema::getCurMethodDecl() {
Factor some code to get the "function level" DeclContext out into a separate function. llvm-svn: 78478
2009-08-09 01:45:02 +08:00
DeclContext *DC = getFunctionLevelDeclContext();
Fix <rdar://problem/6320086> parser rejects block capturing ivar. llvm-svn: 59444
2008-11-18 00:28:52 +08:00
return dyn_cast<ObjCMethodDecl>(DC);
More #include cleaning - Drop {Decl.h,DeclObjC.h,IdentifierTable.h} from Expr.h - Moved Sema::getCurMethodDecl() out of line (dependent on ObjCMethodDecl via dyn_cast). llvm-svn: 54629
2008-08-11 13:35:13 +08:00
}
change getCurFunctionDecl to skip through Block contexts to find the containing block. Introduce a new getCurFunctionOrMethodDecl method to check to see if we're in a function or objc method. Minor cleanups to other related places. This fixes rdar://6405429. llvm-svn: 60564
2008-12-05 07:50:19 +08:00
NamedDecl *Sema::getCurFunctionOrMethodDecl() {
Factor some code to get the "function level" DeclContext out into a separate function. llvm-svn: 78478
2009-08-09 01:45:02 +08:00
DeclContext *DC = getFunctionLevelDeclContext();
change getCurFunctionDecl to skip through Block contexts to find the containing block. Introduce a new getCurFunctionOrMethodDecl method to check to see if we're in a function or objc method. Minor cleanups to other related places. This fixes rdar://6405429. llvm-svn: 60564
2008-12-05 07:50:19 +08:00
if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
Remove ScopedDecl, collapsing all of its functionality into Decl, so that every declaration lives inside a DeclContext. Moved several things that don't have names but were ScopedDecls (and, therefore, NamedDecls) to inherit from Decl rather than NamedDecl, including ObjCImplementationDecl and LinkageSpecDecl. Now, we don't store empty DeclarationNames for these things, nor do we try to insert them into DeclContext's lookup structure. The serialization tests are temporarily disabled. We'll re-enable them once we've sorted out the remaining ownership/serialiazation issues between DeclContexts and TranslationUnion, DeclGroups, etc. llvm-svn: 62562
2009-01-20 09:17:11 +08:00
return cast<NamedDecl>(DC);
change getCurFunctionDecl to skip through Block contexts to find the containing block. Introduce a new getCurFunctionOrMethodDecl method to check to see if we're in a function or objc method. Minor cleanups to other related places. This fixes rdar://6405429. llvm-svn: 60564
2008-12-05 07:50:19 +08:00
return 0;
}
Eliminate post-diagnostic hooks. Instead, implement a Sema-specific variant of DiagnosticBuilder that emits the template instantiation backtrace when needed. llvm-svn: 67413
2009-03-21 06:48:49 +08:00
Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {
Update LLVM. Implement support for C++ Substitution Failure Is Not An Error (SFINAE), which says that errors that occur during template argument deduction do *not* produce diagnostics and do not necessarily make a program ill-formed. Instead, template argument deduction silently fails. This is currently implemented for template argument deduction during matching of class template partial specializations, although the mechanism will also apply to template argument deduction for function templates. The scheme is simple: - If we are in a template argument deduction context, any diagnostic that is considered a SFINAE error (or warning) will be suppressed. The error will be propagated up the call stack via the normal means. - By default, all warnings and errors are SFINAE errors. Add the NoSFINAE class to a diagnostic in the .td file to make it a hard error (e.g., for access-control violations). Note that, to make this fully work, every place in Sema that emits an error *and then immediately recovers* will need to check Sema::isSFINAEContext() to determine whether it must immediately return an error rather than recovering. llvm-svn: 73332
2009-06-14 15:33:30 +08:00
if (!this->Emit())
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Eliminate post-diagnostic hooks. Instead, implement a Sema-specific variant of DiagnosticBuilder that emits the template instantiation backtrace when needed. llvm-svn: 67413
2009-03-21 06:48:49 +08:00
// If this is not a note, and we're in a template instantiation
// that is different from the last template instantiation where
// we emitted an error, print a template instantiation
// backtrace.
if (!SemaRef.Diags.isBuiltinNote(DiagID) &&
!SemaRef.ActiveTemplateInstantiations.empty() &&
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SemaRef.ActiveTemplateInstantiations.back()
Eliminate post-diagnostic hooks. Instead, implement a Sema-specific variant of DiagnosticBuilder that emits the template instantiation backtrace when needed. llvm-svn: 67413
2009-03-21 06:48:49 +08:00
!= SemaRef.LastTemplateInstantiationErrorContext) {
SemaRef.PrintInstantiationStack();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SemaRef.LastTemplateInstantiationErrorContext
Eliminate post-diagnostic hooks. Instead, implement a Sema-specific variant of DiagnosticBuilder that emits the template instantiation backtrace when needed. llvm-svn: 67413
2009-03-21 06:48:49 +08:00
= SemaRef.ActiveTemplateInstantiations.back();
}
}
Add support for retrieving the Doxygen comment associated with a given declaration in the AST. The new ASTContext::getCommentForDecl function searches for a comment that is attached to the given declaration, and returns that comment, which may be composed of several comment blocks. Comments are always available in an AST. However, to avoid harming performance, we don't actually parse the comments. Rather, we keep the source ranges of all of the comments within a large, sorted vector, then lazily extract comments via a binary search in that vector only when needed (which never occurs in a "normal" compile). Comments are written to a precompiled header/AST file as a blob of source ranges. That blob is only lazily loaded when one requests a comment for a declaration (this never occurs in a "normal" compile). The indexer testbed now supports comment extraction. When the -point-at location points to a declaration with a Doxygen-style comment, the indexer testbed prints the associated comment block(s). See test/Index/comments.c for an example. Some notes: - We don't actually attempt to parse the comment blocks themselves, beyond identifying them as Doxygen comment blocks to associate them with a declaration. - We won't find comment blocks that aren't adjacent to the declaration, because we start our search based on the location of the declaration. - We don't go through the necessary hops to find, for example, whether some redeclaration of a declaration has comments when our current declaration does not. Similarly, we don't attempt to associate a \param Foo marker in a function body comment with the parameter named Foo (although that is certainly possible). - Verification of my "no performance impact" claims is still "to be done". llvm-svn: 74704
2009-07-03 01:08:52 +08:00
Add a RequireCompleteType variant that takes a PartialDiagnostic. The old RequireCompleteType now creates a PartialDiagnostic and calls the new function. llvm-svn: 80165
2009-08-27 06:33:56 +08:00
Sema::SemaDiagnosticBuilder
Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
PD.Emit(Builder);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add a RequireCompleteType variant that takes a PartialDiagnostic. The old RequireCompleteType now creates a PartialDiagnostic and calls the new function. llvm-svn: 80165
2009-08-27 06:33:56 +08:00
return Builder;
}
Add support for retrieving the Doxygen comment associated with a given declaration in the AST. The new ASTContext::getCommentForDecl function searches for a comment that is attached to the given declaration, and returns that comment, which may be composed of several comment blocks. Comments are always available in an AST. However, to avoid harming performance, we don't actually parse the comments. Rather, we keep the source ranges of all of the comments within a large, sorted vector, then lazily extract comments via a binary search in that vector only when needed (which never occurs in a "normal" compile). Comments are written to a precompiled header/AST file as a blob of source ranges. That blob is only lazily loaded when one requests a comment for a declaration (this never occurs in a "normal" compile). The indexer testbed now supports comment extraction. When the -point-at location points to a declaration with a Doxygen-style comment, the indexer testbed prints the associated comment block(s). See test/Index/comments.c for an example. Some notes: - We don't actually attempt to parse the comment blocks themselves, beyond identifying them as Doxygen comment blocks to associate them with a declaration. - We won't find comment blocks that aren't adjacent to the declaration, because we start our search based on the location of the declaration. - We don't go through the necessary hops to find, for example, whether some redeclaration of a declaration has comments when our current declaration does not. Similarly, we don't attempt to associate a \param Foo marker in a function body comment with the parameter named Foo (although that is certainly possible). - Verification of my "no performance impact" claims is still "to be done". llvm-svn: 74704
2009-07-03 01:08:52 +08:00
void Sema::ActOnComment(SourceRange Comment) {
Context.Comments.push_back(Comment);
}
Add a RequireCompleteType variant that takes a PartialDiagnostic. The old RequireCompleteType now creates a PartialDiagnostic and calls the new function. llvm-svn: 80165
2009-08-27 06:33:56 +08:00