Merge pull request #6 from RedpointGames/iwyu-detection

Add include-what-you-use detection to find unneeded headers

clang/include/clang/AST/Decl.h

@@ -264,7 +264,7 @@ class NamedDecl : public Decl {
   NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
       : Decl(DK, DC, L), Name(N)
       // @unreal: BEGIN
-      , UnrealType(UnrealType::UT_None), UnrealSpecifiers(), UnrealMetadata()
+        , UnrealType(UnrealType::UT_None), UnrealExported(false), UnrealSpecifiers(), UnrealMetadata()
       // @unreal: END
       {}
 
@@ -273,6 +273,12 @@ class NamedDecl : public Decl {
   /// The Unreal type flag for this decl.
   unsigned UnrealType;
 
+  /// If true, this type is exported from modules as far as Unreal
+  /// is concerned. This is set when _API is present on the type,
+  /// and can be used to track that _API is present regardless of
+  /// what the macro expands to.
+  bool UnrealExported;
+
   /// The Unreal specifiers that are associated with this decl.
   /// todo: Make this a map for faster lookups.
   std::vector<UnrealSpecifier> UnrealSpecifiers;

clang/include/clang/ASTMatchers/ASTMatchers.Unreal.h

@@ -501,4 +501,16 @@ AST_MATCHER(QualType, isExpensiveToCopy) {
   return IsExpensive && *IsExpensive;
 }
 
+/// Matches if a named decl has an ..._API macro applied to it.
+///
+/// Given
+/// \code
+///   class MYMODULE_API FSomeDecl {};
+/// \endcode
+/// \c namedDecl(isUnrealExported())
+///   matches the class.
+AST_MATCHER(NamedDecl, isUnrealExported) {
+  return Node.UnrealExported;
+}
+
 // @unreal: END

clang/include/clang/Basic/DiagnosticGroups.td

@@ -1494,4 +1494,5 @@ def UnsafeBufferUsage : DiagGroup<"unsafe-buffer-usage", [UnsafeBufferUsageInCon
 
 // @unreal: BEGIN
 def UnrealEngine : DiagGroup<"unreal-engine">;
+def IncludeWhatYouUse : DiagGroup<"include-what-you-use">;
 // @unreal: END

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3467,6 +3467,15 @@ def warn_unreal_data_discarded_on_new_specifier : Warning<
   InGroup<UnrealEngine>;
 def note_unreal_data_previous_location : Note<
   "previously discarded metadata was located here">;
+def err_unreal_annotation_found_in_unexpected_place : Error<
+  "Unreal Engine macro used in unexpected place">;
+def warn_iwyu_remove_unused_header : Warning<
+  "#include header is completely unused and can be removed">, 
+  InGroup<IncludeWhatYouUse>;
+def warn_iwyu_replace_unused_header : Warning<
+  "#include header does not contain any immediate dependency "
+  "and can be replaced with an #include to '%0' instead">, 
+  InGroup<IncludeWhatYouUse>;
 // @unreal: END
 
 def err_anonymous_property: Error<

clang/include/clang/Basic/TokenKinds.def

@@ -995,6 +995,7 @@ PRAGMA_ANNOTATION(unreal_uinterface)
 PRAGMA_ANNOTATION(unreal_ustruct)
 PRAGMA_ANNOTATION(unreal_specifier)
 PRAGMA_ANNOTATION(unreal_metadata_specifier)
+PRAGMA_ANNOTATION(unreal_exported)
 // @unreal: END
 
 #undef PRAGMA_ANNOTATION

clang/include/clang/Lex/PPCallbacks.h

@@ -27,6 +27,9 @@ class IdentifierInfo;
 class MacroDefinition;
 class MacroDirective;
 class MacroArgs;
+class LookupResult;
+class Scope;
+class DeclContext;
 
 /// This interface provides a way to observe the actions of the
 /// preprocessor as it does its thing.
@@ -428,6 +431,12 @@ class PPCallbacks {
   /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
   virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) {
   }
+
+  // @unreal: BEGIN
+  /// Hook when the semantic system performs a successful lookup.
+  virtual void SemaSuccessfulLookup(LookupResult &R, Scope *S) {}
+  virtual void SemaSuccessfulLookup(LookupResult &R, DeclContext *DC) {}
+  // @unreal: END
 };
 
 /// Simple wrapper class for chaining callbacks.
@@ -702,6 +711,17 @@ class PPChainedCallbacks : public PPCallbacks {
     First->Endif(Loc, IfLoc);
     Second->Endif(Loc, IfLoc);
   }
+
+  // @unreal: BEGIN
+  void SemaSuccessfulLookup(LookupResult &R, Scope *S) override {
+    First->SemaSuccessfulLookup(R, S);
+    Second->SemaSuccessfulLookup(R, S);
+  }
+  void SemaSuccessfulLookup(LookupResult &R, DeclContext *DC) override {
+    First->SemaSuccessfulLookup(R, DC);
+    Second->SemaSuccessfulLookup(R, DC);
+  }
+  // @unreal: END
 };
 
 }  // end namespace clang

