[clangd] Also mark output arguments of array subscript expressions

[ckandeler]

Summary

... with the "usedAsMutableReference" semantic token modifier.
It's quite unusual to declare the index parameter of a subscript
operator as a non-const reference type, but arguably that makes it even
more helpful to be aware of it when working with such code.

[nridge]

Makes sense. Thanks!

clang-tools-extra/clangd/SemanticHighlighting.cpp

bool VisitCallExpr(CallExpr *E) {
     // make sense for literals...
     if (isa<UserDefinedLiteral>(E))
       return true;
 
     // FIXME: consider highlighting parameters of some other overloaded
     // operators as well
     llvm::ArrayRef<const Expr *> Args = {E->getArgs(), E->getNumArgs()};
     if (const auto callOp = dyn_cast<CXXOperatorCallExpr>(E)) {
-      if (callOp->getOperator() != OO_Call)
-        return true;
+      switch (callOp->getOperator()) {
+      case OO_Call:
+      case OO_Subscript:
         Args = Args.drop_front(); // Drop object parameter
+        break;
+      default:
+        return true;
+      }
     }
 
     highlightMutableReferenceArguments(
         dyn_cast_or_null<FunctionDecl>(E->getCalleeDecl()), Args);
 
     return true;
   }
 

clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp

)cpp",
         };
       )cpp",
       // Modifier for variables passed as non-const references
       R"cpp(
         struct $Class_decl[[ClassWithOp]] {
             void operator()(int);
             void operator()(int, int &);
             void operator()(int, int, const int &);
+            int &operator[](int &);
+            int operator[](int) const;
         };
         void $Function_decl[[fun]](int, const int,
                                    int*, const int*,
                                    int&, const int&,
                                    int*&, const int*&, const int* const &,
                                    int**, int**&, int** const &,
                                    int = 123) {
           int $LocalVariable_decl[[val]];
)cpp",
 
                            $LocalVariable[[array]], $LocalVariable_usedAsMutableReference[[array]], 
                            $LocalVariable[[array]]
                            );
           [](int){}($LocalVariable[[val]]);
           [](int&){}($LocalVariable_usedAsMutableReference[[val]]);
           [](const int&){}($LocalVariable[[val]]);
           $Class[[ClassWithOp]] $LocalVariable_decl[[c]];
+          const $Class[[ClassWithOp]] $LocalVariable_decl_readonly[[c2]];
           $LocalVariable[[c]]($LocalVariable[[val]]);
           $LocalVariable[[c]](0, $LocalVariable_usedAsMutableReference[[val]]);
           $LocalVariable[[c]](0, 0, $LocalVariable[[val]]);
+          $LocalVariable[[c]][$LocalVariable_usedAsMutableReference[[val]]];
+          $LocalVariable_readonly[[c2]][$LocalVariable[[val]]];
         }
         struct $Class_decl[[S]] {
           $Class_decl[[S]](int&) {
             $Class[[S]] $LocalVariable_decl[[s1]]($Field_usedAsMutableReference[[field]]);
             $Class[[S]] $LocalVariable_decl[[s2]]($LocalVariable[[s1]].$Field_usedAsMutableReference[[field]]);
 
             $Class[[S]] $LocalVariable_decl[[s3]]($StaticField_static_usedAsMutableReference[[staticField]]);
             $Class[[S]] $LocalVariable_decl[[s4]]($Class[[S]]::$StaticField_static_usedAsMutableReference[[staticField]]);