[documentation]Fixed Random Typos

[ayushi-8102]

Summary

This patch fixes https://github.com/llvm/llvm-project/issues/56747

clang/docs/AutomaticReferenceCounting.rst

.. admonition:: Rationale
   We've so far consciously refrained from implicitly turning retained CF
   results from function calls into ``__bridge_transfer`` casts.  The worry is
   that some code patterns  ---  for example, creating a CF value, assigning it
   to an ObjC-typed local, and then calling ``CFRelease`` when done  ---  are a
   bit too likely to be accidentally accepted, leading to mysterious behavior.
 
   For loads from ``const`` global variables of :ref:`C retainable pointer type
   <arc.misc.c-retainable>`, it is reasonable to assume that global system
-  constants were initialitzed with true constants (e.g. string literals), but
+  constants were initialized with true constants (e.g. string literals), but
   user constants might have been initialized with something dynamically
   allocated, using a global initializer.
 
 .. _arc.objects.restrictions.conversion-exception-contextual:
 
 Conversion from retainable object pointer type in certain contexts
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

clang/docs/ConstantInterpreter.rst

 
 * ``PT_MemPtr``
 
   Member pointer type, can also be a null member pointer. Defined
   in ``"MemberPointer.h"``
 
 * ``PT_VoidPtr``
 
-  Void pointer type, can be used for rount-trip casts. Represented as
+  Void pointer type, can be used for round-trip casts. Represented as
   the union of all pointers which can be cast to void.
   Defined in ``"VoidPointer.h"``.
 
 * ``PT_ObjCBlockPtr``
 
   Pointer type for ObjC blocks. Defined in ``"ObjCBlockPointer.h"``.
 
 Composite types

clang/docs/CrossCompilation.rst

 The system name is generally the OS (linux, darwin), but could be special
 like the bare-metal "none".
 
 When a parameter is not important, it can be omitted, or you can
 choose ``unknown`` and the defaults will be used. If you choose a parameter
 that Clang doesn't know, like ``blerg``, it'll ignore and assume
 ``unknown``, which is not always desired, so be careful.
 
-Finally, the env (enviornment) option is something that will pick default
+Finally, the env (environment) option is something that will pick default
 CPU/FPU, define the specific behaviour of your code (PCS, extensions),
 and also choose the correct library calls, etc.
 
 CPU, FPU, ABI
 -------------
 
 Once your target is specified, it's time to pick the hardware you'll
 be compiling to. For every architecture, a default set of CPU/FPU/ABI

clang/docs/DataFlowAnalysisIntro.md

 
 *   When `x` is assigned a concrete value, its possible set of values contains
     just that specific value.
 
 *   When `x` is assigned some unknown value, it can have any value. We represent
     this fact as `⊤`.
 
 *   When two control flow paths join, we compute the set union of incoming
-    values (limiting the number of elements to 3, representig larger sets as
+    values (limiting the number of elements to 3, representing larger sets as
     `⊤`).
 
 The sets of possible values are influenced by:
 
 *   Statements, for example, assignments.
 
 *   Joins in control flow, for example, ones that appear at the end of "if"
     statements.
void PrintAbs(int x) {
   }
   print(result);  // result is {x; -x}
 }
 ```
 
 We can't say what specific value gets printed, but we know that it is either `x`
 or `-x`.
 
-Dataflow analysis is an istance of abstract interpretation, and does not dictate
+Dataflow analysis is an instance of abstract interpretation, and does not dictate
 how exactly the lattice and transfer functions should be designed, beyond the
 necessary conditions for the analysis to converge. Nevertheless, we can use
 symbolic execution ideas to guide our design of the lattice and transfer
 functions: lattice values can be symbolic expressions, and transfer functions
 can construct more complex symbolic expressions from symbolic expressions that
 represent arguments. See [this StackOverflow
 discussion](https://cstheory.stackexchange.com/questions/19708/symbolic-execution-is-a-case-of-abstract-interpretation)
 for a further comparison of abstract interpretation and symbolic execution.
if (cond()) {
     x = 10; // x is initialized
   }
   print(x); // x is maybe uninitialized, x is being read, report a bug.
 }
 ```
 
 For this purpose we can use lattice in a form of a mapping from variable
 declarations to initialization states; each initialization state is represented
