Implement code completion for preprocessor expressions and in macro

arguments.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@111976 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Lex/CodeCompletionHandler.h b/include/clang/Lex/CodeCompletionHandler.h
index ee02a227e6bffc53af47fdbb71d98f93016ffaf1..bb8705b9a63dd5f6fd4db7a4fb43f293531a3547 100644 (file)
--- a/include/clang/Lex/CodeCompletionHandler.h
+++ b/include/clang/Lex/CodeCompletionHandler.h
@@ -16,6 +16,9 @@
 
 namespace clang {
 
+class IdentifierInfo;
+class MacroInfo;
+  
 /// \brief Callback handler that receives notifications when performing code 
 /// completion within the preprocessor.
 class CodeCompletionHandler {
@@ -42,6 +45,16 @@ public:
   /// \param IsDefinition Whether this is the definition of a macro, e.g.,
   /// in a #define.
   virtual void CodeCompleteMacroName(bool IsDefinition) { }
+  
+  /// \brief Callback invoked when performing code completion in a preprocessor
+  /// expression, such as the condition of an #if or #elif directive.
+  virtual void CodeCompletePreprocessorExpression() { }
+  
+  /// \brief Callback invoked when performing code completion inside a 
+  /// function-like macro argument.
+  virtual void CodeCompleteMacroArgument(IdentifierInfo *Macro,
+                                         MacroInfo *MacroInfo,
+                                         unsigned ArgumentIndex) { }
 };
   
 }

diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index e4859630260c8193d2efb257ecd3426f82334a6f..1f680f8854f93ad1811ac34a163201435bf4aabc 100644 (file)
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -1536,6 +1536,10 @@ private:
   virtual void CodeCompleteDirective(bool InConditional);
   virtual void CodeCompleteInConditionalExclusion();
   virtual void CodeCompleteMacroName(bool IsDefinition);
+  virtual void CodeCompletePreprocessorExpression();
+  virtual void CodeCompleteMacroArgument(IdentifierInfo *Macro,
+                                         MacroInfo *MacroInfo,
+                                         unsigned ArgumentIndex);
 };
 
 }  // end namespace clang

diff --git a/include/clang/Sema/Action.h b/include/clang/Sema/Action.h
index aebb2b4d2b7f4171a837dbee04d8f57196a8b7bc..3b7fc2cc6239d247c3debe6af6911a56a45cfe54 100644 (file)
--- a/include/clang/Sema/Action.h
+++ b/include/clang/Sema/Action.h
@@ -43,7 +43,8 @@ namespace clang {
   // Lex.
   class Preprocessor;
   class Token;
-
+  class MacroInfo;
+  
 /// Action - As the parser reads the input file and recognizes the productions
 /// of the grammar, it invokes methods on this class to turn the parsed input
 /// into something useful: e.g. a parse tree.
@@ -3207,9 +3208,8 @@ public:
   
   /// \brief Code completion for a preprocessor directive.
   ///
-  /// \brief S The scope in which the preprocessor directive is being parsed.
   /// \brief InConditional Whether we're inside a preprocessor conditional.
-  virtual void CodeCompletePreprocessorDirective(Scope *S, bool InConditional) { 
+  virtual void CodeCompletePreprocessorDirective(bool InConditional) { 
   }
   
   /// \brief Code completion while in an area of the translation unit that was
@@ -3219,13 +3219,31 @@ public:
   /// \brief Code completion in the preprocessor where an already-defined
   /// macro name is expected, e.g., an #ifdef or #undef.
   ///
-  /// \param S The scope in which the macro name occurs.
-  ///
   /// \param IsDefinition Whether this code completion for a macro name occurs
   /// in a definition of the macro (#define) or in another use that already
   /// expects that the macro is defined (e.g., #undef or #ifdef).
-  virtual void CodeCompletePreprocessorMacroName(Scope *S, bool IsDefinition) { 
+  virtual void CodeCompletePreprocessorMacroName(bool IsDefinition) { 
   }
+  
+  /// \brief Callback invoked when performing code completion in a preprocessor
+  /// expression, such as the condition of an #if or #elif directive.
+  virtual void CodeCompletePreprocessorExpression() { }
+  
+  /// \brief Callback invoked when performing code completion inside a 
+  /// function-like macro argument.
+  ///
+  /// \param S The scope in which this macro is being expanded.
+  ///
+  /// \param Macro The name of the macro that is going to be expanded.
+  ///
+  /// \param MacroInfo Information about the macro that is going to be
+  /// expanded.
+  ///
+  /// \param Argument The argument in which the code-completion token occurs.
+  virtual void CodeCompletePreprocessorMacroArgument(Scope *S,
+                                                     IdentifierInfo *Macro,
+                                                     MacroInfo *MacroInfo,
+                                                     unsigned Argument) { }
   //@}
 };
 

diff --git a/include/clang/Sema/CodeCompleteConsumer.h b/include/clang/Sema/CodeCompleteConsumer.h
index f9cf48495307fd5ec6e287125a0e5c699d77009a..8b5a741ebd1c37dd5498e88910fdef39471d9b17 100644 (file)
--- a/include/clang/Sema/CodeCompleteConsumer.h
+++ b/include/clang/Sema/CodeCompleteConsumer.h
@@ -174,7 +174,9 @@ public:
     CCC_MacroName,
     /// \brief Code completion occurred where a macro name is expected
     /// (without any arguments, in the case of a function-like macro).
-    CCC_MacroNameUse
+    CCC_MacroNameUse,
+    /// \brief Code completion occurred within a preprocessor expression.
+    CCC_PreprocessorExpression
   };
 
 private:

diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index c7a83ef662c2255a9e0a1d63f2c825c9ed7fe63f..202da5a41e7c4cb33208fbeffa19d33c8ede7011 100644 (file)
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -4633,9 +4633,14 @@ public:
                                                   ParsedType ReturnType,
                                                   IdentifierInfo **SelIdents,
                                                   unsigned NumSelIdents);
