[CodeCompletion] Modifier related improvements in CompletionOverrideLookup

lib/IDE/CodeCompletion.cpp

@@ -4080,6 +4080,11 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
 
   bool hasFuncIntroducer = false;
   bool hasVarIntroducer = false;
+  bool hasTypealiasIntroducer = false;
+  bool hasInitializerModifier = false;
+  bool hasAccessModifier = false;
+  bool hasOverride = false;
+  bool hasOverridabilityModifier = false;
 
 public:
   CompletionOverrideLookup(CodeCompletionResultSink &Sink, ASTContext &Ctx,
@@ -4088,17 +4093,41 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
       : Sink(Sink), TypeResolver(createLazyResolver(Ctx)),
         CurrDeclContext(CurrDeclContext), ParsedKeywords(ParsedKeywords) {
     hasFuncIntroducer = isKeywordSpecified("func");
-    hasVarIntroducer = isKeywordSpecified("var") || isKeywordSpecified("let");
+    hasVarIntroducer = isKeywordSpecified("var") ||
+                       isKeywordSpecified("let");
+    hasTypealiasIntroducer = isKeywordSpecified("typealias");
+    hasInitializerModifier = isKeywordSpecified("required") ||
+                             isKeywordSpecified("convenience");
+    hasAccessModifier = isKeywordSpecified("private") ||
+                        isKeywordSpecified("fileprivate") ||
+                        isKeywordSpecified("internal") ||
+                        isKeywordSpecified("public") ||
+                        isKeywordSpecified("open");
+    hasOverride = isKeywordSpecified("override");
+    hasOverridabilityModifier = isKeywordSpecified("final") ||
+                                isKeywordSpecified("open");
   }
 
   bool isKeywordSpecified(StringRef Word) {
     return std::find(ParsedKeywords.begin(), ParsedKeywords.end(), Word)
       != ParsedKeywords.end();
   }
 
+  void addAccessControl(const ValueDecl *VD,
+                        CodeCompletionResultBuilder &Builder) {
+    assert(CurrDeclContext->getAsGenericTypeOrGenericTypeExtensionContext());
+    auto AccessibilityOfContext =
+      CurrDeclContext->getAsGenericTypeOrGenericTypeExtensionContext()
+        ->getFormalAccess();
+    auto Access = std::min(VD->getFormalAccess(), AccessibilityOfContext);
+    // Only emit 'public', not needed otherwise.
+    if (Access >= Accessibility::Public)
+      Builder.addAccessControlKeyword(Access);
+  }
+
   void addValueOverride(const ValueDecl *VD, DeclVisibilityKind Reason,
                         CodeCompletionResultBuilder &Builder,
-                        StringRef DeclIntroducer = "") {
+                        bool hasDeclIntroducer) {
 
     class DeclNameOffsetLocatorPrinter : public StreamPrinter {
     public:
@@ -4129,37 +4158,18 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
       NameOffset = Printer.NameOffset.getValue();
     }
 
-    assert(CurrDeclContext->getAsGenericTypeOrGenericTypeExtensionContext());
-    Accessibility AccessibilityOfContext =
-        CurrDeclContext->getAsGenericTypeOrGenericTypeExtensionContext()
-            ->getFormalAccess();
-
-    bool missingDeclIntroducer = !hasVarIntroducer && !hasFuncIntroducer;
-    bool missingAccess = !isKeywordSpecified("private") &&
-                         !isKeywordSpecified("fileprivate") &&
-                         !isKeywordSpecified("internal") &&
-                         !isKeywordSpecified("public");
-    bool missingOverride = Reason == DeclVisibilityKind::MemberOfSuper &&
-                           !isKeywordSpecified("override");
-
-    if (missingDeclIntroducer && missingAccess) {
-      auto Access = std::min(VD->getFormalAccess(), AccessibilityOfContext);
-      // Only emit 'public', not needed otherwise.
-      if (Access >= Accessibility::Public)
-        Builder.addAccessControlKeyword(Access);
-    }
+    if (!hasDeclIntroducer && !hasAccessModifier)
+      addAccessControl(VD, Builder);
 
     // FIXME: if we're missing 'override', but have the decl introducer we
     // should delete it and re-add both in the correct order.
-    if (missingDeclIntroducer && missingOverride)
+    bool missingOverride = Reason == DeclVisibilityKind::MemberOfSuper &&
+                           !hasOverride;
+    if (!hasDeclIntroducer && missingOverride)
       Builder.addOverrideKeyword();
 
-    if (missingDeclIntroducer) {
-      if (DeclIntroducer.empty())
-        Builder.addDeclIntroducer(DeclStr.str().substr(0, NameOffset));
-      else
-        Builder.addDeclIntroducer(DeclIntroducer);
-    }
+    if (!hasDeclIntroducer)
+      Builder.addDeclIntroducer(DeclStr.str().substr(0, NameOffset));
 
     Builder.addTextChunk(DeclStr.str().substr(NameOffset));
   }
@@ -4169,7 +4179,7 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
         Sink, CodeCompletionResult::ResultKind::Declaration,
         SemanticContextKind::Super, {});
     Builder.setAssociatedDecl(FD);
-    addValueOverride(FD, Reason, Builder);
+    addValueOverride(FD, Reason, Builder, hasFuncIntroducer);
     Builder.addBraceStmtWithCursor();
   }
 
@@ -4178,27 +4188,54 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
         Sink, CodeCompletionResult::ResultKind::Declaration,
         SemanticContextKind::Super, {});
     Builder.setAssociatedDecl(VD);
