Remove SourceKit Support for the libSyntax Tree

Author: CodaFi

include/swift/AST/Module.h

@@ -75,13 +75,9 @@ namespace swift {
   class ValueDecl;
   class VarDecl;
   class VisibleDeclConsumer;
-  class SyntaxParsingCache;
   class ASTScope;
   class SourceLookupCache;
 
-  namespace syntax {
-  class SourceFileSyntax;
-}
 namespace ast_scope {
 class ASTSourceFileScope;
 }

include/swift/AST/ParseRequests.h

@@ -21,7 +21,6 @@
 #include "swift/AST/SimpleRequest.h"
 #include "swift/Basic/Fingerprint.h"
 #include "swift/Parse/Token.h"
-#include "swift/Syntax/SyntaxNodes.h"
 
 namespace swift {
 
@@ -90,7 +89,6 @@ struct SourceFileParsingResult {
   ArrayRef<ASTNode> TopLevelItems;
   Optional<ArrayRef<Token>> CollectedTokens;
   Optional<StableHasher> InterfaceHasher;
-  Optional<syntax::SourceFileSyntax> SyntaxRoot;
 };
 
 /// Parse the top-level items of a SourceFile.

include/swift/AST/SourceFile.h

@@ -78,18 +78,15 @@ class SourceFile final : public FileUnit {
     /// and the associated language option.
     DisablePoundIfEvaluation = 1 << 1,
 
-    /// Whether to build a syntax tree.
-    BuildSyntaxTree = 1 << 2,
-
     /// Whether to save the file's parsed tokens.
-    CollectParsedTokens = 1 << 3,
+    CollectParsedTokens = 1 << 2,
 
     /// Whether to compute the interface hash of the file.
-    EnableInterfaceHash = 1 << 4,
+    EnableInterfaceHash = 1 << 3,
 
     /// Whether to suppress warnings when parsing. This is set for secondary
     /// files, as they get parsed multiple times.
-    SuppressWarnings = 1 << 5,
+    SuppressWarnings = 1 << 4,
   };
   using ParsingOptions = OptionSet<ParsingFlags>;
 
@@ -248,10 +245,6 @@ class SourceFile final : public FileUnit {
   /// code for it. Note this method returns \c false in WMO.
   bool isPrimary() const { return IsPrimary; }
 
-  /// A cache of syntax nodes that can be reused when creating the syntax tree
-  /// for this file.
-  swift::SyntaxParsingCache *SyntaxParsingCache = nullptr;
-
   /// The list of local type declarations in the source file.
   llvm::SetVector<TypeDecl *> LocalTypeDecls;
 
@@ -633,14 +626,10 @@ class SourceFile final : public FileUnit {
   /// them to be accessed from \c getAllTokens.
   bool shouldCollectTokens() const;
 
-  bool shouldBuildSyntaxTree() const;
-
   /// Whether the bodies of types and functions within this file can be lazily
   /// parsed.
   bool hasDelayedBodyParsing() const;
 
-  syntax::SourceFileSyntax getSyntaxRoot() const;
-
   OpaqueTypeDecl *lookupOpaqueResultType(StringRef MangledName) override;
 
   /// Do not call when inside an inactive clause (\c
@@ -660,9 +649,6 @@ class SourceFile final : public FileUnit {
   /// If not \c None, the underlying vector contains the parsed tokens of this
   /// source file.
   Optional<ArrayRef<Token>> AllCollectedTokens;
-
-  /// The root of the syntax tree representing the source file.
-  std::unique_ptr<syntax::SourceFileSyntax> SyntaxRoot;
 };
 
 inline SourceFile::ParsingOptions operator|(SourceFile::ParsingFlags lhs,

include/swift/IDE/CompletionLookup.h

@@ -26,6 +26,7 @@
 #include "swift/IDE/CodeCompletionResult.h"
 #include "swift/IDE/CodeCompletionStringPrinter.h"
 #include "swift/IDE/PossibleParamInfo.h"
+#include "swift/Parse/CodeCompletionCallbacks.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "swift/Strings.h"
 
@@ -599,7 +600,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void collectPrecedenceGroups();
 
-  void getPrecedenceGroupCompletions(syntax::SyntaxKind SK);
+  void getPrecedenceGroupCompletions(CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK);
 
   void getPoundAvailablePlatformCompletions();
 

include/swift/Parse/CodeCompletionCallbacks.h

@@ -192,9 +192,15 @@ class CodeCompletionCallbacks {
   /// Complete 'async' and 'throws' at effects specifier position.
   virtual void completeEffectsSpecifier(bool hasAsync, bool hasThrows) {};
 
+  enum class PrecedenceGroupCompletionKind {
+    Relation,
+    Associativity,
+    AttributeList,
+    Assignment,
+  };
   /// Complete within a precedence group decl or after a colon in an
   /// operator decl.
-  virtual void completeInPrecedenceGroup(SyntaxKind SK) {};
+  virtual void completeInPrecedenceGroup(PrecedenceGroupCompletionKind SK) {};
 
   /// Complete the platform names inside #available statements.
   virtual void completePoundAvailablePlatform() {};

lib/IDE/CodeCompletion.cpp

@@ -123,7 +123,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   /// In situations when \c SyntaxKind hints or determines
   /// completions, i.e. a precedence group attribute, this
   /// can be set and used to control the code completion scenario.
-  SyntaxKind SyntxKind;
+  CodeCompletionCallbacks::PrecedenceGroupCompletionKind SyntxKind;
 
   int AttrParamIndex;
   bool IsInSil = false;
@@ -256,7 +256,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   void completeDeclAttrBeginning(bool Sil, bool isIndependent) override;
   void completeDeclAttrParam(DeclAttrKind DK, int Index) override;
   void completeEffectsSpecifier(bool hasAsync, bool hasThrows) override;
-  void completeInPrecedenceGroup(SyntaxKind SK) override;
+  void completeInPrecedenceGroup(CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) override;
   void completeNominalMemberBeginning(
       SmallVectorImpl<StringRef> &Keywords, SourceLoc introducerLoc) override;
   void completeAccessorBeginning(CodeCompletionExpr *E) override;
@@ -466,7 +466,7 @@ void CodeCompletionCallbacksImpl::completeDeclAttrBeginning(
   AttTargetIsIndependent = isIndependent;
 }
 
-void CodeCompletionCallbacksImpl::completeInPrecedenceGroup(SyntaxKind SK) {
+void CodeCompletionCallbacksImpl::completeInPrecedenceGroup(CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) {
   assert(P.Tok.is(tok::code_complete));
 
   SyntxKind = SK;
@@ -805,7 +805,7 @@ static void addDeclKeywords(CodeCompletionResultSink &Sink, DeclContext *DC,
 
 #define DECL_KEYWORD(kw)                                                       \
   AddDeclKeyword(#kw, CodeCompletionKeywordKind::kw_##kw, None);
-#include "swift/Syntax/TokenKinds.def"
+#include "swift/AST/TokenKinds.def"
   // Manually add "actor" because it's a contextual keyword.
   AddDeclKeyword("actor", CodeCompletionKeywordKind::None, None);
 
@@ -842,7 +842,7 @@ static void addStmtKeywords(CodeCompletionResultSink &Sink, DeclContext *DC,
     addKeyword(Sink, Name, Kind, "", flair);
   };
 #define STMT_KEYWORD(kw) AddStmtKeyword(#kw, CodeCompletionKeywordKind::kw_##kw);
-#include "swift/Syntax/TokenKinds.def"
+#include "swift/AST/TokenKinds.def"
 }
 
 static void addCaseStmtKeywords(CodeCompletionResultSink &Sink) {

lib/IDE/CodeCompletionResult.cpp

@@ -455,7 +455,7 @@ void CodeCompletionResult::printPrefix(raw_ostream &OS) const {
   case CodeCompletionKeywordKind::pound_##X:                                   \
     Prefix.append("[#" #X "]");                                                \
     break;
-#include "swift/Syntax/TokenKinds.def"
+#include "swift/AST/TokenKinds.def"
     }
     break;
   case CodeCompletionResultKind::Pattern:

lib/IDE/CompletionLookup.cpp

@@ -15,12 +15,9 @@
 #include "ExprContextAnalysis.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/SourceFile.h"
-#include "swift/Syntax/SyntaxKind.h"
-#include "swift/Syntax/TokenKinds.h"
 
 using namespace swift;
 using namespace swift::ide;
-using swift::syntax::SyntaxKind;
 
 namespace {
 
@@ -3050,31 +3047,30 @@ void CompletionLookup::collectPrecedenceGroups() {
   }
 }
 
-void CompletionLookup::getPrecedenceGroupCompletions(SyntaxKind SK) {
+void CompletionLookup::getPrecedenceGroupCompletions(CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) {
   switch (SK) {
-  case SyntaxKind::PrecedenceGroupAssociativity:
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::Associativity:
     addKeyword(getAssociativitySpelling(Associativity::None));
     addKeyword(getAssociativitySpelling(Associativity::Left));
     addKeyword(getAssociativitySpelling(Associativity::Right));
-    break;
-  case SyntaxKind::PrecedenceGroupAssignment:
+    return;
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::Assignment:
     addKeyword(getTokenText(tok::kw_false), Type(), SemanticContextKind::None,
                CodeCompletionKeywordKind::kw_false);
     addKeyword(getTokenText(tok::kw_true), Type(), SemanticContextKind::None,
                CodeCompletionKeywordKind::kw_true);
-    break;
-  case SyntaxKind::PrecedenceGroupAttributeList:
+    return;
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::AttributeList:
     addKeyword("associativity");
     addKeyword("higherThan");
     addKeyword("lowerThan");
     addKeyword("assignment");
-    break;
-  case SyntaxKind::PrecedenceGroupRelation:
+    return;
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::Relation:
     collectPrecedenceGroups();
-    break;
-  default:
-    llvm_unreachable("not a precedencegroup SyntaxKind");
+    return;
   }
+  llvm_unreachable("not a precedencegroup SyntaxKind");
 }
 
 void CompletionLookup::getPoundAvailablePlatformCompletions() {

lib/IDETool/CompletionInstance.cpp

@@ -567,10 +567,6 @@ void swift::ide::CompletionInstance::performOperation(
   // because they're somewhat heavy operations and aren't needed for completion.
   Invocation.getFrontendOptions().IgnoreSwiftSourceInfo = true;
 
-  // Disable to build syntax tree because code-completion skips some portion of
-  // source text. That breaks an invariant of syntax tree building.
-  Invocation.getLangOptions().BuildSyntaxTree = false;
-
   // We don't need token list.
   Invocation.getLangOptions().CollectParsedToken = false;