[DONOTSUBMIT] work on prototyping bracket fix its

clang-tools-extra/clangd/CodeComplete.cpp

CompletionItem CodeCompletion::render(const CodeCompleteOptions &Opts) const {
   // edit.
   // Note that we store additional text edits from back to front in a line. That
   // is mainly to help LSP clients again, so that changes do not effect each
   // other.
   for (const auto &FixIt : FixIts) {
     if (FixIt.range.end == LSP.textEdit->range.start) {
       LSP.textEdit->newText = FixIt.newText + LSP.textEdit->newText;
       LSP.textEdit->range.start = FixIt.range.start;
+    } else if (FixIt.range.start == LSP.textEdit->range.end) {
+      LSP.textEdit->newText = LSP.textEdit->newText + FixIt.newText;
+      LSP.textEdit->range.end = FixIt.range.end;
     } else {
       LSP.additionalTextEdits.push_back(FixIt);
     }
   }
   if (Opts.EnableSnippets)
     LSP.textEdit->newText += SnippetSuffix;
 
   // FIXME(kadircet): Do not even fill insertText after making sure textEdit is

clang/include/clang/Parse/Parser.h

private:
   ExprResult ParseObjCArrayLiteral(SourceLocation AtLoc);
   ExprResult ParseObjCDictionaryLiteral(SourceLocation AtLoc);
   ExprResult ParseObjCBoxedExpr(SourceLocation AtLoc);
   ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc);
   ExprResult ParseObjCSelectorExpression(SourceLocation AtLoc);
   ExprResult ParseObjCProtocolExpression(SourceLocation AtLoc);
   bool isSimpleObjCMessageExpression();
   ExprResult ParseObjCMessageExpression();
   ExprResult ParseObjCMessageExpressionBody(SourceLocation LBracloc,
                                             SourceLocation SuperLoc,
                                             ParsedType ReceiverType,
-                                            Expr *ReceiverExpr);
+                                            Expr *ReceiverExpr,
+                                            SourceLocation InferredLBracLoc = SourceLocation());
   ExprResult ParseAssignmentExprWithObjCMessageExprStart(
       SourceLocation LBracloc, SourceLocation SuperLoc,
       ParsedType ReceiverType, Expr *ReceiverExpr);
   bool ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr);
 
   //===--------------------------------------------------------------------===//
   // C99 6.8: Statements and Blocks.
 

clang/include/clang/Sema/Sema.h

void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
                                    bool IsParameter);
   void CodeCompleteObjCMessageReceiver(Scope *S);
   void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
                                     ArrayRef<IdentifierInfo *> SelIdents,
                                     bool AtArgumentExpression);
   void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
                                     ArrayRef<IdentifierInfo *> SelIdents,
                                     bool AtArgumentExpression,
-                                    bool IsSuper = false);
+                                    bool IsSuper = false,
+                                    SourceRange InferredBrac = SourceRange());
   void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
                                        ArrayRef<IdentifierInfo *> SelIdents,
                                        bool AtArgumentExpression,
                                        ObjCInterfaceDecl *Super = nullptr);
   void CodeCompleteObjCForCollection(Scope *S,
                                      DeclGroupPtrTy IterationVar);
   void CodeCompleteObjCSelector(Scope *S,
                                 ArrayRef<IdentifierInfo *> SelIdents);

clang/lib/Parse/ParseExpr.cpp

#undef RTT_JOIN
     // that identifier, this is probably a message send with a missing open
     // bracket. Treat it as such.
     if (getLangOpts().ObjC && &II == Ident_super && !InMessageExpression &&
         getCurScope()->isInObjcMethodScope() &&
         ((Tok.is(tok::identifier) &&
          (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) ||
          Tok.is(tok::code_completion))) {
       Res = ParseObjCMessageExpressionBody(SourceLocation(), ILoc, nullptr,
-                                           nullptr);
+                                           nullptr, ILoc);
       break;
     }
 
     // If we have an Objective-C class name followed by an identifier
     // and either ':' or ']', this is an Objective-C class message
     // send that's missing the opening '['. Recovery
     // appropriately. Also take this path if we're performing code
     // completion after an Objective-C class name.