-    addValueOverride(VD, Reason, Builder);
+    addValueOverride(VD, Reason, Builder, hasVarIntroducer);
   }
 
   void addTypeAlias(const AssociatedTypeDecl *ATD, DeclVisibilityKind Reason) {
     CodeCompletionResultBuilder Builder(Sink,
       CodeCompletionResult::ResultKind::Declaration,
       SemanticContextKind::Super, {});
     Builder.setAssociatedDecl(ATD);
-    addValueOverride(ATD, Reason, Builder, "typealias ");
+    if (!hasTypealiasIntroducer && !hasAccessModifier)
+      addAccessControl(ATD, Builder);
+    if (!hasTypealiasIntroducer)
+      Builder.addDeclIntroducer("typealias ");
+    Builder.addTextChunk(ATD->getName().str());
     Builder.addTextChunk(" = ");
     Builder.addSimpleNamedParameter("Type");
   }
 
-  void addConstructor(const ConstructorDecl *CD) {
+  void addConstructor(const ConstructorDecl *CD, DeclVisibilityKind Reason) {
     CodeCompletionResultBuilder Builder(
         Sink,
         CodeCompletionResult::ResultKind::Declaration,
         SemanticContextKind::Super, {});
     Builder.setAssociatedDecl(CD);
 
+    if (!hasAccessModifier)
+      addAccessControl(CD, Builder);
+
+    if (!hasOverride && Reason == DeclVisibilityKind::MemberOfSuper &&
+        CD->isDesignatedInit() && !CD->isRequired())
+      Builder.addOverrideKeyword();
+
+    // Emit 'required' if we're in class context, 'required' is not specified,
+    // and 1) this is a protocol conformance and the class is not final, or 2)
+    // this is subclass and the initializer is marked as required.
+    bool needRequired = false;
+    auto C = CurrDeclContext->getAsClassOrClassExtensionContext();
+    if (C && !isKeywordSpecified("required")) {
+      if (Reason ==
+            DeclVisibilityKind::MemberOfProtocolImplementedByCurrentNominal &&
+          !C->isFinal())
+        needRequired = true;
+      else if (Reason == DeclVisibilityKind::MemberOfSuper && CD->isRequired())
+        needRequired = true;
+    }
+
     llvm::SmallString<256> DeclStr;
+    if (needRequired)
+      DeclStr += "required ";
     {
       llvm::raw_svector_ostream OS(DeclStr);
       PrintOptions Options;
@@ -4232,7 +4269,9 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     if (!D->hasType())
       TypeResolver->resolveDeclSignature(D);
 
-    bool hasIntroducer = hasFuncIntroducer || hasVarIntroducer;
+    bool hasIntroducer = hasFuncIntroducer ||
+                         hasVarIntroducer ||
+                         hasTypealiasIntroducer;
 
     if (auto *FD = dyn_cast<FuncDecl>(D)) {
       // We cannot override operators as members.
@@ -4243,30 +4282,31 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
       if (FD->isAccessor())
         return;
 
-      if (!hasIntroducer || hasFuncIntroducer)
+      if (hasFuncIntroducer || (!hasIntroducer && !hasInitializerModifier))
         addMethodOverride(FD, Reason);
       return;
     }
 
     if (auto *VD = dyn_cast<VarDecl>(D)) {
-      if (!hasIntroducer || hasVarIntroducer) {
+      if (hasVarIntroducer || (!hasIntroducer && !hasInitializerModifier))
         addVarOverride(VD, Reason);
-      }
+      return;
     }
 
     if (auto *CD = dyn_cast<ConstructorDecl>(D)) {
       if (!isa<ProtocolDecl>(CD->getDeclContext()))
         return;
-      if (hasIntroducer || isKeywordSpecified("override"))
+      if (hasIntroducer || hasOverride || hasOverridabilityModifier)
         return;
       if (CD->isRequired() || CD->isDesignatedInit())
-        addConstructor(CD);
+        addConstructor(CD, Reason);
       return;
     }
   }
 
   void addDesignatedInitializers(Type CurrTy) {
-    if (hasFuncIntroducer || hasVarIntroducer || isKeywordSpecified("override"))
+    if (hasFuncIntroducer || hasVarIntroducer || hasTypealiasIntroducer ||
+        hasOverridabilityModifier)
       return;
 
     assert(CurrTy);
@@ -4283,12 +4323,14 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
       if (Constructor->hasStubImplementation())
         continue;
       if (Constructor->isDesignatedInit())
-        addConstructor(Constructor);
+        addConstructor(Constructor, DeclVisibilityKind::MemberOfSuper);
     }
   }
 
   void addAssociatedTypes(Type CurrTy) {
-    if (hasFuncIntroducer || hasVarIntroducer || isKeywordSpecified("override"))
+    if (!hasTypealiasIntroducer &&
+        (hasFuncIntroducer || hasVarIntroducer || hasInitializerModifier ||
+         hasOverride || hasOverridabilityModifier))
       return;
 
     NominalTypeDecl *NTD = CurrTy->getAnyNominal();

lib/Parse/ParseDecl.cpp

@@ -2019,6 +2019,7 @@ ParserStatus Parser::parseDecl(ParseDeclOptions Flags,
     case tok::kw_typealias:
       DeclResult = parseDeclTypeAlias(Flags, Attributes);
       Status = DeclResult;
+      MayNeedOverrideCompletion = true;
       break;
     case tok::kw_associatedtype:
       DeclResult = parseDeclAssociatedType(Flags, Attributes);
@@ -2098,6 +2099,7 @@ ParserStatus Parser::parseDecl(ParseDeclOptions Flags,
         case tok::kw_func:
         case tok::kw_subscript:
         case tok::kw_var:
+        case tok::kw_typealias:
           Keywords.push_back(OrigTok.getText());
           break;
         default: