Sema.cpp revision ba91143029e953e8e813d3f4d2bafef96ba52770 
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 functions that turned out to be used.
266  UnusedStaticFuncs.erase(std::remove_if(UnusedStaticFuncs.begin(),
267                                         UnusedStaticFuncs.end(),
268                             std::bind2nd(std::mem_fun(&FunctionDecl::isUsed),
269                                          true)),
270                          UnusedStaticFuncs.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 functions.
334  for (std::vector<FunctionDecl*>::iterator
335       F = UnusedStaticFuncs.begin(),
336       FEnd = UnusedStaticFuncs.end();
337       F != FEnd;
338       ++F)
339    Diag((*F)->getLocation(), diag::warn_unused_function) << (*F)->getDeclName();
340
341}
342
343
344//===----------------------------------------------------------------------===//
345// Helper functions.
346//===----------------------------------------------------------------------===//
347
348DeclContext *Sema::getFunctionLevelDeclContext() {
349  DeclContext *DC = CurContext;
350
351  while (isa<BlockDecl>(DC) || isa<EnumDecl>(DC))
352    DC = DC->getParent();
353
354  return DC;
355}
356
357/// getCurFunctionDecl - If inside of a function body, this returns a pointer
358/// to the function decl for the function being parsed.  If we're currently
359/// in a 'block', this returns the containing context.
360FunctionDecl *Sema::getCurFunctionDecl() {
361  DeclContext *DC = getFunctionLevelDeclContext();
362  return dyn_cast<FunctionDecl>(DC);
363}
364
365ObjCMethodDecl *Sema::getCurMethodDecl() {
366  DeclContext *DC = getFunctionLevelDeclContext();
367  return dyn_cast<ObjCMethodDecl>(DC);
368}
369
370NamedDecl *Sema::getCurFunctionOrMethodDecl() {
371  DeclContext *DC = getFunctionLevelDeclContext();
372  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
373    return cast<NamedDecl>(DC);
374  return 0;
375}
376
377Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {
378  if (!this->Emit())
379    return;
380
381  // If this is not a note, and we're in a template instantiation
382  // that is different from the last template instantiation where
383  // we emitted an error, print a template instantiation
384  // backtrace.
385  if (!SemaRef.Diags.isBuiltinNote(DiagID) &&
386      !SemaRef.ActiveTemplateInstantiations.empty() &&
387      SemaRef.ActiveTemplateInstantiations.back()
388        != SemaRef.LastTemplateInstantiationErrorContext) {
389    SemaRef.PrintInstantiationStack();
390    SemaRef.LastTemplateInstantiationErrorContext
391      = SemaRef.ActiveTemplateInstantiations.back();
392  }
393}
394
395Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, unsigned DiagID) {
396  if (isSFINAEContext()) {
397    switch (Diagnostic::getDiagnosticSFINAEResponse(DiagID)) {
398    case Diagnostic::SFINAE_Report:
399      // Fall through; we'll report the diagnostic below.
400      break;
401
402    case Diagnostic::SFINAE_SubstitutionFailure:
403      // Count this failure so that we know that template argument deduction
404      // has failed.
405      ++NumSFINAEErrors;
406      // Fall through
407
408    case Diagnostic::SFINAE_Suppress:
409      // Suppress this diagnostic.
410      Diags.setLastDiagnosticIgnored();
411      return SemaDiagnosticBuilder(*this);
412    }
413  }
414
415  DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
416  return SemaDiagnosticBuilder(DB, *this, DiagID);
417}
418
419Sema::SemaDiagnosticBuilder
420Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
421  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
422  PD.Emit(Builder);
423
424  return Builder;
425}
426
427/// \brief Determines the active Scope associated with the given declaration
428/// context.
429///
430/// This routine maps a declaration context to the active Scope object that
431/// represents that declaration context in the parser. It is typically used
432/// from "scope-less" code (e.g., template instantiation, lazy creation of
433/// declarations) that injects a name for name-lookup purposes and, therefore,
434/// must update the Scope.
435///
436/// \returns The scope corresponding to the given declaraion context, or NULL
437/// if no such scope is open.
438Scope *Sema::getScopeForContext(DeclContext *Ctx) {
439
440  if (!Ctx)
441    return 0;
442
443  Ctx = Ctx->getPrimaryContext();
444  for (Scope *S = getCurScope(); S; S = S->getParent()) {
445    // Ignore scopes that cannot have declarations. This is important for
446    // out-of-line definitions of static class members.
447    if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
448      if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
449        if (Ctx == Entity->getPrimaryContext())
450          return S;
451  }
452
453  return 0;
454}
455
456/// \brief Enter a new function scope
457void Sema::PushFunctionScope() {
458  if (FunctionScopes.empty()) {
459    // Use the "top" function scope rather than having to allocate memory for
460    // a new scope.
461    TopFunctionScope.Clear(getDiagnostics().getNumErrors());
462    FunctionScopes.push_back(&TopFunctionScope);
463    return;
464  }
465
466  FunctionScopes.push_back(
467                      new FunctionScopeInfo(getDiagnostics().getNumErrors()));
468}
469
470void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
471  FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics().getNumErrors(),
472                                              BlockScope, Block));
473}
474
475void Sema::PopFunctionOrBlockScope() {
476  if (FunctionScopes.back() != &TopFunctionScope)
477    delete FunctionScopes.back();
478  else
479    TopFunctionScope.Clear(getDiagnostics().getNumErrors());
480
481  FunctionScopes.pop_back();
482}
483
484/// \brief Determine whether any errors occurred within this function/method/
485/// block.
486bool Sema::hasAnyErrorsInThisFunction() const {
487  unsigned NumErrors = TopFunctionScope.NumErrorsAtStartOfFunction;
488  if (!FunctionScopes.empty())
489    NumErrors = FunctionScopes.back()->NumErrorsAtStartOfFunction;
490  return NumErrors != getDiagnostics().getNumErrors();
491}
492
493BlockScopeInfo *Sema::getCurBlock() {
494  if (FunctionScopes.empty())
495    return 0;
496
497  return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
498}
499
500// Pin this vtable to this file.
501ExternalSemaSource::~ExternalSemaSource() {}
502