-by the followingn lattice:
+by the following lattice:
 
 ![Lattice for definitive initialization analysis](DataFlowAnalysisIntroImages/DefinitiveInitializationLattice.svg)
 
 A lattice element could also capture the source locations of the branches that
 lead us to the corresponding program point. Diagnostics would use this
 information to show a sample buggy code path to the user.
 
 ## Example: refactoring raw pointers to `unique_ptr`

clang/docs/DebuggingCoroutines.rst

.. code-block:: python
   ShowCoroFrame()
 
 Then let's run:
 
 .. code-block:: text
 
   $ clang++ -std=c++20 -g debugging-example.cpp -o debugging-example
   $ gdb ./debugging-example
-  (gdb) # We've alreay set the breakpoint.
+  (gdb) # We've already set the breakpoint.
   (gdb) r
   Program received signal SIGTRAP, Trace/breakpoint trap.
   detail::chain_fn<0> () at debugging-example2.cpp:73
   73    co_return 0;
   (gdb) # Executes the debugging scripts
   (gdb) source debugging-helper.py
   (gdb) # Print the asynchronous stack
   (gdb) async-bt

clang/docs/analyzer/developer-docs/nullability.rst

 
 If a pointer ``p`` has a nullable annotation and no explicit null check or assert, we should warn in the following cases:
 
 * ``p`` gets implicitly converted into nonnull pointer, for example, we are passing it to a function that takes a nonnull parameter.
 * ``p`` gets dereferenced
 
 Taking a branch on nullable pointers are the same like taking branch on null unspecified pointers.
 
-Explicit cast from nullable to nonnul:
+Explicit cast from nullable to nonnull:
 
 .. code-block:: cpp
 
   __nullable id foo;
   id bar = foo;
   takesNonNull((_nonnull) bar); // should not warn here (backward compatibility hack)
   anotherTakesNonNull(bar); // would be great to warn here, but not necessary(*)
 

clang/include/clang/AST/CXXInheritance.h

 /// member function in that hierarchy has one or more "final
 /// overriders" (C++ [class.virtual]p2). A final overrider for a
 /// virtual function "f" is the virtual function that will actually be
 /// invoked when dispatching a call to "f" through the
 /// vtable. Well-formed classes have a single final overrider for each
 /// virtual function; in abstract classes, the final overrider for at
 /// least one virtual function is a pure virtual function. Due to
 /// multiple, virtual inheritance, it is possible for a class to have
-/// more than one final overrider. Athough this is an error (per C++
+/// more than one final overrider. Although this is an error (per C++
 /// [class.virtual]p2), it is not considered an error here: the final
 /// overrider map can represent multiple final overriders for a
 /// method, and it is up to the client to determine whether they are
 /// problem. For example, the following class \c D has two final
 /// overriders for the virtual function \c A::f(), one in \c C and one
 /// in \c D:
 ///
 /// \code

clang/include/clang/AST/CommentSema.h

private:
 
   void checkFunctionDeclVerbatimLine(const BlockCommandComment *Comment);
 
   void checkContainerDeclVerbatimLine(const BlockCommandComment *Comment);
 
   void checkContainerDecl(const BlockCommandComment *Comment);
 
   /// Resolve parameter names to parameter indexes in function declaration.
-  /// Emit diagnostics about unknown parametrs.
+  /// Emit diagnostics about unknown parameters.
   void resolveParamCommandIndexes(const FullComment *FC);
 
   /// \returns \c true if the declaration that this comment is attached to
   /// is a pointer to function/method/block type or has such a type.
   bool involvesFunctionType();
 
   bool isFunctionDecl();
   bool isAnyFunctionDecl();

clang/include/clang/AST/Decl.h

public:
 
   /// Returns true if the function has a definition that does not need to be
   /// instantiated.
   ///
   /// The variant that accepts a FunctionDecl pointer will set that function
   /// declaration to the declaration that is a definition (if there is one).
   ///
   /// \param CheckForPendingFriendDefinition If \c true, also check for friend
