feat: Add PP_INTERNAL_VARIABLE to track header dependencies

Signed-off-by: Roberto Raggi <[email protected]>

Author: robertoraggi

packages/cxx-frontend/src/TokenKind.ts

@@ -32,6 +32,7 @@ export enum TokenKind {
   UTF32_STRING_LITERAL,
   UTF8_STRING_LITERAL,
   WIDE_STRING_LITERAL,
+  PP_INTERNAL_VARIABLE,
   AMP_AMP,
   AMP_EQUAL,
   AMP,

packages/cxx-gen-ast/src/tokens.ts

@@ -32,6 +32,7 @@ export const BASE_TOKENS: string[] = [
   "UTF32_STRING_LITERAL",
   "UTF8_STRING_LITERAL",
   "WIDE_STRING_LITERAL",
+  "PP_INTERNAL_VARIABLE",
 ];
 
 export const OPERATORS: Array<[kind: string, spelling: string]> = [

src/parser/cxx/preprocessor.cc

@@ -731,6 +731,15 @@ struct Preprocessor::Private {
   std::function<std::string(std::string)> readFile_;
   std::function<void(const std::string &, int)> willIncludeHeader_;
   std::vector<Buffer> buffers_;
+  struct Dep {
+    std::string_view local;
+    Include include;
+    bool isIncludeNext = false;
+    int value = 0;
+  };
+  std::vector<Dep> dependencies_;
+  int localCount_ = 0;
+
   int counter_ = 0;
   int includeDepth_ = 0;
   bool omitLineMarkers_ = false;
@@ -1379,6 +1388,15 @@ void Preprocessor::Private::initialize() {
     return cons(tk, ts);
   };
 
+  auto replaceWithLocal = [this](const Tok *token, std::string_view local,
+                                 TokList *ts) {
+    auto tk = gen(TokenKind::T_PP_INTERNAL_VARIABLE, local);
+    tk->sourceFile = token->sourceFile;
+    tk->space = token->space;
+    tk->bol = token->bol;
+    return cons(tk, ts);
+  };
+
   adddBuiltinFunctionMacro(
       "__has_feature",
       [this, replaceWithBoolLiteral](
@@ -1435,7 +1453,7 @@ void Preprocessor::Private::initialize() {
         return replaceWithBoolLiteral(macroId, enabled, ts);
       });
 
-  auto hasInclude = [this, replaceWithBoolLiteral](
+  auto hasInclude = [this, replaceWithLocal, replaceWithBoolLiteral](
                         const MacroExpansionContext &context) -> TokList * {
     auto ts = context.ts;
 
@@ -1478,9 +1496,11 @@ void Preprocessor::Private::initialize() {
       include = SystemInclude(std::move(fn));
     }
 
-    const auto value = resolve(include, isIncludeNext);
+    std::string_view local = string(std::format("@{}", localCount_++));
+
+    dependencies_.push_back({local, include, isIncludeNext});
 
-    return replaceWithBoolLiteral(macroName, value.has_value(), rest);
+    return replaceWithLocal(macroName, local, rest);
   };
 
   adddBuiltinFunctionMacro("__has_include", hasInclude);
@@ -1710,6 +1730,8 @@ auto Preprocessor::Private::parseDirective(SourceFile *source, TokList *start)
 
   if (!lookat(directive, TokenKind::T_IDENTIFIER)) return std::nullopt;
 
+  dependencies_.clear();
+
   const auto directiveKind = classifyDirective(directive->tok->text.data(),
                                                directive->tok->text.length());
 
@@ -2344,8 +2366,14 @@ auto Preprocessor::Private::copyLine(TokList *ts, bool inMacroBody)
 
 auto Preprocessor::Private::constantExpression(TokList *ts) -> long {
   auto line = copyLine(ts);
+  dependencies_.clear();
   auto it = expandTokens(TokIterator{line}, TokIterator{},
                          /*inConditionalExpression*/ true);
+  // evaluate the deps
+  for (auto &d : dependencies_) {
+    auto resolved = resolve(d.include, d.isIncludeNext);
+    d.value = resolved.has_value();
+  }
   auto e = it.toTokList();
   return conditionalExpression(e);
 }
@@ -2527,6 +2555,13 @@ auto Preprocessor::Private::primaryExpression(TokList *&ts) -> long {
     auto result = conditionalExpression(ts);
     expect(ts, TokenKind::T_RPAREN);
     return result;
+  } else if (tk->is(TokenKind::T_PP_INTERNAL_VARIABLE)) {
+    for (const auto &dep : dependencies_) {
+      if (dep.local == tk->text) {
+        ts = ts->next;
+        return dep.value;
+      }
+    }
   }
 
   ts = ts->next;

src/parser/cxx/token_fwd.h

@@ -42,7 +42,8 @@ class Token;
   V(UTF16_STRING_LITERAL, "<utf16_string_literal>")               \
   V(UTF32_STRING_LITERAL, "<utf32_string_literal>")               \
   V(UTF8_STRING_LITERAL, "<utf8_string_literal>")                 \
-  V(WIDE_STRING_LITERAL, "<wide_string_literal>")
+  V(WIDE_STRING_LITERAL, "<wide_string_literal>")                 \
+  V(PP_INTERNAL_VARIABLE, "<PP_INTERNAL_VARIABLE>")
 
 #define FOR_EACH_OPERATOR(V)      \
   V(AMP_AMP, "&&")                \