hdrstop proof of concept

[thakis]

Summary

not for review, pr38258

[mikerice]

I've made good progress on this. My lit tests are working. I will try it on the tests in our test suites and maybe I will have a patch for review in a few days.

include/clang/Lex/Preprocessor.h

private:
   FileID PredefinesFileID;
 
   /// The file ID for the PCH through header.
   FileID PCHThroughHeaderFileID;
 
   /// Whether tokens are being skipped until the through header is seen.
   bool SkippingUntilPCHThroughHeader = false;
 
+  /// XXX
+  bool SawHdrstop = false;
+
   /// \{
   /// Cache of macro expanders to reduce malloc traffic.
   enum { TokenLexerCacheSize = 8 };
   unsigned NumCachedTokenLexers;
   std::unique_ptr<TokenLexer> TokenLexerCache[TokenLexerCacheSize];
   /// \}
 
   /// Keeps macro expanded tokens for TokenLexers.
public:
   /// lex again.
   bool HandleIdentifier(Token &Identifier);
 
   /// Callback invoked when the lexer hits the end of the current file.
   ///
   /// This either returns the EOF token and returns true, or
   /// pops a level off the include stack and returns false, at which point the
   /// client should call lex again.
-  bool HandleEndOfFile(Token &Result, bool isEndOfMacro = false);
+  bool HandleEndOfFile(Token &Result, bool isEndOfMacro = false,
+                       bool IsHdrstop = false);
 
   /// Callback invoked when the current TokenLexer hits the end of its
   /// token stream.
   bool HandleEndOfTokenLexer(Token &Result);
 
   /// Callback invoked when the lexer sees a # token at the start of a
   /// line.
   ///
private:
   void HandleIfDirective(Token &Tok, const Token &HashToken,
                          bool ReadAnyTokensBeforeDirective);
   void HandleEndifDirective(Token &Tok);
   void HandleElseDirective(Token &Tok, const Token &HashToken);
   void HandleElifDirective(Token &Tok, const Token &HashToken);
 
   // Pragmas.
   void HandlePragmaDirective(SourceLocation IntroducerLoc,
-                             PragmaIntroducerKind Introducer);
+                             PragmaIntroducerKind Introducer, Token &Result);
 
 public:
   void HandlePragmaOnce(Token &OnceTok);
   void HandlePragmaMark();
   void HandlePragmaPoison();
   void HandlePragmaSystemHeader(Token &SysHeaderTok);
   void HandlePragmaDependency(Token &DependencyTok);
   void HandlePragmaPushMacro(Token &Tok);
   void HandlePragmaPopMacro(Token &Tok);
   void HandlePragmaIncludeAlias(Token &Tok);
   void HandlePragmaModuleBuild(Token &Tok);
+  void HandlePragmaHdrstop(Token &Tok);
   IdentifierInfo *ParsePragmaPushOrPopMacro(Token &Tok);
 
   // Return true and store the first token only if any CommentHandler
   // has inserted some tokens and getCommentRetentionState() is false.
   bool HandleComment(Token &Token, SourceRange Comment);
 
   /// A macro is used, update information about macros that need unused
   /// warnings.

lib/Lex/Lexer.cpp

do {
     }
 
     // We hit a token that we don't recognize as being in the
     // "preprocessing only" part of the file, so we're no longer in
     // the preamble.
     break;
   } while (true);
 
+// XXX might hook into this?
+
   SourceLocation End;
   if (ActiveCommentLoc.isValid())
     End = ActiveCommentLoc; // don't truncate a decl comment.
   else
     End = TheTok.getLocation();
 
   return PreambleBounds(End.getRawEncoding() - FileLoc.getRawEncoding(),
                         TheTok.isAtStartOfLine());

