Sema.cpp revision 05eac86d547892847ca95b5350e28d681150fa68
1//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the actions class which performs semantic analysis and
11// builds an AST out of a parse stream.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Sema/Sema.h"
16#include "TargetAttributesSema.h"
17#include "llvm/ADT/DenseMap.h"
18#include "llvm/ADT/SmallSet.h"
19#include "llvm/ADT/APFloat.h"
20#include "clang/Sema/ExternalSemaSource.h"
21#include "clang/Sema/SemaConsumer.h"
22#include "clang/AST/ASTContext.h"
23#include "clang/AST/ASTDiagnostic.h"
24#include "clang/AST/DeclObjC.h"
25#include "clang/AST/Expr.h"
26#include "clang/Lex/Preprocessor.h"
27#include "clang/Basic/PartialDiagnostic.h"
28#include "clang/Basic/TargetInfo.h"
29using namespace clang;
30
31FunctionScopeInfo::~FunctionScopeInfo() { }
32
33void FunctionScopeInfo::Clear(unsigned NumErrors) {
34  HasBranchProtectedScope = false;
35  HasBranchIntoScope = false;
36  HasIndirectGoto = false;
37
38  LabelMap.clear();
39  SwitchStack.clear();
40  Returns.clear();
41  NumErrorsAtStartOfFunction = NumErrors;
42}
43
44BlockScopeInfo::~BlockScopeInfo() { }
45
46void Sema::ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) {
47  TUScope = S;
48  PushDeclContext(S, Context.getTranslationUnitDecl());
49
50  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
51
52  if (!Context.isInt128Installed() && // May be set by PCHReader.
53      PP.getTargetInfo().getPointerWidth(0) >= 64) {
54    TypeSourceInfo *TInfo;
55
56    // Install [u]int128_t for 64-bit targets.
57    TInfo = Context.getTrivialTypeSourceInfo(Context.Int128Ty);
58    PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
59                                          SourceLocation(),
60                                          &Context.Idents.get("__int128_t"),
61                                          TInfo), TUScope);
62
63    TInfo = Context.getTrivialTypeSourceInfo(Context.UnsignedInt128Ty);
64    PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
65                                          SourceLocation(),
66                                          &Context.Idents.get("__uint128_t"),
67                                          TInfo), TUScope);
68    Context.setInt128Installed();
69  }
70
71
72  if (!PP.getLangOptions().ObjC1) return;
73
74  // Built-in ObjC types may already be set by PCHReader (hence isNull checks).
75  if (Context.getObjCSelType().isNull()) {
76    // Create the built-in typedef for 'SEL'.
77    QualType SelT = Context.getPointerType(Context.ObjCBuiltinSelTy);
78    TypeSourceInfo *SelInfo = Context.getTrivialTypeSourceInfo(SelT);
79    TypedefDecl *SelTypedef
80      = TypedefDecl::Create(Context, CurContext, SourceLocation(),
81                            &Context.Idents.get("SEL"), SelInfo);
82    PushOnScopeChains(SelTypedef, TUScope);
83    Context.setObjCSelType(Context.getTypeDeclType(SelTypedef));
84    Context.ObjCSelRedefinitionType = Context.getObjCSelType();
85  }
86
87  // Synthesize "@class Protocol;
88  if (Context.getObjCProtoType().isNull()) {
89    ObjCInterfaceDecl *ProtocolDecl =
90      ObjCInterfaceDecl::Create(Context, CurContext, SourceLocation(),
91                                &Context.Idents.get("Protocol"),
92                                SourceLocation(), true);
93    Context.setObjCProtoType(Context.getObjCInterfaceType(ProtocolDecl));
94    PushOnScopeChains(ProtocolDecl, TUScope, false);
95  }
96  // Create the built-in typedef for 'id'.
97  if (Context.getObjCIdType().isNull()) {
98    QualType T = Context.getObjCObjectType(Context.ObjCBuiltinIdTy, 0, 0);
99    T = Context.getObjCObjectPointerType(T);
100    TypeSourceInfo *IdInfo = Context.getTrivialTypeSourceInfo(T);
101    TypedefDecl *IdTypedef
102      = TypedefDecl::Create(Context, CurContext, SourceLocation(),
103                            &Context.Idents.get("id"), IdInfo);
104    PushOnScopeChains(IdTypedef, TUScope);
105    Context.setObjCIdType(Context.getTypeDeclType(IdTypedef));
106    Context.ObjCIdRedefinitionType = Context.getObjCIdType();
107  }
108  // Create the built-in typedef for 'Class'.
109  if (Context.getObjCClassType().isNull()) {
110    QualType T = Context.getObjCObjectType(Context.ObjCBuiltinClassTy, 0, 0);
111    T = Context.getObjCObjectPointerType(T);
112    TypeSourceInfo *ClassInfo = Context.getTrivialTypeSourceInfo(T);
113    TypedefDecl *ClassTypedef
114      = TypedefDecl::Create(Context, CurContext, SourceLocation(),
115                            &Context.Idents.get("Class"), ClassInfo);
116    PushOnScopeChains(ClassTypedef, TUScope);
117    Context.setObjCClassType(Context.getTypeDeclType(ClassTypedef));
118    Context.ObjCClassRedefinitionType = Context.getObjCClassType();
119  }
120}
121
122Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
123           bool CompleteTranslationUnit,
124           CodeCompleteConsumer *CodeCompleter)
125  : TheTargetAttributesSema(0),
126    LangOpts(pp.getLangOptions()), PP(pp), Context(ctxt), Consumer(consumer),
127    Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
128    ExternalSource(0), CodeCompleter(CodeCompleter), CurContext(0),
129    PackContext(0), VisContext(0), TopFunctionScope(0), ParsingDeclDepth(0),
130    IdResolver(pp.getLangOptions()), GlobalNewDeleteDeclared(false),
131    CompleteTranslationUnit(CompleteTranslationUnit),
132    NumSFINAEErrors(0), SuppressAccessChecking(false),
133    NonInstantiationEntries(0), CurrentInstantiationScope(0), TyposCorrected(0),
134    AnalysisWarnings(*this)
135{
136  TUScope = 0;
137  if (getLangOptions().CPlusPlus)
138    FieldCollector.reset(new CXXFieldCollector());
139
140  // Tell diagnostics how to render things from the AST library.
141  PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
142                                       &Context);
143
144  ExprEvalContexts.push_back(
145                  ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0));
146}
147
148void Sema::Initialize() {
149  // Tell the AST consumer about this Sema object.
150  Consumer.Initialize(Context);
151
152  // FIXME: Isn't this redundant with the initialization above?
153  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
154    SC->InitializeSema(*this);
155
156  // Tell the external Sema source about this Sema object.
157  if (ExternalSemaSource *ExternalSema
158      = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
159    ExternalSema->InitializeSema(*this);
160}
161
162Sema::~Sema() {
163  if (PackContext) FreePackedContext();
164  if (VisContext) FreeVisContext();
165  delete TheTargetAttributesSema;
166  while (!FunctionScopes.empty())
167    PopFunctionOrBlockScope();
168
169  // Tell the SemaConsumer to forget about us; we're going out of scope.
170  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
171    SC->ForgetSema();
172
173  // Detach from the external Sema source.
174  if (ExternalSemaSource *ExternalSema
175        = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
176    ExternalSema->ForgetSema();
177}
178
179/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
180/// If there is already an implicit cast, merge into the existing one.
181/// The result is of the given category.
182void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty,
183                             CastExpr::CastKind Kind,
184                             ImplicitCastExpr::ResultCategory Category,
185                             const CXXCastPath *BasePath) {
186  QualType ExprTy = Context.getCanonicalType(Expr->getType());
187  QualType TypeTy = Context.getCanonicalType(Ty);
188
189  if (ExprTy == TypeTy)
190    return;
191
192  if (Expr->getType()->isPointerType() && Ty->isPointerType()) {
193    QualType ExprBaseType = cast<PointerType>(ExprTy)->getPointeeType();
194    QualType BaseType = cast<PointerType>(TypeTy)->getPointeeType();
195    if (ExprBaseType.getAddressSpace() != BaseType.getAddressSpace()) {
196      Diag(Expr->getExprLoc(), diag::err_implicit_pointer_address_space_cast)
197        << Expr->getSourceRange();
198    }
199  }
200
201  // If this is a derived-to-base cast to a through a virtual base, we
202  // need a vtable.
203  if (Kind == CastExpr::CK_DerivedToBase &&
204      BasePathInvolvesVirtualBase(*BasePath)) {
205    QualType T = Expr->getType();
206    if (const PointerType *Pointer = T->getAs<PointerType>())
207      T = Pointer->getPointeeType();
208    if (const RecordType *RecordTy = T->getAs<RecordType>())
209      MarkVTableUsed(Expr->getLocStart(),
210                     cast<CXXRecordDecl>(RecordTy->getDecl()));
211  }
212
213  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(Expr)) {
214    if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
215      ImpCast->setType(Ty);
216      ImpCast->setCategory(Category);
217      return;
218    }
219  }
220
221  Expr = ImplicitCastExpr::Create(Context, Ty, Kind, Expr, BasePath, Category);
222}
223
224ImplicitCastExpr::ResultCategory Sema::CastCategory(Expr *E) {
225  Expr::Classification Classification = E->Classify(Context);
226  return Classification.isRValue() ?
227      ImplicitCastExpr::RValue :
228      (Classification.isLValue() ?
229          ImplicitCastExpr::LValue :
230          ImplicitCastExpr::XValue);
231}
232
233void Sema::DeleteExpr(ExprTy *E) {
234}
235void Sema::DeleteStmt(StmtTy *S) {
236}
237
238/// ActOnEndOfTranslationUnit - This is called at the very end of the
239/// translation unit when EOF is reached and all but the top-level scope is
240/// popped.
241void Sema::ActOnEndOfTranslationUnit() {
242  // At PCH writing, implicit instantiations and VTable handling info are
243  // stored and performed when the PCH is included.
244  if (CompleteTranslationUnit)
245    while (1) {
246      // C++: Perform implicit template instantiations.
247      //
248      // FIXME: When we perform these implicit instantiations, we do not
249      // carefully keep track of the point of instantiation (C++ [temp.point]).
250      // This means that name lookup that occurs within the template
251      // instantiation will always happen at the end of the translation unit,
252      // so it will find some names that should not be found. Although this is
253      // common behavior for C++ compilers, it is technically wrong. In the
254      // future, we either need to be able to filter the results of name lookup
255      // or we need to perform template instantiations earlier.
256      PerformPendingImplicitInstantiations();
257
258      /// If DefinedUsedVTables ends up marking any virtual member
259      /// functions it might lead to more pending template
260      /// instantiations, which is why we need to loop here.
261      if (!DefineUsedVTables())
262        break;
263    }
264
265  // Remove file scoped decls that turned out to be used.
266  UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(),
267                                             UnusedFileScopedDecls.end(),
268                             std::bind2nd(std::mem_fun(&DeclaratorDecl::isUsed),
269                                          true)),
270                              UnusedFileScopedDecls.end());
271
272  if (!CompleteTranslationUnit)
273    return;
274
275  // Check for #pragma weak identifiers that were never declared
276  // FIXME: This will cause diagnostics to be emitted in a non-determinstic
277  // order!  Iterating over a densemap like this is bad.
278  for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
279       I = WeakUndeclaredIdentifiers.begin(),
280       E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
281    if (I->second.getUsed()) continue;
282
283    Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
284      << I->first;
285  }
286
287  // C99 6.9.2p2:
288  //   A declaration of an identifier for an object that has file
289  //   scope without an initializer, and without a storage-class
290  //   specifier or with the storage-class specifier static,
291  //   constitutes a tentative definition. If a translation unit
292  //   contains one or more tentative definitions for an identifier,
293  //   and the translation unit contains no external definition for
294  //   that identifier, then the behavior is exactly as if the
295  //   translation unit contains a file scope declaration of that
296  //   identifier, with the composite type as of the end of the
297  //   translation unit, with an initializer equal to 0.
298  llvm::SmallSet<VarDecl *, 32> Seen;
299  for (unsigned i = 0, e = TentativeDefinitions.size(); i != e; ++i) {
300    VarDecl *VD = TentativeDefinitions[i]->getActingDefinition();
301
302    // If the tentative definition was completed, getActingDefinition() returns
303    // null. If we've already seen this variable before, insert()'s second
304    // return value is false.
305    if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
306      continue;
307
308    if (const IncompleteArrayType *ArrayT
309        = Context.getAsIncompleteArrayType(VD->getType())) {
310      if (RequireCompleteType(VD->getLocation(),
311                              ArrayT->getElementType(),
312                              diag::err_tentative_def_incomplete_type_arr)) {
313        VD->setInvalidDecl();
314        continue;
315      }
316
317      // Set the length of the array to 1 (C99 6.9.2p5).
318      Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
319      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
320      QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
321                                                One, ArrayType::Normal, 0);
322      VD->setType(T);
323    } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
324                                   diag::err_tentative_def_incomplete_type))
325      VD->setInvalidDecl();
326
327    // Notify the consumer that we've completed a tentative definition.
328    if (!VD->isInvalidDecl())
329      Consumer.CompleteTentativeDefinition(VD);
330
331  }
332
333  // Output warning for unused file scoped decls.
334  for (std::vector<const DeclaratorDecl*>::iterator
335         I = UnusedFileScopedDecls.begin(),
336         E = UnusedFileScopedDecls.end(); I != E; ++I) {
337    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
338      Diag(FD->getLocation(), diag::warn_unused_function) << FD->getDeclName();
339    else
340      Diag((*I)->getLocation(), diag::warn_unused_variable)
341            << cast<VarDecl>(*I)->getDeclName();
342  }
343}
344
345
346//===----------------------------------------------------------------------===//
347// Helper functions.
348//===----------------------------------------------------------------------===//
349
350DeclContext *Sema::getFunctionLevelDeclContext() {
351  DeclContext *DC = CurContext;
352
353  while (isa<BlockDecl>(DC) || isa<EnumDecl>(DC))
354    DC = DC->getParent();
355
356  return DC;
357}
358
359/// getCurFunctionDecl - If inside of a function body, this returns a pointer
360/// to the function decl for the function being parsed.  If we're currently
361/// in a 'block', this returns the containing context.
362FunctionDecl *Sema::getCurFunctionDecl() {
363  DeclContext *DC = getFunctionLevelDeclContext();
364  return dyn_cast<FunctionDecl>(DC);
365}
366
367ObjCMethodDecl *Sema::getCurMethodDecl() {
368  DeclContext *DC = getFunctionLevelDeclContext();
369  return dyn_cast<ObjCMethodDecl>(DC);
370}
371
372NamedDecl *Sema::getCurFunctionOrMethodDecl() {
373  DeclContext *DC = getFunctionLevelDeclContext();
374  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
375    return cast<NamedDecl>(DC);
376  return 0;
377}
378
379Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {
380  if (!this->Emit())
381    return;
382
383  // If this is not a note, and we're in a template instantiation
384  // that is different from the last template instantiation where
385  // we emitted an error, print a template instantiation
386  // backtrace.
387  if (!SemaRef.Diags.isBuiltinNote(DiagID) &&
388      !SemaRef.ActiveTemplateInstantiations.empty() &&
389      SemaRef.ActiveTemplateInstantiations.back()
390        != SemaRef.LastTemplateInstantiationErrorContext) {
391    SemaRef.PrintInstantiationStack();
392    SemaRef.LastTemplateInstantiationErrorContext
393      = SemaRef.ActiveTemplateInstantiations.back();
394  }
395}
396
397Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, unsigned DiagID) {
398  if (isSFINAEContext()) {
399    switch (Diagnostic::getDiagnosticSFINAEResponse(DiagID)) {
400    case Diagnostic::SFINAE_Report:
401      // Fall through; we'll report the diagnostic below.
402      break;
403
404    case Diagnostic::SFINAE_SubstitutionFailure:
405      // Count this failure so that we know that template argument deduction
406      // has failed.
407      ++NumSFINAEErrors;
408      // Fall through
409
410    case Diagnostic::SFINAE_Suppress:
411      // Suppress this diagnostic.
412      Diags.setLastDiagnosticIgnored();
413      return SemaDiagnosticBuilder(*this);
414    }
415  }
416
417  DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
418  return SemaDiagnosticBuilder(DB, *this, DiagID);
419}
420
421Sema::SemaDiagnosticBuilder
422Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
423  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
424  PD.Emit(Builder);
425
426  return Builder;
427}
428
429/// \brief Determines the active Scope associated with the given declaration
430/// context.
431///
432/// This routine maps a declaration context to the active Scope object that
433/// represents that declaration context in the parser. It is typically used
434/// from "scope-less" code (e.g., template instantiation, lazy creation of
435/// declarations) that injects a name for name-lookup purposes and, therefore,
436/// must update the Scope.
437///
438/// \returns The scope corresponding to the given declaraion context, or NULL
439/// if no such scope is open.
440Scope *Sema::getScopeForContext(DeclContext *Ctx) {
441
442  if (!Ctx)
443    return 0;
444
445  Ctx = Ctx->getPrimaryContext();
446  for (Scope *S = getCurScope(); S; S = S->getParent()) {
447    // Ignore scopes that cannot have declarations. This is important for
448    // out-of-line definitions of static class members.
449    if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
450      if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
451        if (Ctx == Entity->getPrimaryContext())
452          return S;
453  }
454
455  return 0;
456}
457
458/// \brief Enter a new function scope
459void Sema::PushFunctionScope() {
460  if (FunctionScopes.empty()) {
461    // Use the "top" function scope rather than having to allocate memory for
462    // a new scope.
463    TopFunctionScope.Clear(getDiagnostics().getNumErrors());
464    FunctionScopes.push_back(&TopFunctionScope);
465    return;
466  }
467
468  FunctionScopes.push_back(
469                      new FunctionScopeInfo(getDiagnostics().getNumErrors()));
470}
471
472void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
473  FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics().getNumErrors(),
474                                              BlockScope, Block));
475}
476
477void Sema::PopFunctionOrBlockScope() {
478  if (FunctionScopes.back() != &TopFunctionScope)
479    delete FunctionScopes.back();
480  else
481    TopFunctionScope.Clear(getDiagnostics().getNumErrors());
482
483  FunctionScopes.pop_back();
484}
485
486/// \brief Determine whether any errors occurred within this function/method/
487/// block.
488bool Sema::hasAnyErrorsInThisFunction() const {
489  unsigned NumErrors = TopFunctionScope.NumErrorsAtStartOfFunction;
490  if (!FunctionScopes.empty())
491    NumErrors = FunctionScopes.back()->NumErrorsAtStartOfFunction;
492  return NumErrors != getDiagnostics().getNumErrors();
493}
494
495BlockScopeInfo *Sema::getCurBlock() {
496  if (FunctionScopes.empty())
497    return 0;
498
499  return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
500}
501
502// Pin this vtable to this file.
503ExternalSemaSource::~ExternalSemaSource() {}
504