if (getLangOpts().ObjC &&
                                Actions.getASTContext().getPrintingPolicy());
 
             Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
             TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
                                                   DeclaratorInfo);
             if (Ty.isInvalid())
               break;
 
             Res = ParseObjCMessageExpressionBody(SourceLocation(),
                                                  SourceLocation(),
-                                                 Ty.get(), nullptr);
+                                                 Ty.get(), nullptr, ILoc);
             break;
           }
     }
 
     // Make sure to pass down the right value for isAddressOfOperand.
     if (isAddressOfOperand && isPostfixExpressionSuffixStart())
       isAddressOfOperand = false;
 
if (isStartOfObjCClassMessageMissingOpenBracket()) {
                          Actions.getASTContext().getPrintingPolicy());
 
       Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
       TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
       if (Ty.isInvalid())
         break;
 
       ConsumeAnnotationToken();
       Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
-                                           Ty.get(), nullptr);
+                                           Ty.get(), nullptr, Tok.getLocation());
       break;
     }
     LLVM_FALLTHROUGH;
 
   case tok::annot_decltype:
   case tok::kw_char:
   case tok::kw_wchar_t:
   case tok::kw_char8_t:

clang/lib/Parse/ParseObjc.cpp

 ///
 ///   objc-keywordexpr:
 ///     nonempty-expr-list
 ///
 ///   nonempty-expr-list:
 ///     assignment-expression
 ///     nonempty-expr-list , assignment-expression
 ///
 ExprResult
 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc,
                                        SourceLocation SuperLoc,
                                        ParsedType ReceiverType,
-                                       Expr *ReceiverExpr) {
+                                       Expr *ReceiverExpr,
+                                       SourceLocation InferredLBracLoc) {
   InMessageExpressionRAIIObject InMessage(*this, true);
 
   if (Tok.is(tok::code_completion)) {
+    SourceRange InferredBrac;
+    if (InferredLBracLoc.isValid()) {
+      InferredBrac = SourceRange(InferredLBracLoc, Tok.getLocation());
+      llvm::errs() << "[BUMBO] Found bracket replacement ";
+      llvm::errs().flush();
+      // InferredBrac.dump();
+    }
+    llvm::errs() << "[BUMBO] Triggering objc message code completion";
+    llvm::errs().flush();
+
     if (SuperLoc.isValid())
       Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, None,
                                            false);
     else if (ReceiverType)
       Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, None,
-                                           false);
+                                           false, false, InferredBrac);
     else
       Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
                                               None, false);
     cutOffParsing();
     return ExprError();
   }
 
   // Parse objc-selector

clang/lib/Sema/SemaCodeComplete.cpp

Result.AddTypedTextChunk(
         Result.getAllocator().CopyString(Template->getNameAsString()));
     Result.AddChunk(CodeCompletionString::CK_LeftAngle);
     AddTemplateParameterChunks(Ctx, Policy, Template, Result);
     Result.AddChunk(CodeCompletionString::CK_RightAngle);
     return Result.TakeString();
   }
 
   if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
+    // FIXME:(davg): should this just be a fix it itself?
+    bool needRBrac = FixIts.size() == 1;
     Selector Sel = Method->getSelector();
     if (Sel.isUnarySelector()) {
       Result.AddTypedTextChunk(
           Result.getAllocator().CopyString(Sel.getNameForSlot(0)));
+      if (needRBrac)
+        Result.AddChunk(CodeCompletionString::CK_RightBracket);
       return Result.TakeString();
     }
 
     std::string SelName = Sel.getNameForSlot(0).str();
     SelName += ':';
     if (StartParameter == 0)
       Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
     else {
if (Method->isVariadic()) {
         else if (AllParametersAreInformative)
           Result.AddInformativeChunk(", ...");
         else
           Result.AddPlaceholderChunk(", ...");
       }
 
       MaybeAddSentinel(PP, Method, Result);
     }
+    if (needRBrac)
+        Result.AddChunk(CodeCompletionString::CK_RightBracket);
 
     return Result.TakeString();
   }
 
   if (Qualifier)
     AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
                                    Ctx, Policy);
 
void Sema::CodeCompleteOrdinaryName(Scope *S,
   HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
                             Results.data(), Results.size());
 }
 
 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
                                        ParsedType Receiver,
                                        ArrayRef<IdentifierInfo *> SelIdents,
                                        bool AtArgumentExpression, bool IsSuper,