lib/Lex/PPDirectives.cpp

 /// Only #include (to check if it is the through header) and #define (to warn
 /// about macros that don't match the PCH) are handled. All other directives
 /// are completely discarded.
 void Preprocessor::HandleSkippedThroughHeaderDirective(Token &Result,
                                                        SourceLocation HashLoc) {
   if (const IdentifierInfo *II = Result.getIdentifierInfo()) {
     if (II->getPPKeywordID() == tok::pp_include)
       return HandleIncludeDirective(HashLoc, Result);
-    if (II->getPPKeywordID() == tok::pp_define)
-      return HandleDefineDirective(Result,
-                                   /*ImmediatelyAfterHeaderGuard=*/false);
+    //if (II->getPPKeywordID() == tok::pp_define)
+      //return HandleDefineDirective(Result,
+                                   ///*ImmediatelyAfterHeaderGuard=*/false);
+    if (II->getPPKeywordID() == tok::pp_pragma)
+      return HandlePragmaDirective(HashLoc, PIK_HashPragma, Result);
   }
   DiscardUntilEndOfDirective();
 }
 
 /// HandleDirective - This callback is invoked when the lexer sees a # token
 /// at the start of a line.  This consumes the directive, modifies the
 /// lexer/preprocessor state, and advances the lexer(s) so that the next token
 /// read is the correct one.
case tok::pp_line:
       return HandleLineDirective();
 
     // C99 6.10.5 - Error Directive.
     case tok::pp_error:
       return HandleUserDiagnosticDirective(Result, false);
 
     // C99 6.10.6 - Pragma Directive.
     case tok::pp_pragma:
-      return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma);
+      return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma,
+                                   Result);
 
     // GNU Extensions.
     case tok::pp_import:
       return HandleImportDirective(SavedHash.getLocation(), Result);
     case tok::pp_include_next:
       return HandleIncludeNextDirective(SavedHash.getLocation(), Result);
 
     case tok::pp_warning:
if (ShouldEnter && File && SuggestedModule && getLangOpts().Modules &&
     } else if (Imported.isConfigMismatch()) {
       // On a configuration mismatch, enter the header textually. We still know
       // that it's part of the corresponding module.
     } else {
       // We hit an error processing the import. Bail out.
       if (hadModuleLoaderFatalFailure()) {
         // With a fatal failure in the module loader, we abort parsing.
         Token &Result = IncludeTok;
-        if (CurLexer) {
+        if (CurLexer) {  // XXX something like this
           Result.startToken();
           CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
           CurLexer->cutOffLexing();
         } else {
           assert(CurPTHLexer && "#include but no current lexer set!");
           CurPTHLexer->getEOF(Result);
         }
       }

lib/Lex/PPLexerChange.cpp

if (const FileEntry *Header = getFileManager().getFile(Entry->getName()))
         }
       }
   }
 }
 
 /// HandleEndOfFile - This callback is invoked when the lexer hits the end of
 /// the current file.  This either returns the EOF token or pops a level off
 /// the include stack and keeps going.