clang/include/clang/Parse/Parser.Unreal.h

@@ -0,0 +1 @@
+void PPLexWithUnrealAnnotationTokens();

clang/include/clang/Parse/Parser.h

@@ -509,6 +509,10 @@ class Parser : public CodeCompletionHandler {
     return ParseTopLevelDecl(Result, IS);
   }
 
+  // @unreal: BEGIN
+  #include "Parser.Unreal.h"
+  // @unreal: END
+
   /// ConsumeToken - Consume the current 'peek token' and lex the next one.
   /// This does not work with special tokens: string literals, code completion,
   /// annotation tokens and balanced tokens must be handled using the specific
@@ -518,7 +522,9 @@ class Parser : public CodeCompletionHandler {
     assert(!isTokenSpecial() &&
            "Should consume special tokens with Consume*Token");
     PrevTokLocation = Tok.getLocation();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return PrevTokLocation;
   }
 
@@ -528,7 +534,9 @@ class Parser : public CodeCompletionHandler {
     assert(!isTokenSpecial() &&
            "Should consume special tokens with Consume*Token");
     PrevTokLocation = Tok.getLocation();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return true;
   }
 
@@ -606,15 +614,19 @@ class Parser : public CodeCompletionHandler {
   void UnconsumeToken(Token &Consumed) {
       Token Next = Tok;
       PP.EnterToken(Consumed, /*IsReinject*/true);
-      PP.Lex(Tok);
+      // @unreal: BEGIN
+      PPLexWithUnrealAnnotationTokens();
+      // @unreal: END
       PP.EnterToken(Next, /*IsReinject*/true);
   }
 
   SourceLocation ConsumeAnnotationToken() {
     assert(Tok.isAnnotation() && "wrong consume method");
     SourceLocation Loc = Tok.getLocation();
     PrevTokLocation = Tok.getAnnotationEndLoc();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return Loc;
   }
 
@@ -629,7 +641,9 @@ class Parser : public CodeCompletionHandler {
       --ParenCount;       // Don't let unbalanced )'s drive the count negative.
     }
     PrevTokLocation = Tok.getLocation();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return PrevTokLocation;
   }
 
@@ -645,7 +659,9 @@ class Parser : public CodeCompletionHandler {
     }
 
     PrevTokLocation = Tok.getLocation();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return PrevTokLocation;
   }
 
@@ -661,7 +677,9 @@ class Parser : public CodeCompletionHandler {
     }
 
     PrevTokLocation = Tok.getLocation();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return PrevTokLocation;
   }
 
@@ -673,7 +691,9 @@ class Parser : public CodeCompletionHandler {
     assert(isTokenStringLiteral() &&
            "Should only consume string literals with this method");
     PrevTokLocation = Tok.getLocation();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return PrevTokLocation;
   }
 
