getIdentifierInfo now updates the returned information by default

[teemperor]

Summary

Calling Preprocessor::getIdentifierInfo is not automatically updating the returned identifier at the moment. This patch adds a flag that is ensuring by default that the returned IdentifierInfo is updated. The flag is true by default because that seems like the most logical behavior for this method. Can be turned off for performance reasons

[teemperor]

Work in progress patch. We probably also need to update a few other places where we call this.

include/clang/Lex/Preprocessor.h

public:
 
   const std::string &getPredefines() const { return Predefines; }
   /// \brief Set the predefines for this Preprocessor.
   ///
   /// These predefines are automatically injected when parsing the main file.
   void setPredefines(const char *P) { Predefines = P; }
   void setPredefines(StringRef P) { Predefines = P; }
 
-  /// Return information about the specified preprocessor
-  /// identifier token.
-  IdentifierInfo *getIdentifierInfo(StringRef Name) const {
-    return &Identifiers.get(Name);
-  }
+  /// Return information about the specified preprocessor identifier token.
+  /// If \p CheckOutOfDate is true, then the returned information is ensured
+  /// to be not out of date.
+  IdentifierInfo *getIdentifierInfo(StringRef Name,
+                                    bool CheckOutOfDate = true) const;
 
   /// \brief Add the specified pragma handler to this preprocessor.
   ///
   /// If \p Namespace is non-null, then it is a token required to exist on the
   /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
   void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler);
   void AddPragmaHandler(PragmaHandler *Handler) {
     AddPragmaHandler(StringRef(), Handler);

lib/Lex/Preprocessor.cpp

llvm::errs() << " [UnClean='" << StringRef(Start, Tok.getLength())
                  << "']";
   }
 
   llvm::errs() << "\tLoc=<";
   DumpLocation(Tok.getLocation());
   llvm::errs() << ">";
 }
 
+IdentifierInfo *Preprocessor::getIdentifierInfo(StringRef Name,
+                                                bool CheckOutOfDate) const {
+  IdentifierInfo &II = Identifiers.get(Name);
+  // If the information about this identifier is out of date, update it from
+  // the external source.
+  // We have to treat __VA_ARGS__ in a special way, since it gets
+  // serialized with isPoisoned = true, but our preprocessor may have
+  // unpoisoned it if we're defining a C99 macro.
+  if (CheckOutOfDate && II.isOutOfDate()) {
+    bool CurrentIsPoisoned = false;
+    if (&II == Ident__VA_ARGS__)
+      CurrentIsPoisoned = Ident__VA_ARGS__->isPoisoned();
+
+    updateOutOfDateIdentifier(II);
+
+    if (&II == Ident__VA_ARGS__)
+      II.setIsPoisoned(CurrentIsPoisoned);
+  }
+  return &II;
+}
+
 void Preprocessor::DumpLocation(SourceLocation Loc) const {
   Loc.dump(SourceMgr);
 }
 
 void Preprocessor::DumpMacro(const MacroInfo &MI) const {
   llvm::errs() << "MACRO: ";
   for (unsigned i = 0, e = MI.getNumTokens(); i != e; ++i) {
     DumpToken(MI.getReplacementToken(i));

 /// IdentifierInfo methods that compute these properties will need to change to
 /// match.
 bool Preprocessor::HandleIdentifier(Token &Identifier) {
   assert(Identifier.getIdentifierInfo() &&
          "Can't handle identifiers without identifier info!");
 
   IdentifierInfo &II = *Identifier.getIdentifierInfo();
 
-  // If the information about this identifier is out of date, update it from
-  // the external source.
-  // We have to treat __VA_ARGS__ in a special way, since it gets
-  // serialized with isPoisoned = true, but our preprocessor may have
-  // unpoisoned it if we're defining a C99 macro.
-  if (II.isOutOfDate()) {
-    bool CurrentIsPoisoned = false;
-    if (&II == Ident__VA_ARGS__)
-      CurrentIsPoisoned = Ident__VA_ARGS__->isPoisoned();
-
-    updateOutOfDateIdentifier(II);
-    Identifier.setKind(II.getTokenID());
 
-    if (&II == Ident__VA_ARGS__)
-      II.setIsPoisoned(CurrentIsPoisoned);
-  }
-  
   // If this identifier was poisoned, and if it was not produced from a macro
   // expansion, emit an error.
   if (II.isPoisoned() && CurPPLexer) {
     HandlePoisonedIdentifier(Identifier);
   }
 
   // If this is a macro to be expanded, do it.
   if (MacroDefinition MD = getMacroDefinition(&II)) {