-bool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {
+bool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro,
+                                   bool IsHdrstop) {
   assert(!CurTokenLexer &&
          "Ending a file when currently in a macro!");
+  if (CurTokenLexer)
+fprintf(stderr, "HandleEndOfFile CurTokenLexer\n");
+  else if (CurPPLexer) {
+    if (CurPPLexer->getFileEntry())
+fprintf(stderr, "HandleEndOfFile %s\n", CurPPLexer->getFileEntry()->getName().str().c_str());
+    else
+fprintf(stderr, "HandleEndOfFile no file\n");
+  }else
+fprintf(stderr, "HandleEndOfFile whatnow\n");
 
   // If we have an unclosed module region from a pragma at the end of a
   // module, complain and close it now.
   // FIXME: This is not correct if we are building a module from PTH.
   const bool LeavingSubmodule = CurLexer && CurLexerSubmodule;
   if ((LeavingSubmodule || IncludeMacroStack.empty()) &&
       !BuildingSubmoduleStack.empty() &&
       BuildingSubmoduleStack.back().IsPragma) {
fprintf(stderr, "HandleEndOfFile whatnow\n");
   if (PragmaAssumeNonNullLoc.isValid() &&
       !isEndOfMacro && !(CurLexer && CurLexer->Is_PragmaLexer)) {
     Diag(PragmaAssumeNonNullLoc, diag::err_pp_eof_in_assume_nonnull);
 
     // Recover by leaving immediately.
     PragmaAssumeNonNullLoc = SourceLocation();
   }
 
-  bool LeavingPCHThroughHeader = false;
+  bool LeavingPCHThroughHeader = SawHdrstop;
 
   // If this is a #include'd file, pop it off the include stack and continue
   // lexing the #includer file.
   if (!IncludeMacroStack.empty()) {
 
     // If we lexed the code-completion file, act as if we reached EOF.
     if (isCodeCompletionEnabled() && CurPPLexer &&
         SourceMgr.getLocForStartOfFile(CurPPLexer->getFileID()) ==
if (LeavingSubmodule) {
       CurLexer->BufferPtr = EndPos;
       CurLexer->FormTokenWithChars(Result, EndPos, tok::annot_module_end);
       Result.setAnnotationEndLoc(Result.getLocation());
       Result.setAnnotationValue(M);
     }
 
     bool FoundPCHThroughHeader = false;
     if (CurPPLexer && creatingPCHWithThroughHeader() &&
-        isPCHThroughHeader(
-            SourceMgr.getFileEntryForID(CurPPLexer->getFileID())))
+        isPCHThroughHeader(CurPPLexer->getFileEntry())) {
+fprintf(stderr, "FoundPCHThroughHeader\n");
       FoundPCHThroughHeader = true;
+    }
 
     // We're done with the #included file.
     RemoveTopOfLexerStack();
 
     // Propagate info about start-of-line/leading white-space/etc.
     PropagateLineStartLeadingSpaceInfo(Result);
 
     // Notify the client, if desired, that we are in a new source file.
fprintf(stderr, "FoundPCHThroughHeader\n");
 
     if (!isEndOfMacro && CurPPLexer && FoundPCHThroughHeader &&
         (isInPrimaryFile() ||
          CurPPLexer->getFileID() == getPredefinesFileID())) {
       // Leaving the through header. Continue directly to end of main file
       // processing.
       LeavingPCHThroughHeader = true;
     } else {
+fprintf(stderr, "LeavingSubmodule\n");
       // Client should lex another token unless we generated an EOM.
       return LeavingSubmodule;
     }
   }
 
+fprintf(stderr, "hi\n");
+
   // If this is the end of the main file, form an EOF token.
   if (CurLexer) {
+fprintf(stderr, "ho\n");
     const char *EndPos = getCurLexerEndPos();
     Result.startToken();
     CurLexer->BufferPtr = EndPos;
     CurLexer->FormTokenWithChars(Result, EndPos, tok::eof);
 
     if (isCodeCompletionEnabled()) {
       // Inserting the code-completion point increases the source buffer by 1,
       // but the main FileID was created before inserting the point.

lib/Lex/PPMacroExpansion.cpp

 bool Preprocessor::isNextPPTokenLParen() {
   // Do some quick tests for rejection cases.
   unsigned Val;
   if (CurLexer)
     Val = CurLexer->isNextPPTokenLParen();
   else if (CurPTHLexer)
     Val = CurPTHLexer->isNextPPTokenLParen();
   else
-    Val = CurTokenLexer->isNextTokenLParen();
+    Val = CurTokenLexer->isNextTokenLParen();  // XXX
 
   if (Val == 2) {
     // We have run off the end.  If it's a source file we don't
     // examine enclosing ones (C99 5.1.1.2p4).  Otherwise walk up the
     // macro stack.
     if (CurPPLexer)
       return false;
     for (const IncludeStackInfo &Entry : llvm::reverse(IncludeMacroStack)) {
MacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName,
   unsigned NumFixedArgsLeft = MI->getNumParams();
   bool isVariadic = MI->isVariadic();
 
   // Outer loop, while there are more arguments, keep reading them.
   Token Tok;
 
   // Read arguments as unexpanded tokens.  This avoids issues, e.g., where
   // an argument value in a macro could expand to ',' or '(' or ')'.
-  LexUnexpandedToken(Tok);
+  // XXX look at ( from macro too
+  //LexUnexpandedToken(Tok);
+  LexNonComment(Tok);
   assert(Tok.is(tok::l_paren) && "Error computing l-paren-ness?");
 
   // ArgTokens - Build up a list of tokens that make up each argument.  Each
   // argument is separated by an EOF token.  Use a SmallVector so we can avoid
   // heap allocations in the common case.
   SmallVector<Token, 64> ArgTokens;
   bool ContainsCodeCompletionTok = false;
   bool FoundElidedComma = false;

lib/Lex/Pragma.cpp

 
 //===----------------------------------------------------------------------===//
 // Preprocessor Pragma Directive Handling.
 //===----------------------------------------------------------------------===//
 
 /// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
 /// rest of the pragma, passing it to the registered pragma handlers.
 void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc,
-                                         PragmaIntroducerKind Introducer) {
+                                         PragmaIntroducerKind Introducer,
+                                         Token &Result) {
   if (Callbacks)
     Callbacks->PragmaDirective(IntroducerLoc, Introducer);
 
   if (!PragmasEnabled)
     return;
 
   ++NumPragma;
 
   // Invoke the first level of pragma handlers which reads the namespace id.
-  Token Tok;
-  PragmaHandlers->HandlePragma(*this, Introducer, Tok);
+  //Token Tok;
+  PragmaHandlers->HandlePragma(*this, Introducer, Result);
 
   // If the pragma handler didn't read the rest of the line, consume it now.
   if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective()) 
    || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
     DiscardUntilEndOfDirective();
 }
 
 namespace {
void Preprocessor::Handle_Pragma(Token &Tok) {
   // Make and enter a lexer object so that we lex and expand the tokens just
   // like any others.
   Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
                                         StrVal.size(), *this);
 
   EnterSourceFileWithLexer(TL, nullptr);
 
   // With everything set up, lex this as a #pragma directive.
-  HandlePragmaDirective(PragmaLoc, PIK__Pragma);
+  HandlePragmaDirective(PragmaLoc, PIK__Pragma, Tok);
 
   // Finally, return whatever came after the pragma directive.
   return Lex(Tok);
 }
 
 /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
 /// is not enclosed within a string literal.
 void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
 
   Token *TokArray = new Token[PragmaToks.size()];
   std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
 
   // Push the tokens onto the stack.
   EnterTokenStream(TokArray, PragmaToks.size(), true, true);
 
   // With everything set up, lex this as a #pragma directive.
-  HandlePragmaDirective(PragmaLoc, PIK___pragma);
+  HandlePragmaDirective(PragmaLoc, PIK___pragma, Tok);
 
   // Finally, return whatever came after the pragma directive.
   return Lex(Tok);
 }
 
 /// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
 void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
   // Don't honor the 'once' when handling the primary source file, unless
assert(CurLexer->getBuffer().begin() <= Start &&
          Start <= CurLexer->getBuffer().end() &&
          CurLexer->getBuffer().begin() <= End &&
          End <= CurLexer->getBuffer().end() &&
          "module source range not contained within same file buffer");
   TheModuleLoader.loadModuleFromSource(Loc, ModuleName->getName(),
                                        StringRef(Start, End - Start));
 }
 
+void Preprocessor::HandlePragmaHdrstop(Token &Tok) {
+  // XXX do this right in HandlePragma() instead (see other LexStringLiteral()
+  // clients in lib/Parse/ParsePragma.cpp)
+  // `#pragma hdrstop` can optionally be followed by '(' string_literal ')',
+  // check if that's present and parse it if it's there.
+  Lex(Tok);
+  if (Tok.isNot(tok::l_paren)) {
+    // XXX diag if this isn't eod
+    //Lex(Tok);  // consuming eod pops the macro off the stack
+    //     XXX wrong already popped (?)
+    // XXX only do anything if we're in the main tu?
+    // XXX probably also for ( arg ) form below
+    if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) {
+fprintf(stderr, "bar %s\n", Tok.getName());
+      // XXX probably also for ( arg ) form below
+      SkippingUntilPCHThroughHeader = false;
+    }
+    // XXX make sure this is only called once if there are several
+    // pragma hdrstops or the pragma and an include? or neuter logic in
+    // HandleEndOfFile?
+    if (creatingPCHWithThroughHeader()) {
+fprintf(stderr, "foo %s\n", Tok.getName());
+      // XXX need to get the eof Tok to the other lexing loop
+      //HandleEndOfFile(Tok, /*isEndOfMacro=*/false, /*IsHdrstop=*/true);
+      Token& Result = Tok;
+      //Token Result;
+      if (CurLexer) {  // XXX something like this
+        Result.startToken();
+        CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
+        CurLexer->cutOffLexing();
+      } else {
+        assert(CurPTHLexer && "#include but no current lexer set!");
+        CurPTHLexer->getEOF(Result);
+      }
+      // XXX calling this seems to prevent HandleEndOfFile() being called,
+      // which is good in that it suppresses the "didn't see through header"
+      // diag, but HandleEndOfFile() might do other important things
+      // Looks like Preprocessor::CachingLex() doesn't call HandleEndOfFile()
+      // on eof tokens, only Lexer::LexEndOfFile calls it.
+      //EnterToken(Result); // XXX need?
+      SawHdrstop = true;
+    }
+    return;
+  }
+
+  std::string Name;
+  // XXX Preprocessor::LexStringLiteral() doesn't handle wide, raw, unicode
+  // string literals (Lexer::LexStringLiteral() does).
+  if (!LexStringLiteral(Tok, Name, "pragma hdrstop",
+                        /*AllowMacroExpansion=*/true))
+    return;
+
+  if (Tok.isNot(tok::r_paren)) {
+    Diag(Tok, diag::err_expected) << tok::r_paren;
+    return;
+  }
+
+  // XXX diag if there are more tokens
+
+  // There was a syntactically valid '(' string_literal ')' after
+  // `#pragma hdrstop`.  After going through all this work, diag that that's
+  // not supported in clang. (XXX: unless it's the /Fp arg?)
+  // XXX: real diag (XXX warning or err?)
+  Diag(Tok, diag::err_pp_expected_rparen);
+}
+
 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
 /// If '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 Preprocessor::AddPragmaHandler(StringRef Namespace,
                                     PragmaHandler *Handler) {
   PragmaNamespace *InsertNS = PragmaHandlers.get();
 
   // If this is specified to be in a namespace, step down into it.
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     if (unknownDiag)
       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
         << WarningName;
     else if (Callbacks)
       Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
   }
 };
 