@@ -685,7 +705,9 @@ class Parser : public CodeCompletionHandler {
   SourceLocation ConsumeCodeCompletionToken() {
     assert(Tok.is(tok::code_completion));
     PrevTokLocation = Tok.getLocation();
-    PP.Lex(Tok);
+    // @unreal: BEGIN
+    PPLexWithUnrealAnnotationTokens();
+    // @unreal: END
     return PrevTokLocation;
   }
 
@@ -733,18 +755,6 @@ class Parser : public CodeCompletionHandler {
   /// #pragma GCC visibility...
   void HandlePragmaVisibility();
 
-  // @unreal: BEGIN
-  /// Consume any and all Unreal Engine tokens into the stack.
-  void ConsumePragmaUnreal();
-
-  /// Checks that there aren't any Unreal tokens on the stack.
-  void CheckNoPragmaUnreal();
-
-  /// Handle Unreal Engine semantics.
-  void HandlePragmaUnreal(tok::TokenKind Kind,
-                          const UnrealSpecifier &UnrealData);
-  // @unreal: END
-
   /// Handle the annotation token produced for
   /// #pragma pack...
   void HandlePragmaPack();

clang/include/clang/Sema/Sema.Unreal.h

@@ -0,0 +1,21 @@
+// Unreal stacks.
+struct UnrealSpecifierSema {
+  tok::TokenKind Kind;
+  clang::UnrealSpecifier SpecData;
+  clang::SourceLocation Loc;
+  UnrealSpecifierSema(tok::TokenKind InKind,
+                      const clang::UnrealSpecifier &InSpecData,
+                      const clang::SourceLocation &InLoc)
+      : Kind(InKind), SpecData(InSpecData), Loc(InLoc){};
+};
+std::vector<UnrealSpecifierSema> UnrealStack;
+std::map<std::string, CXXRecordDecl *>
+    ExpectedIInterfaceToUInterfaceAttachments;
+
+void ActOnUnrealData(SourceLocation TokenLoc, tok::TokenKind Kind,
+                      const UnrealSpecifier &UnrealData);
+
+/// Called to add specifiers from the Unreal stack.
+void AddUnrealSpecifiersForDecl(Decl *RD);
+
+void ProcessUnrealInterfaceMappings(TagDecl* New);

clang/include/clang/Sema/Sema.h

@@ -704,19 +704,7 @@ class Sema final {
   PragmaStack<bool> StrictGuardStackCheckStack;
 
   // @unreal: BEGIN
-  // Unreal stacks.
-  struct UnrealSpecifierSema {
-    tok::TokenKind Kind;
-    clang::UnrealSpecifier SpecData;
-    clang::SourceLocation Loc;
-    UnrealSpecifierSema(tok::TokenKind InKind,
-                        const clang::UnrealSpecifier &InSpecData,
-                        const clang::SourceLocation &InLoc)
-        : Kind(InKind), SpecData(InSpecData), Loc(InLoc){};
-  };
-  std::vector<UnrealSpecifierSema> UnrealStack;
-  std::map<std::string, CXXRecordDecl *>
-      ExpectedIInterfaceToUInterfaceAttachments;
+  #include "Sema.Unreal.h"
   // @unreal: END
 
   // This stack tracks the current state of Sema.CurFPFeatures.
@@ -10923,11 +10911,6 @@ class Sema final {
   void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
                                SourceLocation PragmaLoc);
 
-  // @unreal: BEGIN
-  void ActOnUnrealData(SourceLocation TokenLoc, tok::TokenKind Kind,
-                       const UnrealSpecifier &UnrealData);
-  // @unreal: END
-
   /// ActOnPragmaPack - Called on well formed \#pragma pack(...).
   void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
                        StringRef SlotLabel, Expr *Alignment);
@@ -11090,11 +11073,6 @@ class Sema final {
   /// Called to set exception behavior for floating point operations.
   void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind);
 
-  // @unreal: BEGIN
-  /// Called to add specifiers from the Unreal stack.
-  void AddUnrealSpecifiersForDecl(Decl *RD);
-  // @unreal: END
-
   /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
   /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
   void AddAlignmentAttributesForRecord(RecordDecl *RD);

clang/lib/ASTMatchers/Dynamic/Registry.Unreal.h

@@ -18,4 +18,5 @@ REGISTER_MATCHER(isMissingDllImportOrExport);
 REGISTER_MATCHER(isPODType);
 REGISTER_MATCHER(hasRedundantNamespacing);
 REGISTER_MATCHER(isExpensiveToCopy);
+REGISTER_MATCHER(isUnrealExported);
 // @unreal: END