-  ///        declarations that were instantiataed from function definitions.
+  ///        declarations that were instantiated from function definitions.
   ///        Such a declaration behaves as if it is a definition for the
   ///        purpose of redefinition checking, but isn't actually a "real"
   ///        definition until its body is instantiated.
   bool isDefined(const FunctionDecl *&Definition,
                  bool CheckForPendingFriendDefinition = false) const;
 
   bool isDefined() const {
     const FunctionDecl* Definition;

clang/include/clang/AST/DeclBase.h

class DeclContext {
   /// If modified NumOMPDeclareReductionDeclBits and the accessor
   /// methods in OMPDeclareReductionDecl should be updated appropriately.
   class OMPDeclareReductionDeclBitfields {
     friend class OMPDeclareReductionDecl;
     /// For the bits in DeclContextBitfields
     uint64_t : NumDeclContextBits;
 
     /// Kind of initializer,
-    /// function call or omp_priv<init_expr> initializtion.
+    /// function call or omp_priv<init_expr> initialization.
     uint64_t InitializerKind : 2;
   };
 
   /// Number of non-inherited bits in OMPDeclareReductionDeclBitfields.
   enum { NumOMPDeclareReductionDeclBits = 2 };
 
   /// Stores the bits used by FunctionDecl.
   /// If modified NumFunctionDeclBits and the accessor

clang/include/clang/AST/DeclTemplate.h

struct CommonBase {
     /// The first value in the array is the number of specializations/partial
     /// specializations that follow.
     uint32_t *LazySpecializations = nullptr;
 
     /// The set of "injected" template arguments used within this
     /// template.
     ///
     /// This pointer refers to the template arguments (there are as
-    /// many template arguments as template parameaters) for the
+    /// many template arguments as template parameters) for the
     /// template, and is allocated lazily, since most templates do not
     /// require the use of this information.
     TemplateArgument *InjectedArgs = nullptr;
   };
 
   /// Pointer to the common data shared by all declarations of this
   /// template.
   mutable CommonBase *Common = nullptr;

clang/include/clang/AST/DeclarationName.h

public:
   static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc) {
     DeclarationNameLoc DNL;
     DNL.setCXXLiteralOperatorNameLoc(Loc);
     return DNL;
   }
 };
 
 /// DeclarationNameInfo - A collector data type for bundling together
