[SyntaxParse] Introduce CodeCompletionTypeSyntax

To represent a type with code completion.

  type? '.'? <code-completion-token>

This is "parser only" node which is not exposed to SwiftSyntax.
Using this, defer to set the parsed type to code-completion callbacks.

Author: rintaro

cmake/modules/SwiftHandleGybSources.cmake

@@ -118,6 +118,7 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/AttributeNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/AvailabilityNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/CommonNodes.py"
+      "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/CompletionOnlyNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/DeclNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/ExprNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/GenericNodes.py"

include/swift/Parse/ASTGen.h

@@ -97,6 +97,8 @@ class ASTGen {
                      const SourceLoc Loc);
   TypeRepr *generate(const syntax::ImplicitlyUnwrappedOptionalTypeSyntax &Type,
                      const SourceLoc Loc);
+  TypeRepr *generate(const syntax::CodeCompletionTypeSyntax &Type,
+                     const SourceLoc Loc);
   TypeRepr *generate(const syntax::UnknownTypeSyntax &Type,
                      const SourceLoc Loc);
 

include/swift/Parse/CodeCompletionCallbacks.h

@@ -40,6 +40,8 @@ class CodeCompletionCallbacks {
   /// completion. This declaration contained the code completion token.
   Decl *ParsedDecl = nullptr;
 
+  TypeLoc ParsedTypeLoc;
+
   /// True if code completion is done inside a raw value expression of an enum
   /// case.
   bool InEnumElementRawValue = false;
@@ -76,6 +78,10 @@ class CodeCompletionCallbacks {
     ParsedDecl = D;
   }
 
+  void setParsedTypeLoc(TypeLoc TyLoc) {
+    ParsedTypeLoc = TyLoc;
+  }
+
   void setLeadingSequenceExprs(ArrayRef<Expr *> exprs) {
     leadingSequenceExprs.assign(exprs.begin(), exprs.end());
   }
@@ -159,10 +165,10 @@ class CodeCompletionCallbacks {
   virtual void completeTypeSimpleBeginning() {};
 
   /// Complete a given type-identifier after we have consumed the dot.
-  virtual void completeTypeIdentifierWithDot(IdentTypeRepr *ITR) {};
+  virtual void completeTypeIdentifierWithDot() {};
 
   /// Complete a given type-identifier when there is no trailing dot.
-  virtual void completeTypeIdentifierWithoutDot(IdentTypeRepr *ITR) {};
+  virtual void completeTypeIdentifierWithoutDot() {};
 
   /// Complete the beginning of a case statement at the top of switch stmt.
   virtual void completeCaseStmtKeyword() {};

include/swift/Parse/ParsedSyntaxBuilders.h.gyb

@@ -30,7 +30,7 @@ namespace swift {
 class ParsedRawSyntaxRecorder;
 class SyntaxParsingContext;
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if node.is_buildable():
 %     child_count = len(node.children)
 class Parsed${node.name}Builder {

include/swift/Parse/ParsedSyntaxNodes.h.gyb

@@ -28,20 +28,20 @@ namespace swift {
 % # Emit the non-collection classes first, then emit the collection classes
 % # that reference these classes.
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if not node.is_syntax_collection():
 class Parsed${node.name};
 %   end
 % end
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if node.is_syntax_collection():
 using Parsed${node.name} =
   ParsedSyntaxCollection<syntax::SyntaxKind::${node.syntax_kind}>;
 %   end
 % end
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if not node.is_syntax_collection():
 %     qualifier = "" if node.is_base() else "final"
 %     for line in dedented_lines(node.description):

include/swift/Parse/ParsedSyntaxRecorder.h.gyb

@@ -31,7 +31,7 @@ class SyntaxParsingContext;
 
 struct ParsedSyntaxRecorder {
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if node.children:
 %     child_params = []
 %     for child in node.children:

include/swift/Syntax/SyntaxBuilders.h.gyb

@@ -29,7 +29,7 @@ namespace syntax {
 
 class SyntaxArena;
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if node.is_buildable():
 %     child_count = len(node.children)
 class ${node.name}Builder {

include/swift/Syntax/SyntaxFactory.h.gyb

@@ -71,7 +71,7 @@ struct SyntaxFactory {
   static Syntax
   makeBlankCollectionSyntax(SyntaxKind Kind);
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if node.children:
 %     child_params = []
 %     for child in node.children:

include/swift/Syntax/SyntaxKind.h.gyb

@@ -2,7 +2,7 @@
   from gyb_syntax_support import *
   from gyb_syntax_support.kinds import SYNTAX_BASE_KINDS
   grouped_nodes = { kind: [] for kind in SYNTAX_BASE_KINDS }
-  for node in SYNTAX_NODES + SILONLY_NODES:
+  for node in SYNTAX_NODES + PARSEONLY_NODES:
     grouped_nodes[node.base_kind].append(node)
   # -*- mode: C++ -*-
   # Ignore the following admonition; it applies to the resulting .h file only
@@ -93,7 +93,7 @@ struct WrapperTypeTraits<syntax::SyntaxKind> {
     case syntax::SyntaxKind::${node.syntax_kind}: 
       return ${SYNTAX_NODE_SERIALIZATION_CODES[node.syntax_kind]};
 % end
-% for node in SILONLY_NODES:
+% for node in PARSEONLY_NODES:
     case syntax::SyntaxKind::${node.syntax_kind}:
 % end
       llvm_unreachable("unserializable syntax kind");
@@ -124,7 +124,7 @@ struct ScalarReferenceTraits<syntax::SyntaxKind> {
       case syntax::SyntaxKind::${node.syntax_kind}:
         return "\"${node.syntax_kind}\"";
 % end
-% for node in SILONLY_NODES:
+% for node in PARSEONLY_NODES:
       case syntax::SyntaxKind::${node.syntax_kind}:
 % end
         llvm_unreachable("unserializable syntax kind");

include/swift/Syntax/SyntaxNodes.h.gyb

@@ -32,21 +32,21 @@ namespace syntax {
 % # Emit the non-collection classes first, then emit the collection classes
 % # that reference these classes.
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if not node.is_syntax_collection():
 class ${node.name};
 %   end
 % end
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if node.is_syntax_collection():
 using ${node.name} =
   SyntaxCollection<SyntaxKind::${node.syntax_kind},
                    ${node.collection_element_type}>;
 %   end
 % end
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if not node.is_syntax_collection():
 %     qualifier = "" if node.is_base() else "final"
 %     for line in dedented_lines(node.description):

include/swift/Syntax/SyntaxVisitor.h.gyb

@@ -32,7 +32,7 @@ namespace syntax {
 struct SyntaxVisitor {
   virtual ~SyntaxVisitor() {}
 
-% for node in SYNTAX_NODES + SILONLY_NODES:
+% for node in SYNTAX_NODES + PARSEONLY_NODES:
 %   if is_visitable(node):
   virtual void visit(${node.name} node);
 %   end

lib/IDE/CodeCompletion.cpp

@@ -1217,7 +1217,6 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   CompletionKind Kind = CompletionKind::None;
   Expr *ParsedExpr = nullptr;
   SourceLoc DotLoc;
-  TypeLoc ParsedTypeLoc;
   DeclContext *CurDeclContext = nullptr;
   DeclAttrKind AttrKind;
 
@@ -1351,8 +1350,8 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
 
   void completeTypeDeclResultBeginning() override;
   void completeTypeSimpleBeginning() override;
-  void completeTypeIdentifierWithDot(IdentTypeRepr *ITR) override;
-  void completeTypeIdentifierWithoutDot(IdentTypeRepr *ITR) override;
+  void completeTypeIdentifierWithDot() override;
+  void completeTypeIdentifierWithoutDot() override;
 
   void completeCaseStmtKeyword() override;
   void completeCaseStmtBeginning(CodeCompletionExpr *E) override;
@@ -4609,22 +4608,13 @@ void CodeCompletionCallbacksImpl::completeInPrecedenceGroup(SyntaxKind SK) {
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completeTypeIdentifierWithDot(
-    IdentTypeRepr *ITR) {
-  if (!ITR) {
-    completeTypeSimpleBeginning();
-    return;
-  }
+void CodeCompletionCallbacksImpl::completeTypeIdentifierWithDot() {
   Kind = CompletionKind::TypeIdentifierWithDot;
-  ParsedTypeLoc = TypeLoc(ITR);
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completeTypeIdentifierWithoutDot(
-    IdentTypeRepr *ITR) {
-  assert(ITR);
+void CodeCompletionCallbacksImpl::completeTypeIdentifierWithoutDot() {
   Kind = CompletionKind::TypeIdentifierWithoutDot;
-  ParsedTypeLoc = TypeLoc(ITR);
   CurDeclContext = P.CurDeclContext;
 }
 

lib/Parse/ASTGen.cpp

@@ -13,6 +13,7 @@
 #include "swift/Parse/ASTGen.h"
 
 #include "swift/Basic/SourceManager.h"
+#include "swift/Parse/CodeCompletionCallbacks.h"
 #include "swift/Parse/Parser.h"
 
 using namespace swift;
@@ -123,6 +124,8 @@ TypeRepr *ASTGen::generate(const TypeSyntax &Type, const SourceLoc Loc) {
     TypeAST = generate(*Unwrapped, Loc);
   else if (auto Attributed = Type.getAs<AttributedTypeSyntax>())
     TypeAST = generate(*Attributed, Loc);
+  else if (auto CompletionTy = Type.getAs<CodeCompletionTypeSyntax>())
+    TypeAST = generate(*CompletionTy, Loc);
   else if (auto Unknown = Type.getAs<UnknownTypeSyntax>())
     TypeAST = generate(*Unknown, Loc);
 
@@ -445,34 +448,44 @@ TypeRepr *ASTGen::generate(const ImplicitlyUnwrappedOptionalTypeSyntax &Type,
       ImplicitlyUnwrappedOptionalTypeRepr(WrappedType, ExclamationLoc);
 }
 
+TypeRepr *ASTGen::generate(const CodeCompletionTypeSyntax &Type,
+                           const SourceLoc Loc) {
+  auto base = Type.getBase();
+  if (!base)
+    return nullptr;
+
+  TypeRepr *parsedTyR = generate(*base, Loc);
+  if (parsedTyR) {
+    if (P.CodeCompletion)
+      P.CodeCompletion->setParsedTypeLoc(parsedTyR);
+  }
+  return parsedTyR;
+}
+
 TypeRepr *ASTGen::generate(const UnknownTypeSyntax &Type, const SourceLoc Loc) {
   auto ChildrenCount = Type.getNumChildren();
 
   // Recover from old-style protocol composition:
   //   `protocol` `<` protocols `>`
   if (ChildrenCount >= 2) {
-    auto Protocol = Type.getChild(0)->getAs<TokenSyntax>();
+    auto keyword = Type.getChild(0)->getAs<TokenSyntax>();
 
-    if (Protocol && Protocol->getText() == "protocol") {
+    if (keyword && keyword->getText() == "protocol") {
+      auto keywordLoc = advanceLocBegin(Loc, *keyword);
       auto LAngle = Type.getChild(1);
-
-      SmallVector<TypeSyntax, 4> Protocols;
-      for (unsigned i = 2; i < Type.getNumChildren(); i++)
-        if (auto PType = Type.getChild(i)->getAs<TypeSyntax>())
-          Protocols.push_back(*PType);
-
       auto RAngle = Type.getChild(ChildrenCount - 1);
 
-      auto ProtocolLoc = advanceLocBegin(Loc, *Protocol);
       auto LAngleLoc = advanceLocBegin(Loc, *LAngle);
       auto RAngleLoc = advanceLocBegin(Loc, *RAngle);
 
-      SmallVector<TypeRepr *, 4> ProtocolTypes;
-      for (auto &&P : llvm::reverse(Protocols))
-        ProtocolTypes.push_back(generate(P, Loc));
-      std::reverse(std::begin(ProtocolTypes), std::end(ProtocolTypes));
+      SmallVector<TypeRepr *, 4> protocols;
+      for (unsigned i = 2; i < Type.getNumChildren(); i++) {
+        if (auto elem = Type.getChild(i)->getAs<TypeSyntax>())
+          if (auto proto = generate(*elem, Loc))
+            protocols.push_back(proto);
+      }
 
-      return CompositionTypeRepr::create(Context, ProtocolTypes, ProtocolLoc,
+      return CompositionTypeRepr::create(Context, protocols, keywordLoc,
                                          {LAngleLoc, RAngleLoc});
     }
   }