[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 ↗

(On Diff #167301)

Commited accidentally, removed in rC343205.

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

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();