CodeCompletion: Complete member types with non-identifier qualifiers

Author: AnthonyLatsis

include/swift/IDE/CodeCompletionResult.h

@@ -200,8 +200,8 @@ enum class CompletionKind : uint8_t {
   KeyPathExprSwift,
   TypeDeclResultBeginning,
   TypeSimpleBeginning,
-  TypeIdentifierWithDot,
-  TypeIdentifierWithoutDot,
+  TypeSimpleWithDot,
+  TypeSimpleWithoutDot,
   CaseStmtKeyword,
   CaseStmtBeginning,
   NominalMemberBeginning,

include/swift/Parse/IDEInspectionCallbacks.h

@@ -162,11 +162,11 @@ class IDEInspectionCallbacks {
   /// by user.
   virtual void completeTypeSimpleBeginning() {};
 
-  /// Complete a given type identifier after we have consumed the dot.
-  virtual void completeTypeIdentifierWithDot(DeclRefTypeRepr *TR){};
+  /// Complete a given \c type-simple after we have consumed the dot.
+  virtual void completeTypeSimpleWithDot(TypeRepr *TR){};
 
-  /// Complete a given type identifier when there is no trailing dot.
-  virtual void completeTypeIdentifierWithoutDot(DeclRefTypeRepr *TR){};
+  /// Complete a given \c type-simple when there is no trailing dot.
+  virtual void completeTypeSimpleWithoutDot(TypeRepr *TR){};
 
   /// Complete the beginning of a case statement at the top of switch stmt.
   virtual void completeCaseStmtKeyword() {};

lib/IDE/CodeCompletion.cpp

@@ -266,8 +266,8 @@ class CodeCompletionCallbacksImpl : public IDEInspectionCallbacks {
 
   void completeTypeDeclResultBeginning() override;
   void completeTypeSimpleBeginning() override;
-  void completeTypeIdentifierWithDot(DeclRefTypeRepr *TR) override;
-  void completeTypeIdentifierWithoutDot(DeclRefTypeRepr *TR) override;
+  void completeTypeSimpleWithDot(TypeRepr *TR) override;
+  void completeTypeSimpleWithoutDot(TypeRepr *TR) override;
 
   void completeCaseStmtKeyword() override;
   void completeCaseStmtBeginning(CodeCompletionExpr *E) override;
@@ -494,21 +494,16 @@ void CodeCompletionCallbacksImpl::completeInPrecedenceGroup(
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completeTypeIdentifierWithDot(
-    DeclRefTypeRepr *TR) {
-  if (!TR) {
-    completeTypeSimpleBeginning();
-    return;
-  }
-  Kind = CompletionKind::TypeIdentifierWithDot;
+void CodeCompletionCallbacksImpl::completeTypeSimpleWithDot(TypeRepr *TR) {
+  assert(TR);
+  Kind = CompletionKind::TypeSimpleWithDot;
   ParsedTypeLoc = TypeLoc(TR);
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completeTypeIdentifierWithoutDot(
-    DeclRefTypeRepr *TR) {
+void CodeCompletionCallbacksImpl::completeTypeSimpleWithoutDot(TypeRepr *TR) {
   assert(TR);
-  Kind = CompletionKind::TypeIdentifierWithoutDot;
+  Kind = CompletionKind::TypeSimpleWithoutDot;
   ParsedTypeLoc = TypeLoc(TR);
   CurDeclContext = P.CurDeclContext;
 }
@@ -953,6 +948,13 @@ addClosureSignatureKeywordsIfApplicable(CodeCompletionResultSink &Sink,
 
 void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
                                               bool MaybeFuncBody) {
+  auto addEffectsSpecifierKeywords = [&] {
+    if (!llvm::is_contained(ParsedKeywords, "async"))
+      addKeyword(Sink, "async", CodeCompletionKeywordKind::None);
+    if (!llvm::is_contained(ParsedKeywords, "throws"))
+      addKeyword(Sink, "throws", CodeCompletionKeywordKind::kw_throws);
+  };
+
   switch (Kind) {
   case CompletionKind::None:
   case CompletionKind::DotExpr:
@@ -974,13 +976,9 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
   case CompletionKind::OptionalBinding:
     break;
 
-  case CompletionKind::EffectsSpecifier: {
-    if (!llvm::is_contained(ParsedKeywords, "async"))
-      addKeyword(Sink, "async", CodeCompletionKeywordKind::None);
-    if (!llvm::is_contained(ParsedKeywords, "throws"))
-      addKeyword(Sink, "throws", CodeCompletionKeywordKind::kw_throws);
+  case CompletionKind::EffectsSpecifier:
+    addEffectsSpecifierKeywords();
     break;
-  }
 
   case CompletionKind::AccessorBeginning: {
     // TODO: Omit already declared or mutally exclusive accessors.
@@ -1037,8 +1035,15 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
 
     break;
   case CompletionKind::CaseStmtBeginning:
-  case CompletionKind::TypeIdentifierWithDot:
-  case CompletionKind::TypeIdentifierWithoutDot:
+  case CompletionKind::TypeSimpleWithDot:
+    break;
+
+  case CompletionKind::TypeSimpleWithoutDot:
+    // Suggest effects specifiers after a tuple type because it may be
+    // intended as a parameter list.
+    if (isa_and_nonnull<TupleTypeRepr>(ParsedTypeLoc.getTypeRepr())) {
+      addEffectsSpecifierKeywords();
+    }
     break;
 
   case CompletionKind::TypeDeclResultBeginning: {
@@ -1241,8 +1246,8 @@ void swift::ide::postProcessCompletionResults(
     if (result->getKind() == CodeCompletionResultKind::Declaration &&
         result->getAssociatedDeclKind() == CodeCompletionDeclKind::Protocol &&
         Kind != CompletionKind::TypeSimpleBeginning &&
-        Kind != CompletionKind::TypeIdentifierWithoutDot &&
-        Kind != CompletionKind::TypeIdentifierWithDot &&
+        Kind != CompletionKind::TypeSimpleWithoutDot &&
+        Kind != CompletionKind::TypeSimpleWithDot &&
         Kind != CompletionKind::TypeDeclResultBeginning &&
         Kind != CompletionKind::GenericRequirement) {
       flair |= CodeCompletionFlairBit::RareTypeAtCurrentPosition;
@@ -1597,7 +1602,7 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
     return;
 
   undoSingleExpressionReturn(CurDeclContext);
-  if (Kind != CompletionKind::TypeIdentifierWithDot) {
+  if (Kind != CompletionKind::TypeSimpleWithDot) {
     // Type member completion does not need a type-checked AST.
     typeCheckContextAt(
         TypeCheckASTNodeAtLocContext::declContext(CurDeclContext),
@@ -1753,13 +1758,13 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
     break;
   }
 
-  case CompletionKind::TypeIdentifierWithDot: {
+  case CompletionKind::TypeSimpleWithDot: {
     Lookup.setHaveDot(SourceLoc());
     Lookup.getTypeCompletions(ParsedTypeLoc.getType());
     break;
   }
 
-  case CompletionKind::TypeIdentifierWithoutDot: {
+  case CompletionKind::TypeSimpleWithoutDot: {
     Lookup.getTypeCompletions(ParsedTypeLoc.getType());
     break;
   }

lib/Parse/ParseType.cpp

@@ -208,7 +208,7 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
       if (auto *ITR = cast_or_null<IdentTypeRepr>(ty.getPtrOrNull())) {
         if (Tok.is(tok::code_complete) && !Tok.isAtStartOfLine()) {
           if (IDECallbacks)
-            IDECallbacks->completeTypeIdentifierWithoutDot(ITR);
+            IDECallbacks->completeTypeSimpleWithoutDot(ITR);
 
           ty.setHasCodeCompletionAndIsError();
           consumeToken(tok::code_complete);
@@ -219,7 +219,6 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
     break;
   case tok::kw_Any:
     ty = parseAnyType();
-    // FIXME: Offer completions in 'Any<#HERE#>' and 'Any.<#HERE#>'.
     break;
   case tok::l_paren:
     ty = parseTypeTupleBody();
@@ -262,6 +261,18 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
   // '.X', '.Type', '.Protocol', '?', '!', '[]'.
   while (ty.isNonNull()) {
     if (Tok.isAny(tok::period, tok::period_prefix)) {
+      if (peekToken().is(tok::code_complete)) {
+        consumeToken();
+
+        if (IDECallbacks) {
+          IDECallbacks->completeTypeSimpleWithDot(ty.get());
+        }
+
+        ty.setHasCodeCompletionAndIsError();
+        consumeToken(tok::code_complete);
+        break;
+      }
+
       ty = parseTypeDotted(ty);
       continue;
     }
@@ -281,6 +292,15 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
         continue;
       }
     }
+
+    if (Tok.is(tok::code_complete) && !Tok.isAtStartOfLine()) {
+      if (IDECallbacks) {
+        IDECallbacks->completeTypeSimpleWithoutDot(ty.get());
+      }
+
+      ty.setHasCodeCompletionAndIsError();
+      consumeToken(tok::code_complete);
+    }
     break;
   }
 
@@ -807,10 +827,10 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
       // We have a dot.
       consumeToken();
       if (IDECallbacks)
-        IDECallbacks->completeTypeIdentifierWithDot(DeclRefTR);
+        IDECallbacks->completeTypeSimpleWithDot(DeclRefTR);
     } else {
       if (IDECallbacks)
-        IDECallbacks->completeTypeIdentifierWithoutDot(DeclRefTR);
+        IDECallbacks->completeTypeSimpleWithoutDot(DeclRefTR);
     }
     // Eat the code completion token because we handled it.
     consumeToken(tok::code_complete);
@@ -853,9 +873,9 @@ ParserResult<TypeRepr> Parser::parseTypeDotted(ParserResult<TypeRepr> Base) {
 
   SmallVector<IdentTypeRepr *, 4> MemberComponents;
 
-  while (true) {
-    if (Tok.isNot(tok::period, tok::period_prefix) ||
-        peekToken().is(tok::code_complete)) {
+  while (Tok.isAny(tok::period, tok::period_prefix)) {
+    if (peekToken().is(tok::code_complete)) {
+      // Code completion for "type-simple '.'" is handled in 'parseTypeSimple'.
       break;
     }
 
@@ -888,32 +908,8 @@ ParserResult<TypeRepr> Parser::parseTypeDotted(ParserResult<TypeRepr> Base) {
     MemberComponents.push_back(cast<IdentTypeRepr>(IdentResult.get()));
   }
 
-  TypeRepr *TR = MemberTypeRepr::create(Context, Base.get(), MemberComponents);
-
-  // FIXME: Offer completions in 'X.Type<#HERE#>' and 'X.Type.<#HERE#>'.
-  if (Tok.is(tok::code_complete)) {
-    if (!Tok.isAtStartOfLine()) {
-      Base.setHasCodeCompletionAndIsError();
-
-      if (IDECallbacks) {
-        if (auto *DeclRefTR = dyn_cast<DeclRefTypeRepr>(TR))
-          IDECallbacks->completeTypeIdentifierWithoutDot(DeclRefTR);
-      }
-
-      consumeToken(tok::code_complete);
-    }
-  } else if (Tok.isAny(tok::period, tok::period_prefix)) {
-    Base.setHasCodeCompletionAndIsError();
-    consumeToken();
-
-    if (IDECallbacks) {
-      if (auto *DeclRefTR = dyn_cast<DeclRefTypeRepr>(TR))
-        IDECallbacks->completeTypeIdentifierWithDot(DeclRefTR);
-    }
-    consumeToken(tok::code_complete);
-  }
-
-  return makeParserResult(Base, TR);
+  return makeParserResult(
+      Base, MemberTypeRepr::create(Context, Base.get(), MemberComponents));
 }
 
 /// parseTypeSimpleOrComposition