-  virtual void CodeCompletePreprocessorDirective(Scope *S, bool InConditional);
+  virtual void CodeCompletePreprocessorDirective(bool InConditional);
   virtual void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);
-  virtual void CodeCompletePreprocessorMacroName(Scope *S, bool IsDefinition);
+  virtual void CodeCompletePreprocessorMacroName(bool IsDefinition);
+  virtual void CodeCompletePreprocessorExpression();
+  virtual void CodeCompletePreprocessorMacroArgument(Scope *S,
+                                                     IdentifierInfo *Macro,
+                                                     MacroInfo *MacroInfo,
+                                                     unsigned Argument);
   void GatherGlobalCodeCompletions(
                   llvm::SmallVectorImpl<CodeCompleteConsumer::Result> &Results);
   //@}

diff --git a/lib/Frontend/ASTUnit.cpp b/lib/Frontend/ASTUnit.cpp
index 384edb4502b1c7169846e1a9ca117b8bd1698bab..117d3775c0e1e1e2b18d4e0631b30307c5506afe 100644 (file)
--- a/lib/Frontend/ASTUnit.cpp
+++ b/lib/Frontend/ASTUnit.cpp
@@ -278,7 +278,8 @@ void ASTUnit::CacheCodeCompletionResults() {
         | (1 << (CodeCompletionContext::CCC_Statement - 1))
         | (1 << (CodeCompletionContext::CCC_Expression - 1))
         | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
-        | (1 << (CodeCompletionContext::CCC_MacroNameUse - 1));
+        | (1 << (CodeCompletionContext::CCC_MacroNameUse - 1))
+        | (1 << (CodeCompletionContext::CCC_PreprocessorExpression - 1));
       
       CachedResult.Priority = Results[I].Priority;
       CachedResult.Kind = Results[I].CursorKind;
@@ -1550,6 +1551,7 @@ void CalculateHiddenNames(const CodeCompletionContext &Context,
   case CodeCompletionContext::CCC_ObjCProtocolName:
   case CodeCompletionContext::CCC_MacroName:
   case CodeCompletionContext::CCC_MacroNameUse:
+  case CodeCompletionContext::CCC_PreprocessorExpression:
     // If we're just looking for protocol or macro names, nothing can hide them.
     return;
   }

diff --git a/lib/Lex/PPExpressions.cpp b/lib/Lex/PPExpressions.cpp
index 73f3d4ee7a0f7f4418a830ebbf37bc6e0dba0b72..163e869400aa51f6e0a935bd8b46f360e0ed739e 100644 (file)
--- a/lib/Lex/PPExpressions.cpp
+++ b/lib/Lex/PPExpressions.cpp
@@ -149,6 +149,12 @@ static bool EvaluateValue(PPValue &Result, Token &PeekTok, DefinedTracker &DT,
                           bool ValueLive, Preprocessor &PP) {
   DT.State = DefinedTracker::Unknown;
 
+  if (PeekTok.is(tok::code_completion)) {
+    if (PP.getCodeCompletionHandler())
+      PP.getCodeCompletionHandler()->CodeCompletePreprocessorExpression();
+    PP.LexUnexpandedToken(PeekTok);
+  }
+      
   // If this token's spelling is a pp-identifier, check to see if it is
   // 'defined' or if it is a macro.  Note that we check here because many
   // keywords are pp-identifiers, so we can't check the kind.

diff --git a/lib/Lex/PPMacroExpansion.cpp b/lib/Lex/PPMacroExpansion.cpp
index ad05b40e42a8638441cdc43dc17d2dd770f46a19..894dc368e4c8221eb8f3cb53e2e8bd62d76abbd0 100644 (file)
--- a/lib/Lex/PPMacroExpansion.cpp
+++ b/lib/Lex/PPMacroExpansion.cpp
@@ -19,6 +19,7 @@
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/LexDiagnostic.h"
+#include "clang/Lex/CodeCompletionHandler.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
@@ -323,6 +324,13 @@ MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName,
       // an argument value in a macro could expand to ',' or '(' or ')'.
       LexUnexpandedToken(Tok);
 
+      if (Tok.is(tok::code_completion)) {
+        if (CodeComplete)
+          CodeComplete->CodeCompleteMacroArgument(MacroName.getIdentifierInfo(),
+                                                  MI, NumActuals);
+        LexUnexpandedToken(Tok);
+      }
+      
       if (Tok.is(tok::eof) || Tok.is(tok::eom)) { // "#if f(<eof>" & "#if f(\n"
         Diag(MacroName, diag::err_unterm_macro_invoc);
         // Do not lose the EOF/EOM.  Return it to the client.

diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
index 13db742f18fc29555a47c7d4b5ca3d569104de0e..dd244bb895a2109a947af858a34f7377bbd4d05f 100644 (file)
--- a/lib/Parse/Parser.cpp
+++ b/lib/Parse/Parser.cpp
@@ -1133,7 +1133,7 @@ void Parser::FieldCallback::_anchor() {
 // Code-completion pass-through functions
 
 void Parser::CodeCompleteDirective(bool InConditional) {
-  Actions.CodeCompletePreprocessorDirective(getCurScope(), InConditional);
+  Actions.CodeCompletePreprocessorDirective(InConditional);
 }
 
 void Parser::CodeCompleteInConditionalExclusion() {
@@ -1141,5 +1141,16 @@ void Parser::CodeCompleteInConditionalExclusion() {
 }
 
 void Parser::CodeCompleteMacroName(bool IsDefinition) {
-  Actions.CodeCompletePreprocessorMacroName(getCurScope(), IsDefinition);
+  Actions.CodeCompletePreprocessorMacroName(IsDefinition);
+}
+
+void Parser::CodeCompletePreprocessorExpression() { 
+  Actions.CodeCompletePreprocessorExpression();
+}
+
+void Parser::CodeCompleteMacroArgument(IdentifierInfo *Macro,
+                                       MacroInfo *MacroInfo,
+                                       unsigned ArgumentIndex) {
+  Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, 
+                                                ArgumentIndex);
 }

diff --git a/lib/Sema/SemaCodeComplete.cpp b/lib/Sema/SemaCodeComplete.cpp
index 06e65784e85dfda1af6fbd9a07275bdf2d098b4b..e25a47c2a553e10cabcea0ed7ecbd23fbaf6b0ca 100644 (file)
--- a/lib/Sema/SemaCodeComplete.cpp
+++ b/lib/Sema/SemaCodeComplete.cpp
@@ -4608,7 +4608,7 @@ void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
                             Results.data(),Results.size());
 }
 
-void Sema::CodeCompletePreprocessorDirective(Scope *S, bool InConditional) {
+void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
   ResultBuilder Results(*this);
   Results.EnterNewScope();
   
@@ -4785,11 +4785,12 @@ void Sema::CodeCompletePreprocessorDirective(Scope *S, bool InConditional) {
 }
 
 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
-  CodeCompleteOrdinaryName(S, Action::PCC_RecoveryInFunction);
+  CodeCompleteOrdinaryName(S,
+                           S->getFnParent()? Action::PCC_RecoveryInFunction 
+                                           : Action::PCC_Namespace);
 }
 
-void Sema::CodeCompletePreprocessorMacroName(Scope *S, bool IsDefinition) {
-  typedef CodeCompleteConsumer::Result Result;
+void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
   ResultBuilder Results(*this);
   if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
     // Add just the names of macros, not their arguments.    
@@ -4812,6 +4813,40 @@ void Sema::CodeCompletePreprocessorMacroName(Scope *S, bool IsDefinition) {
                             Results.data(), Results.size()); 
 }
 
+void Sema::CodeCompletePreprocessorExpression() {
+  ResultBuilder Results(*this);
+  
+  if (!CodeCompleter || CodeCompleter->includeMacros())
+    AddMacroResults(PP, Results);
+  
+    // defined (<macro>)
+  Results.EnterNewScope();
+  CodeCompletionString *Pattern = new CodeCompletionString;
+  Pattern->AddTypedTextChunk("defined");
+  Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace);
+  Pattern->AddChunk(CodeCompletionString::CK_LeftParen);
+  Pattern->AddPlaceholderChunk("macro");
+  Pattern->AddChunk(CodeCompletionString::CK_RightParen);
+  Results.AddResult(Pattern);
+  Results.ExitScope();
+  
+  HandleCodeCompleteResults(this, CodeCompleter, 
+                            CodeCompletionContext::CCC_PreprocessorExpression,
+                            Results.data(), Results.size()); 
+}
+
+void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
+                                                 IdentifierInfo *Macro,
+                                                 MacroInfo *MacroInfo,
+                                                 unsigned Argument) {
+  // FIXME: In the future, we could provide "overload" results, much like we
+  // do for function calls.
+  
+  CodeCompleteOrdinaryName(S,
+                           S->getFnParent()? Action::PCC_RecoveryInFunction 
+                                           : Action::PCC_Namespace);
+}
+
 void Sema::GatherGlobalCodeCompletions(
                  llvm::SmallVectorImpl<CodeCompleteConsumer::Result> &Results) {
   ResultBuilder Builder(*this);

diff --git a/test/Index/complete-preprocessor.m b/test/Index/complete-preprocessor.m
index 14c4c150b316cb035c515019e81fe6fc9c60d885..d3a07d6f0699a6154efa585a36bf858d1b568ddf 100644 (file)
--- a/test/Index/complete-preprocessor.m
+++ b/test/Index/complete-preprocessor.m
@@ -11,6 +11,8 @@
 #if defined(FOO)
 #endif
 
+FOO(in,t) value;
+
 // RUN: c-index-test -code-completion-at=%s:4:2 %s | FileCheck -check-prefix=CHECK-CC1 %s
 // CHECK-CC1: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro} (30)
 // CHECK-CC1-NEXT: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro}{LeftParen (}{Placeholder args}{RightParen )} (30)
@@ -55,3 +57,18 @@
 // CHECK-CC3: NotImplemented:{TypedText FOO} (30)
 // RUN: c-index-test -code-completion-at=%s:11:12 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: c-index-test -code-completion-at=%s:11:13 %s | FileCheck -check-prefix=CHECK-CC3 %s
+// RUN: c-index-test -code-completion-at=%s:11:5 %s | FileCheck -check-prefix=CHECK-CC4 %s
+// CHECK-CC4: macro definition:{TypedText BAR} (70)
+// CHECK-CC4: macro definition:{TypedText FOO}{LeftParen (}{Placeholder a}{Comma , }{Placeholder b}{RightParen )} (70)
+// RUN: c-index-test -code-completion-at=%s:14:5 %s | FileCheck -check-prefix=CHECK-CC5 %s
+// CHECK-CC5: NotImplemented:{TypedText const} (40)
+// CHECK-CC5: NotImplemented:{TypedText double} (40)
+// CHECK-CC5: NotImplemented:{TypedText enum} (40)
+// CHECK-CC5: NotImplemented:{TypedText extern} (30)
+// CHECK-CC5: NotImplemented:{TypedText float} (40)
+// CHECK-CC5: macro definition:{TypedText FOO}{LeftParen (}{Placeholder a}{Comma , }{Placeholder b}{RightParen )} (70)
+// CHECK-CC5: macro definition:{TypedText i386} (70)
+// CHECK-CC5: TypedefDecl:{TypedText id} (40)
+// CHECK-CC5: NotImplemented:{TypedText inline} (30)
+// CHECK-CC5: NotImplemented:{TypedText int} (40)
+// CHECK-CC5: NotImplemented:{TypedText long} (40)