Sema.cpp revision 30c0dd86f0dc3c1a1fba29581d04e8ed0bdb659d 
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/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
239static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
240  if (D->isUsed())
241    return true;
242
243  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
244    // UnusedFileScopedDecls stores the first declaration.
245    // The declaration may have become definition so check again.
246    const FunctionDecl *DeclToCheck;
247    if (FD->hasBody(DeclToCheck))
248      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
249
250    // Later redecls may add new information resulting in not having to warn,
251    // so check again.
252    DeclToCheck = FD->getMostRecentDeclaration();
253    if (DeclToCheck != FD)
254      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
255  }
256
257  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
258    // UnusedFileScopedDecls stores the first declaration.
259    // The declaration may have become definition so check again.
260    const VarDecl *DeclToCheck = VD->getDefinition();
261    if (DeclToCheck)
262      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
263
264    // Later redecls may add new information resulting in not having to warn,
265    // so check again.
266    DeclToCheck = VD->getMostRecentDeclaration();
267    if (DeclToCheck != VD)
268      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
269  }
270
271  return false;
272}
273
274/// ActOnEndOfTranslationUnit - This is called at the very end of the
275/// translation unit when EOF is reached and all but the top-level scope is
276/// popped.
277void Sema::ActOnEndOfTranslationUnit() {
278  // At PCH writing, implicit instantiations and VTable handling info are
279  // stored and performed when the PCH is included.
280  if (CompleteTranslationUnit)
281    while (1) {
282      // C++: Perform implicit template instantiations.
283      //
284      // FIXME: When we perform these implicit instantiations, we do not
285      // carefully keep track of the point of instantiation (C++ [temp.point]).
286      // This means that name lookup that occurs within the template
287      // instantiation will always happen at the end of the translation unit,
288      // so it will find some names that should not be found. Although this is
289      // common behavior for C++ compilers, it is technically wrong. In the
290      // future, we either need to be able to filter the results of name lookup
291      // or we need to perform template instantiations earlier.
292      PerformPendingImplicitInstantiations();
293
294      /// If DefinedUsedVTables ends up marking any virtual member
295      /// functions it might lead to more pending template
296      /// instantiations, which is why we need to loop here.
297      if (!DefineUsedVTables())
298        break;
299    }
300
301  // Remove file scoped decls that turned out to be used.
302  UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(),
303                                             UnusedFileScopedDecls.end(),
304                              std::bind1st(std::ptr_fun(ShouldRemoveFromUnused),
305                                           this)),
306                              UnusedFileScopedDecls.end());
307
308  if (!CompleteTranslationUnit)
309    return;
310
311  // Check for #pragma weak identifiers that were never declared
312  // FIXME: This will cause diagnostics to be emitted in a non-determinstic
313  // order!  Iterating over a densemap like this is bad.
314  for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
315       I = WeakUndeclaredIdentifiers.begin(),
316       E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
317    if (I->second.getUsed()) continue;
318
319    Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
320      << I->first;
321  }
322
323  // C99 6.9.2p2:
324  //   A declaration of an identifier for an object that has file
325  //   scope without an initializer, and without a storage-class
326  //   specifier or with the storage-class specifier static,
327  //   constitutes a tentative definition. If a translation unit
328  //   contains one or more tentative definitions for an identifier,
329  //   and the translation unit contains no external definition for
330  //   that identifier, then the behavior is exactly as if the
331  //   translation unit contains a file scope declaration of that
332  //   identifier, with the composite type as of the end of the
333  //   translation unit, with an initializer equal to 0.
334  llvm::SmallSet<VarDecl *, 32> Seen;
335  for (unsigned i = 0, e = TentativeDefinitions.size(); i != e; ++i) {
336    VarDecl *VD = TentativeDefinitions[i]->getActingDefinition();
337
338    // If the tentative definition was completed, getActingDefinition() returns
339    // null. If we've already seen this variable before, insert()'s second
340    // return value is false.
341    if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
342      continue;
343
344    if (const IncompleteArrayType *ArrayT
345        = Context.getAsIncompleteArrayType(VD->getType())) {
346      if (RequireCompleteType(VD->getLocation(),
347                              ArrayT->getElementType(),
348                              diag::err_tentative_def_incomplete_type_arr)) {
349        VD->setInvalidDecl();
350        continue;
351      }
352
353      // Set the length of the array to 1 (C99 6.9.2p5).
354      Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
355      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
356      QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
357                                                One, ArrayType::Normal, 0);
358      VD->setType(T);
359    } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
360                                   diag::err_tentative_def_incomplete_type))
361      VD->setInvalidDecl();
362
363    // Notify the consumer that we've completed a tentative definition.
364    if (!VD->isInvalidDecl())
365      Consumer.CompleteTentativeDefinition(VD);
366
367  }
368
369  // Output warning for unused file scoped decls.
370  for (std::vector<const DeclaratorDecl*>::iterator
371         I = UnusedFileScopedDecls.begin(),
372         E = UnusedFileScopedDecls.end(); I != E; ++I) {
373    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
374      const FunctionDecl *DiagD;
375      if (!FD->hasBody(DiagD))
376        DiagD = FD;
377      Diag(DiagD->getLocation(), diag::warn_unused_function)
378            << DiagD->getDeclName();
379    } else {
380      const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
381      if (!DiagD)
382        DiagD = cast<VarDecl>(*I);
383      Diag(DiagD->getLocation(), diag::warn_unused_variable)
384            << DiagD->getDeclName();
385    }
386  }
387}
388
389
390//===----------------------------------------------------------------------===//
391// Helper functions.
392//===----------------------------------------------------------------------===//
393
394DeclContext *Sema::getFunctionLevelDeclContext() {
395  DeclContext *DC = CurContext;
396
397  while (isa<BlockDecl>(DC) || isa<EnumDecl>(DC))
398    DC = DC->getParent();
399
400  return DC;
401}
402
403/// getCurFunctionDecl - If inside of a function body, this returns a pointer
404/// to the function decl for the function being parsed.  If we're currently
405/// in a 'block', this returns the containing context.
406FunctionDecl *Sema::getCurFunctionDecl() {
407  DeclContext *DC = getFunctionLevelDeclContext();
408  return dyn_cast<FunctionDecl>(DC);
409}
410
411ObjCMethodDecl *Sema::getCurMethodDecl() {
412  DeclContext *DC = getFunctionLevelDeclContext();
413  return dyn_cast<ObjCMethodDecl>(DC);
414}
415
416NamedDecl *Sema::getCurFunctionOrMethodDecl() {
417  DeclContext *DC = getFunctionLevelDeclContext();
418  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
419    return cast<NamedDecl>(DC);
420  return 0;
421}
422
423Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {
424  if (!this->Emit())
425    return;
426
427  // If this is not a note, and we're in a template instantiation
428  // that is different from the last template instantiation where
429  // we emitted an error, print a template instantiation
430  // backtrace.
431  if (!SemaRef.Diags.isBuiltinNote(DiagID) &&
432      !SemaRef.ActiveTemplateInstantiations.empty() &&
433      SemaRef.ActiveTemplateInstantiations.back()
434        != SemaRef.LastTemplateInstantiationErrorContext) {
435    SemaRef.PrintInstantiationStack();
436    SemaRef.LastTemplateInstantiationErrorContext
437      = SemaRef.ActiveTemplateInstantiations.back();
438  }
439}
440
441Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, unsigned DiagID) {
442  if (isSFINAEContext()) {
443    switch (Diagnostic::getDiagnosticSFINAEResponse(DiagID)) {
444    case Diagnostic::SFINAE_Report:
445      // Fall through; we'll report the diagnostic below.
446      break;
447
448    case Diagnostic::SFINAE_SubstitutionFailure:
449      // Count this failure so that we know that template argument deduction
450      // has failed.
451      ++NumSFINAEErrors;
452      // Fall through
453
454    case Diagnostic::SFINAE_Suppress:
455      // Suppress this diagnostic.
456      Diags.setLastDiagnosticIgnored();
457      return SemaDiagnosticBuilder(*this);
458    }
459  }
460
461  DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
462  return SemaDiagnosticBuilder(DB, *this, DiagID);
463}
464
465Sema::SemaDiagnosticBuilder
466Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
467  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
468  PD.Emit(Builder);
469
470  return Builder;
471}
472
473/// \brief Determines the active Scope associated with the given declaration
474/// context.
475///
476/// This routine maps a declaration context to the active Scope object that
477/// represents that declaration context in the parser. It is typically used
478/// from "scope-less" code (e.g., template instantiation, lazy creation of
479/// declarations) that injects a name for name-lookup purposes and, therefore,
480/// must update the Scope.
481///
482/// \returns The scope corresponding to the given declaraion context, or NULL
483/// if no such scope is open.
484Scope *Sema::getScopeForContext(DeclContext *Ctx) {
485
486  if (!Ctx)
487    return 0;
488
489  Ctx = Ctx->getPrimaryContext();
490  for (Scope *S = getCurScope(); S; S = S->getParent()) {
491    // Ignore scopes that cannot have declarations. This is important for
492    // out-of-line definitions of static class members.
493    if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
494      if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
495        if (Ctx == Entity->getPrimaryContext())
496          return S;
497  }
498
499  return 0;
500}
501
502/// \brief Enter a new function scope
503void Sema::PushFunctionScope() {
504  if (FunctionScopes.empty()) {
505    // Use the "top" function scope rather than having to allocate memory for
506    // a new scope.
507    TopFunctionScope.Clear(getDiagnostics().getNumErrors());
508    FunctionScopes.push_back(&TopFunctionScope);
509    return;
510  }
511
512  FunctionScopes.push_back(
513                      new FunctionScopeInfo(getDiagnostics().getNumErrors()));
514}
515
516void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
517  FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics().getNumErrors(),
518                                              BlockScope, Block));
519}
520
521void Sema::PopFunctionOrBlockScope() {
522  if (FunctionScopes.back() != &TopFunctionScope)
523    delete FunctionScopes.back();
524  else
525    TopFunctionScope.Clear(getDiagnostics().getNumErrors());
526
527  FunctionScopes.pop_back();
528}
529
530/// \brief Determine whether any errors occurred within this function/method/
531/// block.
532bool Sema::hasAnyErrorsInThisFunction() const {
533  unsigned NumErrors = TopFunctionScope.NumErrorsAtStartOfFunction;
534  if (!FunctionScopes.empty())
535    NumErrors = FunctionScopes.back()->NumErrorsAtStartOfFunction;
536  return NumErrors != getDiagnostics().getNumErrors();
537}
538
539BlockScopeInfo *Sema::getCurBlock() {
540  if (FunctionScopes.empty())
541    return 0;
542
543  return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
544}
545
546// Pin this vtable to this file.
547ExternalSemaSource::~ExternalSemaSource() {}
548