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