+                                       SourceRange BracFixIts,
                                        ResultBuilder &Results);
 
 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
                                 bool AllowNonIdentifiers,
                                 bool AllowNestedNameSpecifiers) {
   typedef CodeCompletionResult Result;
   ResultBuilder Results(
       *this, CodeCompleter->getAllocator(),
if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
       DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
       DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&
       !DS.isTypeAltiVecVector() && S &&
       (S->getFlags() & Scope::DeclScope) != 0 &&
       (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
                         Scope::FunctionPrototypeScope | Scope::AtCatchScope)) ==
           0) {
     ParsedType T = DS.getRepAsType();
-    if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
-      AddClassMessageCompletions(*this, S, T, None, false, false, Results);
+    if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType()) {
+      // FIXME: conditionalize fix it.
+      SourceRange InferredBrac = SourceRange(DS.getBeginLoc(), DS.getEndLoc());
+      AddClassMessageCompletions(*this, S, T, None, false, false,
+                                 InferredBrac, Results);
+    }
   }
 
   // Note that we intentionally suppress macro results here, since we do not
   // encourage using macros to produce the names of entities.
 
   HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
                             Results.data(), Results.size());
 }

 ///
 /// \param Results the structure into which we'll add results.
 static void AddObjCMethods(ObjCContainerDecl *Container,
                            bool WantInstanceMethods, ObjCMethodKind WantKind,
                            ArrayRef<IdentifierInfo *> SelIdents,
                            DeclContext *CurContext,
                            VisitedSelectorSet &Selectors, bool AllowSameLength,
                            ResultBuilder &Results, bool InOriginalClass = true,
-                           bool IsRootClass = false) {
+                           bool IsRootClass = false,
+                           SourceRange BracFixItsRange = SourceRange()) {
   typedef CodeCompletionResult Result;
   Container = getContainerDef(Container);
   ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
   IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
   for (ObjCMethodDecl *M : Container->methods()) {
     // The instance methods on the root class can be messaged via the
     // metaclass.
     if (M->isInstanceMethod() == WantInstanceMethods ||
         (IsRootClass && !WantInstanceMethods)) {
       // Check whether the selector identifiers we've been given are a
       // subset of the identifiers for this particular method.
       if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
         continue;
 
       if (!Selectors.insert(M->getSelector()).second)
         continue;
 
       Result R = Result(M, Results.getBasePriority(M), nullptr);
       R.StartParameter = SelIdents.size();
       R.AllParametersAreInformative = (WantKind != MK_Any);
       if (!InOriginalClass)
         setInBaseClass(R);
+      if (BracFixItsRange.isValid()) {
+        llvm::errs() << "Adding fix its\n";
+        R.FixIts.emplace_back(FixItHint::CreateInsertion(BracFixItsRange.getBegin(), "["));
+        R.FixIts.emplace_back(FixItHint::CreateInsertion(BracFixItsRange.getEnd(), "]"));
+      } else {
+        llvm::errs() << "fix it range invalid\n";
+      }
       Results.MaybeAddResult(R, CurContext);
     }
   }
 
   // Visit the protocols of protocols.
   if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
     if (Protocol->hasDefinition()) {
       const ObjCList<ObjCProtocolDecl> &Protocols =
           Protocol->getReferencedProtocols();
       for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
                                                 E = Protocols.end();
            I != E; ++I)
         AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
-                       Selectors, AllowSameLength, Results, false, IsRootClass);
+                       Selectors, AllowSameLength, Results, false, IsRootClass,
+                       BracFixItsRange);
     }
   }
 
   if (!IFace || !IFace->hasDefinition())
     return;
 
   // Add methods in protocols.
   for (ObjCProtocolDecl *I : IFace->protocols())
     AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
-                   Selectors, AllowSameLength, Results, false, IsRootClass);
+                   Selectors, AllowSameLength, Results, false, IsRootClass,
+                   BracFixItsRange);
 
   // Add methods in categories.
   for (ObjCCategoryDecl *CatDecl : IFace->known_categories()) {
     AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
                    CurContext, Selectors, AllowSameLength, Results,
-                   InOriginalClass, IsRootClass);
+                   InOriginalClass, IsRootClass, BracFixItsRange);
 
     // Add a categories protocol methods.
     const ObjCList<ObjCProtocolDecl> &Protocols =
         CatDecl->getReferencedProtocols();
     for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
                                               E = Protocols.end();
          I != E; ++I)
       AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
-                     Selectors, AllowSameLength, Results, false, IsRootClass);
+                     Selectors, AllowSameLength, Results, false, IsRootClass,
+                     BracFixItsRange);
 
     // Add methods in category implementations.
     if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
       AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
                      Selectors, AllowSameLength, Results, InOriginalClass,