+/// "\#pragma hdrstop".
+struct PragmaHdrstopHandler : public PragmaHandler {
+  PragmaHdrstopHandler() : PragmaHandler("hdrstop") {}
+
+  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
+                    Token &DepToken) override {
+    PP.HandlePragmaHdrstop(DepToken);
+  }
+};
+
 /// "\#pragma warning(...)".  MSVC's diagnostics do not map cleanly to clang's
 /// diagnostics, so we don't really implement this pragma.  We parse it and
 /// ignore it to avoid -Wunknown-pragma warnings.
 struct PragmaWarningHandler : public PragmaHandler {
   PragmaWarningHandler() : PragmaHandler("warning") {}
 
   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                     Token &Tok) override {
void Preprocessor::RegisterBuiltinPragmas() {
   // Add region pragmas.
   AddPragmaHandler(new PragmaRegionHandler("region"));
   AddPragmaHandler(new PragmaRegionHandler("endregion"));
 
   // MS extensions.
   if (LangOpts.MicrosoftExt) {
     AddPragmaHandler(new PragmaWarningHandler());
     AddPragmaHandler(new PragmaIncludeAliasHandler());
+    AddPragmaHandler(new PragmaHdrstopHandler());
   }
 
   // Pragmas added by plugins
   for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(),
                                        ie = PragmaHandlerRegistry::end();
        it != ie; ++it) {
     AddPragmaHandler(it->instantiate().release());
   }

lib/Lex/Preprocessor.cpp

while (true) {
     CurLexer->Lex(Tok);
     if (Tok.is(tok::eof) && !InPredefines) {
       ReachedMainFileEOF = true;
       break;
     }
     if (!SkippingUntilPCHThroughHeader)
       break;
   }
+// XXX
   if (ReachedMainFileEOF)
     Diag(SourceLocation(), diag::err_pp_through_header_not_seen)
         << PPOpts->PCHThroughHeader << 1;
 }
 
 void Preprocessor::replayPreambleConditionalStack() {
   // Restore the conditional stack from the preamble, if there is one.
   if (PreambleConditionalStack.isReplaying()) {
bool Preprocessor::HandleIdentifier(Token &Identifier) {
   // If this is a macro to be expanded, do it.
   if (MacroDefinition MD = getMacroDefinition(&II)) {
     auto *MI = MD.getMacroInfo();
     assert(MI && "macro definition with no macro info?");
     if (!DisableMacroExpansion) {
       if (!Identifier.isExpandDisabled() && MI->isEnabled()) {
         // C99 6.10.3p10: If the preprocessing token immediately after the
         // macro name isn't a '(', this macro should not be expanded.
+        // XXX I think this means '(' coming from a macro doesn't count
         if (!MI->isFunctionLike() || isNextPPTokenLParen())
           return HandleMacroExpandedIdentifier(Identifier, MD);
       } else {
         // C99 6.10.3.4p2 says that a disabled macro may never again be
         // expanded, even if it's in a context where it could be expanded in the
         // future.
         Identifier.setFlag(Token::DisableExpand);
         if (MI->isObjectLike() || isNextPPTokenLParen())

lib/Lex/TokenLexer.cpp

 
 bool TokenLexer::MaybeRemoveCommaBeforeVaArgs(
     SmallVectorImpl<Token> &ResultToks, bool HasPasteOperator, MacroInfo *Macro,
     unsigned MacroArgNo, Preprocessor &PP) {
   // Is the macro argument __VA_ARGS__?
   if (!Macro->isVariadic() || MacroArgNo != Macro->getNumParams()-1)
     return false;
 
+// XXX
   // In Microsoft-compatibility mode, a comma is removed in the expansion
   // of " ... , __VA_ARGS__ " if __VA_ARGS__ is empty.  This extension is
   // not supported by gcc.
   if (!HasPasteOperator && !PP.getLangOpts().MSVCCompat)
     return false;
 
   // GCC removes the comma in the expansion of " ... , ## __VA_ARGS__ " if
   // __VA_ARGS__ is empty, but not in strict C99 mode where there are no
if (isFirstToken) {
     // leading whitespace if we've expanded a macro.
     if (AtStartOfLine) Tok.setFlag(Token::StartOfLine);
     if (HasLeadingSpace) Tok.setFlag(Token::LeadingSpace);
   }
   AtStartOfLine = false;
   HasLeadingSpace = false;
 
   // Handle recursive expansion!
+  // XXX this recurses ([cpp.rescan] i think)
   if (!Tok.isAnnotation() && Tok.getIdentifierInfo() != nullptr) {
     // Change the kind of this identifier to the appropriate token kind, e.g.
     // turning "for" into a keyword.
     IdentifierInfo *II = Tok.getIdentifierInfo();
     Tok.setKind(II->getTokenID());
 
     // If this identifier was poisoned and from a paste, emit an error.  This
     // won't be handled by Preprocessor::HandleIdentifier because this is coming

 
 /// isNextTokenLParen - If the next token lexed will pop this macro off the
 /// expansion stack, return 2.  If the next unexpanded token is a '(', return
 /// 1, otherwise return 0.
 unsigned TokenLexer::isNextTokenLParen() const {
   // Out of tokens?
   if (isAtEnd())
     return 2;
+#if 0
+  if (Tokens[CurToken].is(tok::identifier)) {
+    // XXX need to expand to know
+    // XXX several levels
+    IdentifierInfo *II = Tokens[CurToken].getIdentifierInfo();
+    MacroDefinition Macro = PP.getMacroDefinition(II);
+    if (Macro.getMacroInfo()) {
+      if (Macro.getMacroInfo()->getReplacementToken(0).is(tok::l_paren))
+        return true;
+    }
+  }
+  return Tokens[CurToken].is(tok::l_paren);
+#endif
   return Tokens[CurTokenIdx].is(tok::l_paren);
 }
 
 /// isParsingPreprocessorDirective - Return true if we are in the middle of a
 /// preprocessor directive.
 bool TokenLexer::isParsingPreprocessorDirective() const {
   return Tokens[NumTokens-1].is(tok::eod) && !isAtEnd();
 }