[Lex] TokenConcatenation now takes const Preprocessor

[dblaikie]

any particular motivation for this? But looks fine to me in any case.

[Szelethus]

Thanks!

any particular motivation for this?

I'm currently trying to include macro expansions in the Static Analyzer's plist output, and I only managed to make this happen by some Token handling hackery, including printing them. I saw this trick in lib/Rewrite/HTMLRewrite.cpp.

[Szelethus]

cfe/trunk/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h

82–84

Commited accidentally, removed in rC343205.

cfe/trunk/include/clang/Lex/TokenConcatenation.h

namespace clang {
   ///   "Is it safe to emit two tokens without a whitespace between them, or
   ///    would that cause implicit concatenation of the tokens?"
   ///
   /// For example, it emitting two identifiers "foo" and "bar" next to each
   /// other would cause the lexer to produce one "foobar" token.  Emitting "1"
   /// and ")" next to each other is safe.
   ///
   class TokenConcatenation {
-    Preprocessor &PP;
+    const Preprocessor &PP;
 
     enum AvoidConcatInfo {
       /// By default, a token never needs to avoid concatenation.  Most tokens
       /// (e.g. ',', ')', etc) don't cause a problem when concatenated.
       aci_never_avoid_concat = 0,
 
       /// aci_custom_firstchar - AvoidConcat contains custom code to handle this
       /// token's requirements, and it needs to know the first character of the
enum AvoidConcatInfo {
       aci_avoid_equal = 4
     };
 
     /// TokenInfo - This array contains information for each token on what
     /// action to take when avoiding concatenation of tokens in the AvoidConcat
     /// method.
     char TokenInfo[tok::NUM_TOKENS];
   public:
-    TokenConcatenation(Preprocessor &PP);
+    TokenConcatenation(const Preprocessor &PP);
 
     bool AvoidConcat(const Token &PrevPrevTok,
                      const Token &PrevTok,
                      const Token &Tok) const;
 
   private:
     /// IsIdentifierStringPrefix - Return true if the spelling of the token
     /// is literally 'L', 'u', 'U', or 'u8'.
     bool IsIdentifierStringPrefix(const Token &Tok) const;
   };
   } // end clang namespace
 
 #endif

cfe/trunk/lib/Lex/TokenConcatenation.cpp

if (Tok.getLength() < 256) {
     const char *TokPtr = Buffer;
     unsigned length = PP.getSpelling(Tok, TokPtr);
     return IsStringPrefix(StringRef(TokPtr, length), LangOpts.CPlusPlus11);
   }
 
   return IsStringPrefix(StringRef(PP.getSpelling(Tok)), LangOpts.CPlusPlus11);
 }
 
-TokenConcatenation::TokenConcatenation(Preprocessor &pp) : PP(pp) {
+TokenConcatenation::TokenConcatenation(const Preprocessor &pp) : PP(pp) {
   memset(TokenInfo, 0, sizeof(TokenInfo));
 
   // These tokens have custom code in AvoidConcat.
   TokenInfo[tok::identifier      ] |= aci_custom;
   TokenInfo[tok::numeric_constant] |= aci_custom_firstchar;
   TokenInfo[tok::period          ] |= aci_custom_firstchar;
   TokenInfo[tok::amp             ] |= aci_custom_firstchar;
   TokenInfo[tok::plus            ] |= aci_custom_firstchar;
TokenConcatenation::TokenConcatenation(const Preprocessor &pp) : PP(pp) {
   TokenInfo[tok::lessless    ] |= aci_avoid_equal;           // <<=
   TokenInfo[tok::greatergreater] |= aci_avoid_equal;         // >>=
   TokenInfo[tok::caret       ] |= aci_avoid_equal;           // ^=
   TokenInfo[tok::equal       ] |= aci_avoid_equal;           // ==
 }
 
 /// GetFirstChar - Get the first character of the token \arg Tok,
 /// avoiding calls to getSpelling where possible.
-static char GetFirstChar(Preprocessor &PP, const Token &Tok) {
+static char GetFirstChar(const Preprocessor &PP, const Token &Tok) {
   if (IdentifierInfo *II = Tok.getIdentifierInfo()) {
     // Avoid spelling identifiers, the most common form of token.
     return II->getNameStart()[0];
   } else if (!Tok.needsCleaning()) {
     if (Tok.isLiteral() && Tok.getLiteralData()) {
       return *Tok.getLiteralData();
     } else {
       SourceManager &SM = PP.getSourceManager();

cfe/trunk/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h

 /// A lightweight polymorphic wrapper around FieldRegion *. We'll use this
 /// interface to store addinitional information about fields. As described
 /// later, a list of these objects (i.e. "fieldchain") will be constructed and
 /// used for printing note messages should an uninitialized value be found.
 class FieldNode {
 protected:
   const FieldRegion *FR;
 
-  /// FieldNodes are never meant to be created on the heap, see
-  /// FindUninitializedFields::addFieldToUninits().
-  /* non-virtual */ ~FieldNode() = default;
+  // TODO: This destructor shouldn't be virtual, but breaks buildbots with
+  // -Werror -Wnon-virtual-dtor.
+  virtual ~FieldNode() = default;
 
 public:
   FieldNode(const FieldRegion *FR) : FR(FR) {}
 
   // We'll delete all of these special member functions to force the users of
   // this interface to only store references to FieldNode objects in containers.
   FieldNode() = delete;
   FieldNode(const FieldNode &) = delete;