-/// a DeclarationName and the correspnding source/type location info.
+/// a DeclarationName and the corresponding source/type location info.
 struct DeclarationNameInfo {
 private:
   /// Name - The declaration name, also encoding name kind.
   DeclarationName Name;
 
   /// Loc - The main source location for the declaration name.
   SourceLocation NameLoc;
 

clang/include/clang/AST/Expr.h

protected:
   /// Construct an empty expression.
   explicit Expr(StmtClass SC, EmptyShell) : ValueStmt(SC) { }
 
   /// Each concrete expr subclass is expected to compute its dependence and call
   /// this in the constructor.
   void setDependence(ExprDependence Deps) {
     ExprBits.Dependent = static_cast<unsigned>(Deps);
   }
-  friend class ASTImporter; // Sets dependence dircetly.
-  friend class ASTStmtReader; // Sets dependence dircetly.
+  friend class ASTImporter; // Sets dependence directly.
+  friend class ASTStmtReader; // Sets dependence directly.
 
 public:
   QualType getType() const { return TR; }
   void setType(QualType t) {
     // In C++, the type of an expression is always adjusted so that it
     // will not have reference type (C++ [expr]p6). Use
     // QualType::getNonReferenceType() to retrieve the non-reference
     // type. Additionally, inspect Expr::isLvalue to determine whether
public:
   /// @code
   /// template<int Size, char (&Chars)[Size]> struct meta_string;
   /// @endcode
   bool isValueDependent() const {
     return static_cast<bool>(getDependence() & ExprDependence::Value);
   }
 
   /// Determines whether the type of this expression depends on
-  ///   - a template paramter (C++ [temp.dep.expr], which means that its type
+  ///   - a template parameter (C++ [temp.dep.expr], which means that its type
   ///     could change from one template instantiation to the next)
   ///   - or an error
   ///
   /// For example, the expressions "x" and "x + y" are type-dependent in
   /// the following code, but "y" is not type-dependent:
   /// @code
   /// template<typename T>
   /// void add(T x, int y) {
public:
   /// Returns true if this expression is a bound member function.
   bool isBoundMemberFunction(ASTContext &Ctx) const;
 
   /// Given an expression of bound-member type, find the type
   /// of the member.  Returns null if this is an *overloaded* bound
   /// member expression.
   static QualType findBoundMemberType(const Expr *expr);
 
-  /// Skip past any invisble AST nodes which might surround this
+  /// Skip past any invisible AST nodes which might surround this
   /// statement, such as ExprWithCleanups or ImplicitCastExpr nodes,
   /// but also injected CXXMemberExpr and CXXConstructExpr which represent
   /// implicit conversions.
   Expr *IgnoreUnlessSpelledInSource();
   const Expr *IgnoreUnlessSpelledInSource() const {
     return const_cast<Expr *>(this)->IgnoreUnlessSpelledInSource();
   }
 
public:
   /// FIXME: This is intended purely as a temporary workaround for code
   /// that hasn't yet been rewritten to do the right thing about those
   /// casts, and may disappear along with the last internal use.
   Expr *IgnoreParenLValueCasts() LLVM_READONLY;
   const Expr *IgnoreParenLValueCasts() const {
     return const_cast<Expr *>(this)->IgnoreParenLValueCasts();
   }
 
-  /// Skip past any parenthese and casts which do not change the value
+  /// Skip past any parentheses and casts which do not change the value
   /// (including ptr->int casts of the same size) until reaching a fixed point.
   /// Skips:
   /// * What IgnoreParens() skips
   /// * CastExpr which do not change the value
   /// * SubstNonTypeTemplateParmExpr
   Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY;
   const Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) const {
     return const_cast<Expr *>(this)->IgnoreParenNoopCasts(Ctx);

 /// a subclass for overloaded operator calls that use operator syntax, e.g.,
 /// "str1 + str2" to resolve to a function call.
 class CallExpr : public Expr {
   enum { FN = 0, PREARGS_START = 1 };
 
   /// The number of arguments in the call expression.
   unsigned NumArgs;
 
-  /// The location of the right parenthese. This has a different meaning for
+  /// The location of the right parentheses. This has a different meaning for
   /// the derived classes of CallExpr.
   SourceLocation RParenLoc;
 
   // CallExpr store some data in trailing objects. However since CallExpr
   // is used a base of other expression classes we cannot use
   // llvm::TrailingObjects. Instead we manually perform the pointer arithmetic
   // and casts.
   //

clang/include/clang/Analysis/Analyses/CalledOnceCheck.h

 class Expr;
 class ParmVarDecl;
 class Stmt;
 
 /// Classification of situations when parameter is not called on every path.
 /// \enum IfThen -- then branch of the if statement has no call.
 /// \enum IfElse -- else branch of the if statement has no call.
 /// \enum Switch -- one of the switch cases doesn't have a call.
-/// \enum SwitchSkipped -- there is no call if none of the cases appies.
+/// \enum SwitchSkipped -- there is no call if none of the cases applies.
 /// \enum LoopEntered -- no call when the loop is entered.
 /// \enum LoopSkipped -- no call when the loop is not entered.
 /// \enum FallbackReason -- fallback case when we were not able to figure out
 /// the reason.
 enum class NeverCalledReason {
   IfThen,
   IfElse,
   Switch,

clang/include/clang/Analysis/Analyses/Consumed.h

public:
     ConsumedAnalyzer(ConsumedWarningsHandlerBase &WarningsHandler)
         : WarningsHandler(WarningsHandler) {}
 
     ConsumedState getExpectedReturnState() const { return ExpectedReturnState; }
 
     /// Check a function's CFG for consumed violations.
     ///
     /// We traverse the blocks in the CFG, keeping track of the state of each
-    /// value who's type has uniquness annotations.  If methods are invoked in
+    /// value who's type has uniqueness annotations.  If methods are invoked in
     /// the wrong state a warning is issued.  Each block in the CFG is traversed
     /// exactly once.
     void run(AnalysisDeclContext &AC);
   };
 
 } // namespace consumed
 
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_CONSUMED_H

clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h

typename C::CType compare(const Identifier* E, C& Cmp) const {
     return Cmp.compareStrings(name(), E->name());
   }
 
 private:
   StringRef Name;
 };
 
 /// An if-then-else expression.
-/// This is a pseduo-term; it will be lowered to a branch in a CFG.
+/// This is a pseudo-term; it will be lowered to a branch in a CFG.
 class IfThenElse : public SExpr {
 public:
   IfThenElse(SExpr *C, SExpr *T, SExpr *E)
       : SExpr(COP_IfThenElse), Condition(C), ThenExpr(T), ElseExpr(E) {}
   IfThenElse(const IfThenElse &I, SExpr *C, SExpr *T, SExpr *E)
       : SExpr(I), Condition(C), ThenExpr(T), ElseExpr(E) {}
 
   static bool classof(const SExpr *E) { return E->opcode() == COP_IfThenElse; }

 
 private:
   SExpr* Condition;
   SExpr* ThenExpr;
   SExpr* ElseExpr;
 };
 
 /// A let-expression,  e.g.  let x=t; u.
-/// This is a pseduo-term; it will be lowered to instructions in a CFG.
+/// This is a pseudo-term; it will be lowered to instructions in a CFG.
 class Let : public SExpr {
 public:
   Let(Variable *Vd, SExpr *Bd) : SExpr(COP_Let), VarDecl(Vd), Body(Bd) {
     Vd->setKind(Variable::VK_Let);
   }
 
   Let(const Let &L, Variable *Vd, SExpr *Bd) : SExpr(L), VarDecl(Vd), Body(Bd) {
     Vd->setKind(Variable::VK_Let);

clang/include/clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def

 
 WARNING_GADGET(Increment)
 WARNING_GADGET(Decrement)
 WARNING_GADGET(ArraySubscript)
 WARNING_GADGET(PointerArithmetic)
 WARNING_GADGET(UnsafeBufferUsageAttr)
 FIXABLE_GADGET(ULCArraySubscript)
 FIXABLE_GADGET(DerefSimplePtrArithFixable)
+FIXABLE_GADGET(PointerDereference)
 
 #undef FIXABLE_GADGET
 #undef WARNING_GADGET
 #undef GADGET

clang/lib/Analysis/UnsafeBufferUsage.cpp

public:
   virtual DeclUseList getClaimedVarUseSites() const override {
     if (const auto *DRE =
             dyn_cast<DeclRefExpr>(Node->getBase()->IgnoreImpCasts())) {
       return {DRE};
     }
     return {};
   }
 };
+
+class PointerDereferenceGadget : public FixableGadget {
+  static constexpr const char *const BaseDeclRefExprTag = "BaseDRE";
+  static constexpr const char *const OperatorTag = "op";
+
+  const DeclRefExpr *BaseDeclRefExpr = nullptr;
+  const UnaryOperator *Op = nullptr;
+
+public:
+  PointerDereferenceGadget(const MatchFinder::MatchResult &Result)
+      : FixableGadget(Kind::PointerDereference),
+        BaseDeclRefExpr(
+            Result.Nodes.getNodeAs<DeclRefExpr>(BaseDeclRefExprTag)),
+        Op(Result.Nodes.getNodeAs<UnaryOperator>(OperatorTag)) {}
+
+  static bool classof(const Gadget *G) {
+    return G->getKind() == Kind::PointerDereference;
+  }
+
+  static Matcher matcher() {
+    auto Target =
+        unaryOperator(
+            hasOperatorName("*"),
+            has(expr(ignoringParenImpCasts(
+                declRefExpr(to(varDecl())).bind(BaseDeclRefExprTag)))))
+            .bind(OperatorTag);
+
+    return expr(isInUnspecifiedLvalueContext(Target));
+  }
+
+  DeclUseList getClaimedVarUseSites() const override {
+    return {BaseDeclRefExpr};
+  }
+
+  virtual const Stmt *getBaseStmt() const final { return Op; }
+
+  virtual std::optional<FixItList> getFixits(const Strategy &S) const override;
+};
+
 } // namespace
 
 namespace {
 // An auxiliary tracking facility for the fixit analysis. It helps connect
 // declarations to its and make sure we've covered all uses with our analysis
 // before we try to fix the declaration.
 class DeclUseTracker {
   using UseSetTy = SmallSet<const DeclRefExpr *, 16>;
if (VD && s.lookup(VD) == Strategy::Kind::Span) {
     return FixItList{
         {FixItHint::CreateRemoval(StarWithTrailWhitespace),
          FixItHint::CreateReplacement(PlusWithSurroundingWhitespace, "["),
          FixItHint::CreateReplacement(ClosingParenWithPrecWhitespace, "]")}};
   }
   return std::nullopt; // something wrong or unsupported, give up
 }
 
+std::optional<FixItList>
+PointerDereferenceGadget::getFixits(const Strategy &S) const {
+  const VarDecl *VD = cast<VarDecl>(BaseDeclRefExpr->getDecl());
+  switch (S.lookup(VD)) {
+  case Strategy::Kind::Span: {
+    ASTContext &Ctx = VD->getASTContext();
+    SourceManager &SM = Ctx.getSourceManager();
+    // Required changes: *(ptr); => (ptr[0]); and *ptr; => ptr[0]
+    // Deletes the *operand
+    CharSourceRange derefRange = clang::CharSourceRange::getCharRange(
+        Op->getBeginLoc(), Op->getBeginLoc().getLocWithOffset(1));
+    // Inserts the [0]
+    std::optional<SourceLocation> endOfOperand =
+        getEndCharLoc(BaseDeclRefExpr, SM, Ctx.getLangOpts());
+    if (endOfOperand) {
+      return FixItList{{FixItHint::CreateRemoval(derefRange),
+                        FixItHint::CreateInsertion(
+                            endOfOperand.value().getLocWithOffset(1), "[0]")}};
+    }
+  }
+  case Strategy::Kind::Iterator:
+  case Strategy::Kind::Array:
+  case Strategy::Kind::Vector:
+    llvm_unreachable("Strategy not implemented yet!");
+  case Strategy::Kind::Wontfix:
+    llvm_unreachable("Invalid strategy!");
+  }
+
+  return std::nullopt;
+}
+
 // For a non-null initializer `Init` of `T *` type, this function returns
 // `FixItHint`s producing a list initializer `{Init,  S}` as a part of a fix-it
 // to output stream.
 // In many cases, this function cannot figure out the actual extent `S`.  It
 // then will use a place holder to replace `S` to ask users to fill `S` in.  The
 // initializer shall be used to initialize a variable of type `std::span<T>`.
 //
 // FIXME: Support multi-level pointers

clang/test/SemaCXX/warn-unsafe-buffer-usage-fixits-pointer-deref.cpp

+// RUN: %clang_cc1 -std=c++20 -Wunsafe-buffer-usage -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+
+void basic_dereference() {
+  int tmp;
+  auto p = new int[10];
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:11}:"std::span<int> p"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"{"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-3]]:23-[[@LINE-3]]:23}:", 10}"
+  tmp = p[5];
+  int val = *p;
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:14}:""
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:15-[[@LINE-2]]:15}:"[0]"
+}
+
+int return_method() {
+  auto p = new int[10];
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:11}:"std::span<int> p"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"{"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-3]]:23-[[@LINE-3]]:23}:", 10}"
+  int tmp = p[5];
+  return *p;
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:11}:""
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"[0]"
+}
+
+void foo(int v) {
+}
+
+void method_invocation() {
+  auto p = new int[10];
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:11}:"std::span<int> p"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"{"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-3]]:23-[[@LINE-3]]:23}:", 10}"
+
+  int tmp = p[5];
+
+  foo(*p);
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:7-[[@LINE-1]]:8}:""
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:9-[[@LINE-2]]:9}:"[0]"
+}
+
+void binary_operation() {
+  auto p = new int[10];
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:11}:"std::span<int> p"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"{"
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-3]]:23-[[@LINE-3]]:23}:", 10}"
+
+  int tmp = p[5];
+
+  int k = *p + 20;
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-1]]:11-[[@LINE-1]]:12}:""
+  // CHECK-DAG: fix-it:"{{.*}}":{[[@LINE-2]]:13-[[@LINE-2]]:13}:"[0]"
+
+}
+