-                     IsRootClass);
+                     IsRootClass, BracFixItsRange);
   }
 
   // Add methods in superclass.
   // Avoid passing in IsRootClass since root classes won't have super classes.
   if (IFace->getSuperClass())
     AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
                    SelIdents, CurContext, Selectors, AllowSameLength, Results,
-                   /*IsRootClass=*/false);
+                   /*InOriginalClass=*/false, /*IsRootClass=*/false,
+                   BracFixItsRange);
 
   // Add methods in our implementation, if any.
   if (ObjCImplementationDecl *Impl = IFace->getImplementation())
     AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
                    Selectors, AllowSameLength, Results, InOriginalClass,
-                   IsRootClass);
+                   IsRootClass, BracFixItsRange);
 }
 
 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
   // Try to find the interface where getters might live.
   ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
   if (!Class) {
     if (ObjCCategoryDecl *Category =
             dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
 
   return PreferredType;
 }
 
 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
                                        ParsedType Receiver,
                                        ArrayRef<IdentifierInfo *> SelIdents,
                                        bool AtArgumentExpression, bool IsSuper,
+                                       SourceRange BracFixIts,
                                        ResultBuilder &Results) {
   typedef CodeCompletionResult Result;
   ObjCInterfaceDecl *CDecl = nullptr;
 
+  llvm::errs() << "AddClassMessageCompletions\n";
+  if (BracFixIts.getBegin().isValid())
+    llvm::errs() << "LBracValid\n";
+  if (BracFixIts.getEnd().isValid())
+    llvm::errs() << "RBracValid\n";
+
   // If the given name refers to an interface type, retrieve the
   // corresponding declaration.
   if (Receiver) {
     QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
     if (!T.isNull())
       if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
         CDecl = Interface->getInterface();
   }
static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
   // If we're inside an Objective-C method definition, prefer its selector to
   // others.
   if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
     Results.setPreferredSelector(CurMethod->getSelector());
 
   VisitedSelectorSet Selectors;
   if (CDecl)
     AddObjCMethods(CDecl, false, MK_Any, SelIdents, SemaRef.CurContext,
-                   Selectors, AtArgumentExpression, Results);
+                   Selectors, AtArgumentExpression, Results, false, false,
+                   BracFixIts);
   else {
     // We're messaging "id" as a type; provide all class/factory methods.
 
     // If we have an external source, load the entire class method
     // pool from the AST file.
     if (SemaRef.getExternalSource()) {
       for (uint32_t I = 0,
                     N = SemaRef.getExternalSource()->GetNumExternalSelectors();
for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
            MethList && MethList->getMethod(); MethList = MethList->getNext()) {
         if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
           continue;
 
         Result R(MethList->getMethod(),
                  Results.getBasePriority(MethList->getMethod()), nullptr);
         R.StartParameter = SelIdents.size();
         R.AllParametersAreInformative = false;
+        // FIXME: add it fix it here too.
         Results.MaybeAddResult(R, SemaRef.CurContext);
       }
     }
   }
 
   Results.ExitScope();
 }
 
 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
                                         ArrayRef<IdentifierInfo *> SelIdents,
                                         bool AtArgumentExpression,
-                                        bool IsSuper) {
+                                        bool IsSuper,
+                                        SourceRange InferredBrac) {
 
   QualType T = this->GetTypeFromParser(Receiver);
 
   ResultBuilder Results(
       *this, CodeCompleter->getAllocator(),
       CodeCompleter->getCodeCompletionTUInfo(),
       CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage, T,
                             SelIdents));
 
+  llvm::errs() << "CodeCompleteObjCClassMessage\n";
+  SourceRange BracFixIt;
+  if (CodeCompleter->includeFixIts() && InferredBrac.isValid()) {
+    BracFixIt = std::move(InferredBrac);
+  }
+
   AddClassMessageCompletions(*this, S, Receiver, SelIdents,
-                             AtArgumentExpression, IsSuper, Results);
+                             AtArgumentExpression, IsSuper,
+                             BracFixIt, Results);
 
   // If we're actually at the argument expression (rather than prior to the
   // selector), we're actually performing code completion for an expression.
   // Determine whether we have a single, best method. If so, we can
   // code-complete the expression using the corresponding parameter type as
   // our preferred type, improving completion results.
   if (AtArgumentExpression) {
     QualType PreferredType =