[Sema][Typo] Fix assertion failure for expressions with multiple typos

[dgoldman]

Summary

As Typo Resolution can create new TypoExprs while resolving typos,
it is necessary to recurse through the expression to search for more
typos.

This should fix the assertion failure in clang::Sema::~Sema():

`DelayedTypos.empty() && "Uncorrected typos!"`

Notes:

• For expressions with multiple typos, we only give suggestions if we are able to resolve all typos in the expression
• This patch is similar to D37521 except that it does not eagerly commit to a correction for the first typo in the expression. Instead, it will search for corrections which fix all of the typos in the expression.

[rsmith]

lib/Sema/SemaExprCXX.cpp

7795–7797

What happens if an ambiguous TypoExpr is created as a result of one of the outer level transformations?

In that case, I think that we will try alternatives for that TypoExpr here, but that TypoExpr is not in the expression we're transforming (it was created within RecursiveTransformLoop and isn't part of E), so we're just redoing the same transformation we already did but with typo-correction disabled. This means that the transform will fail (because we hit a typo and can't correct it), so we'll accept the original set of corrections despite them being ambiguous.

7799–7800

What prevents diagnostics from being emitted for TypoExprs we create for an outer transform that we end up discarding? Eg, in:

struct Y {};
struct Z { int value; };
struct A {
  Y get_me_a_Y();
};
struct B {
  Z get_me_a_Z();
};
A make_an_A();
B make_a_B();
int f() {
  return make_an_E().get_me_a_Z().value;
}

I'm concerned that we will:

• try correcting make_me_an_E (TypoExpr T0) to make_me_an_A (because that correction has the minimum edit distance) and discover that there is no get_me_a_Z member, creating a new TypoExpr T1, and recurse:
  • try correcting get_me_a_Z (TypoExpr T1) to get_me_a_Y and discover that there is no value member
  • no correction works: bail out of recursive step
• try correcting make_me_an_E (TypoExpr T0) to make_me_a_B and succeed

But now we still have T1 in our list of TypoExprs, and will presumably diagnose it (and take action below if it turned out to be ambiguous etc).

[dgoldman]

• Fix diagnostics for ignored TypoExprs

[dgoldman]

lib/Sema/SemaExprCXX.cpp

7795–7797

So what do you recommend here? Checking for the non-ambiguity in RecursiveTransformLoop itself?

7799–7800

Fixed by discarding the failed TypoExprs

[dgoldman]

• Fix discarded correction test

[rsmith]

lib/Sema/SemaExprCXX.cpp

7795–7797

Suggestion: in the recursive transform, if we find a potential ambiguity, check whether it's actually ambiguous before returning. If it is ambiguous, fail out of the entire typo-correction process: one of our tied-for-best candidates was ambiguous, so we deem the overall typo-correction process to be ambiguous. And if not, then carry on as in your current patch.

[dgoldman]

lib/Sema/SemaExprCXX.cpp

7795–7797

Will submit a follow up patch to handle this, I think I'll likely rewrite the ambiguity handling to remove the AmbiguousTypoExprs bit.

[dgoldman]

• Remove unused State variable

[dgoldman]

• Move if empty check back

[dgoldman]

• Fix ambiguity handling and add more tests

[dgoldman]

• Add another test and fix up comment

[rsmith]

Thanks, this looks good; just some nits.

lib/Sema/SemaExprCXX.cpp

7591–7596

Please capitalize this parameter name to match the surrounding code style.

7600–7603

Reflow to 80 columns.

7772

outIsAmbiguous -> IsAmbiguous (we don't use an out prefix for output parameters).

7780–7781

Use std::move here.

7782–7785

Call TypoExprs.clear() rather than copying from a default-constructed object.

7796–7797

isAmbiguous -> IsAmbiguous.

7809–7810

And std::move here too.

7864–7865

Apply clang-format here. (Or: add space after while on the first line, and indent the second line so it begins in the same column as (Next =[...]).

7867–7871

Reverse the condition of this if so you can early-exit from the loop and remove the else.

[dgoldman]

• Minor fixes

[dgoldman]

lib/Sema/SemaExprCXX.cpp

7841–7843

Should I do the same std::move and clear here as well?

[rsmith]

lib/Sema/SemaExprCXX.cpp

7841–7843

Yes, please.

[dgoldman]

• Minor fixes

[dgoldman]

• Bug fixes

[rsmith]

Thanks, LGTM. Do you need someone to commit this for you?

[dgoldman]

In D62648#1596535, @rsmith wrote:

Thanks, LGTM. Do you need someone to commit this for you?

Nope, I can commit it. There's still one outstanding issue though: typo-correction-cxx11.cpp is still failing with the DelayedTypos.empty() && "Uncorrected typos!" error, looking into how I can handle it.

[dgoldman]

• Fix test failure: typo-correction-cxx11.cpp

Make sure that TryTransform clears any TypoExprs that are created
if it returns an invalid ExprResult (as the new TypoExprs are unreachable
from the result).

[rsmith]

I don't think you need to change the TreeTranform base class to support this; TreeTransform::TransformExpr is an extension point which you can override from TransformTypos to inject the custom logic you need. But I also don't think this TreeTransform::TransformExpr approach works in general anyway, as noted below.

lib/Sema/TreeTransform.h

3485–3489

It's not safe to assume that all created TypoExprs will be produced by TransformExpr. We might (for example) produce a new TypoExpr for the callee expression while transforming a CallExpr, and you won't catch that here.

It would seem cleaner and more robust to me to collect the typos produced during typo correction from within Sema::createDelayedTypo. (Eg, set some state on Sema for the duration of typo correction, and use that state to communicate any created typos back from createDelayedTypo to typo correction.)

[dgoldman]

Fix test failure via TransformTypos

• Add a new property on Sema to track newly created Typos and use this from within TransformTypos in order to delete any Typos that are unreachable (tested in typo-correction-cxx11.cpp)

[dgoldman]

• remove extra newline

lib/Sema/SemaExprCXX.cpp

class TransformTypos : public TreeTransform<TransformTypos> {
   VarDecl *InitDecl; // A decl to avoid as a correction because it is in the
                      // process of being initialized.
   llvm::function_ref<ExprResult(Expr *)> ExprFilter;
   llvm::SmallSetVector<TypoExpr *, 2> TypoExprs, AmbiguousTypoExprs;
   llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
   llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
 
   /// Emit diagnostics for all of the TypoExprs encountered.
+  ///
   /// If the TypoExprs were successfully corrected, then the diagnostics should
   /// suggest the corrections. Otherwise the diagnostics will not suggest
   /// anything (having been passed an empty TypoCorrection).
-  void EmitAllDiagnostics() {
+  ///
+  /// If we've failed to correct due to ambiguous corrections, we need to
+  /// be sure to pass empty corrections and replacements. Otherwise it's
+  /// possible that the Consumer has a TypoCorrection that failed to ambiguity
+  /// and we don't want to report those diagnostics.
+  void EmitAllDiagnostics(bool IsAmbiguous) {
     for (TypoExpr *TE : TypoExprs) {
       auto &State = SemaRef.getTypoExprState(TE);
       if (State.DiagHandler) {
-        TypoCorrection TC = State.Consumer->getCurrentCorrection();
-        ExprResult Replacement = TransformCache[TE];
+        TypoCorrection TC = IsAmbiguous
+            ? TypoCorrection() : State.Consumer->getCurrentCorrection();
+        ExprResult Replacement = IsAmbiguous ? ExprError() : TransformCache[TE];
 
         // Extract the NamedDecl from the transformed TypoExpr and add it to the
         // TypoCorrection, replacing the existing decls. This ensures the right
         // NamedDecl is used in diagnostics e.g. in the case where overload
         // resolution was used to select one from several possible decls that
         // had been stored in the TypoCorrection.
         if (auto *ND = getDeclFromExpr(
                 Replacement.isInvalid() ? nullptr : Replacement.get()))
           TC.setCorrectionDecl(ND);
if (auto *ME = dyn_cast<MemberExpr>(E))
       return ME->getFoundDecl();
     // FIXME: Add any other expr types that could be be seen by the delayed typo
     // correction TreeTransform for which the corresponding TypoCorrection could
     // contain multiple decls.
     return nullptr;
   }
 
   ExprResult TryTransform(Expr *E) {
-    Sema::SFINAETrap Trap(SemaRef);
-    ExprResult Res = TransformExpr(E);
-    if (Trap.hasErrorOccurred() || Res.isInvalid())
-      return ExprError();
+    return TryTransformExpr(E, ExprFilter);
+  }
+
+  // Since correcting typos may intoduce new TypoExprs, this function
+  // checks for new TypoExprs and recurses if it finds any. Note that it will
+  // only succeed if it is able to correct all typos in the given expression.
+  ExprResult CheckForRecursiveTypos(ExprResult Res, bool &IsAmbiguous) {
+    if (Res.isInvalid()) {
+      return Res;
+    }
+    // Check to see if any new TypoExprs were created. If so, we need to recurse
+    // to check their validity.
+    Expr *FixedExpr = Res.get();
+
+    auto SavedTypoExprs = std::move(TypoExprs);
+    auto SavedAmbiguousTypoExprs = std::move(AmbiguousTypoExprs);
+    TypoExprs.clear();
+    AmbiguousTypoExprs.clear();
+
+    FindTypoExprs(TypoExprs).TraverseStmt(FixedExpr);
+    if (!TypoExprs.empty()) {
+      // Recurse to handle newly created TypoExprs. If we're not able to
+      // handle them, discard these TypoExprs.
+      ExprResult RecurResult =
+          RecursiveTransformLoop(FixedExpr, IsAmbiguous);
+      if (RecurResult.isInvalid()) {
+        Res = ExprError();
+        // Recursive corrections didn't work, wipe them away and don't add
+        // them to the TypoExprs set.
+        for (auto TE : TypoExprs) {
+          TransformCache.erase(TE);
+          SemaRef.clearDelayedTypo(TE);
+        }
+      } else {
+        // TypoExpr is valid: add newly created TypoExprs since we were
+        // able to correct them.
+        Res = RecurResult;
+        SavedTypoExprs.set_union(TypoExprs);
+      }
+    }
+
+    TypoExprs = std::move(SavedTypoExprs);
+    AmbiguousTypoExprs = std::move(SavedAmbiguousTypoExprs);
+
+    return Res;
+  }
+
+  // Try to transform the given expression, looping through the correction
+  // candidates with `CheckAndAdvanceTypoExprCorrectionStreams`.
+  //
+  // If valid ambiguous typo corrections are seen, `IsAmbiguous` is set to
+  // true and this method immediately will return an `ExprError`.
+  ExprResult RecursiveTransformLoop(Expr *E, bool &IsAmbiguous) {
+    ExprResult Res;
+    while (true) {
+      Res = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous);
+
+      // Recursion encountered an ambiguous correction. This means that our
+      // correction itself is ambiguous, so stop now.
+      if (IsAmbiguous)
+        break;
+
+      // If the transform is still valid after checking for any new typos,
+      // it's good to go.
+      if (!Res.isInvalid())
+        break;
+
+      // The transform was invalid, see if we have any TypoExprs with untried
+      // correction candidates.
+      if (!CheckAndAdvanceTypoExprCorrectionStreams())
+        break;
+    }
+
+    // If we found a valid result, double check to make sure it's not ambiguous.
+    if (!IsAmbiguous && !Res.isInvalid() && !AmbiguousTypoExprs.empty()) {
+      auto SavedTransformCache = std::move(TransformCache);
+      TransformCache.clear();
+      // Ensure none of the TypoExprs have multiple typo correction candidates
+      // with the same edit length that pass all the checks and filters.
+
+      while (!AmbiguousTypoExprs.empty()) {
+        auto TE  = AmbiguousTypoExprs.back();
+
+        // TryTransform itself can create new Typos, adding them to the TypoExpr map
+        // and invalidating our TypoExprState, so always fetch it instead of storing.
+        SemaRef.getTypoExprState(TE).Consumer->saveCurrentPosition();
+
+        TypoCorrection TC = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection();
+        TypoCorrection Next;
+        do {
+          ExprResult AmbigRes = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous);
 
-    return ExprFilter(Res.get());
+          if (!AmbigRes.isInvalid() || IsAmbiguous) {
+            SemaRef.getTypoExprState(TE).Consumer->resetCorrectionStream();
+            SavedTransformCache.erase(TE);
+            Res = ExprError();
+            IsAmbiguous = true;
+            break;
+          }
+        } while ((Next = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection()) &&
+                 Next.getEditDistance(false) == TC.getEditDistance(false));
+
+        if (IsAmbiguous)
+          break;
+
+        AmbiguousTypoExprs.remove(TE);
+        SemaRef.getTypoExprState(TE).Consumer->restoreSavedPosition();
+      }
+      TransformCache = std::move(SavedTransformCache);
+    }
+    return Res;
   }
 
 public:
   TransformTypos(Sema &SemaRef, VarDecl *InitDecl, llvm::function_ref<ExprResult(Expr *)> Filter)
       : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {}
 
   ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
                                    MultiExprArg Args,
                                    SourceLocation RParenLoc,
                                    Expr *ExecConfig = nullptr) {
     auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
                                                  RParenLoc, ExecConfig);
     if (auto *OE = dyn_cast<OverloadExpr>(Callee)) {
       if (Result.isUsable()) {
         Expr *ResultCall = Result.get();
         if (auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
           ResultCall = BE->getSubExpr();
         if (auto *CE = dyn_cast<CallExpr>(ResultCall))
           OverloadResolution[OE] = CE->getCallee();
       }
     }
     return Result;
   }
 
   ExprResult TransformLambdaExpr(LambdaExpr *E) { return Owned(E); }
 
   ExprResult TransformBlockExpr(BlockExpr *E) { return Owned(E); }
 
   ExprResult Transform(Expr *E) {
-    ExprResult Res;
-    while (true) {
-      Res = TryTransform(E);
-
-      // Exit if either the transform was valid or if there were no TypoExprs
-      // to transform that still have any untried correction candidates..
-      if (!Res.isInvalid() ||
-          !CheckAndAdvanceTypoExprCorrectionStreams())
-        break;
-    }
-
-    // Ensure none of the TypoExprs have multiple typo correction candidates
-    // with the same edit length that pass all the checks and filters.
-    // TODO: Properly handle various permutations of possible corrections when
-    // there is more than one potentially ambiguous typo correction.
-    // Also, disable typo correction while attempting the transform when
-    // handling potentially ambiguous typo corrections as any new TypoExprs will
-    // have been introduced by the application of one of the correction
-    // candidates and add little to no value if corrected.
-    SemaRef.DisableTypoCorrection = true;
-    while (!AmbiguousTypoExprs.empty()) {
-      auto TE  = AmbiguousTypoExprs.back();
-      auto Cached = TransformCache[TE];
-      auto &State = SemaRef.getTypoExprState(TE);
-      State.Consumer->saveCurrentPosition();
-      TransformCache.erase(TE);
-      if (!TryTransform(E).isInvalid()) {
-        State.Consumer->resetCorrectionStream();
-        TransformCache.erase(TE);
-        Res = ExprError();
-        break;
-      }
-      AmbiguousTypoExprs.remove(TE);
-      State.Consumer->restoreSavedPosition();
-      TransformCache[TE] = Cached;
-    }
-    SemaRef.DisableTypoCorrection = false;
+    bool IsAmbiguous = false;
+    ExprResult Res = RecursiveTransformLoop(E, IsAmbiguous);
 
-    // Ensure that all of the TypoExprs within the current Expr have been found.
     if (!Res.isUsable())
       FindTypoExprs(TypoExprs).TraverseStmt(E);
 
-    EmitAllDiagnostics();
+    EmitAllDiagnostics(IsAmbiguous);
 
     return Res;
   }
 
   ExprResult TransformTypoExpr(TypoExpr *E) {
     // If the TypoExpr hasn't been seen before, record it. Otherwise, return the
     // cached transformation result if there is one and the TypoExpr isn't the
     // first one that was encountered.
     auto &CacheEntry = TransformCache[E];
     if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
       return CacheEntry;
     }
 
     auto &State = SemaRef.getTypoExprState(E);
     assert(State.Consumer && "Cannot transform a cleared TypoExpr");
 
while (TypoCorrection TC = State.Consumer->getNextCorrection()) {
         TypoCorrection Next;
         if ((Next = State.Consumer->peekNextCorrection()) &&
             Next.getEditDistance(false) == TC.getEditDistance(false)) {
           AmbiguousTypoExprs.insert(E);
         } else {
           AmbiguousTypoExprs.remove(E);
         }
         assert(!NE.isUnset() &&
                "Typo was transformed into a valid-but-null ExprResult");
         return CacheEntry = NE;
       }
     }
     return CacheEntry = ExprError();
   }
 };
 }
 
 ExprResult
 Sema::CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl,
                                 llvm::function_ref<ExprResult(Expr *)> Filter) {
   // If the current evaluation context indicates there are uncorrected typos
   // and the current expression isn't guaranteed to not have typos, try to
   // resolve any TypoExpr nodes that might be in the expression.
   if (E && !ExprEvalContexts.empty() && ExprEvalContexts.back().NumTypos &&
       (E->isTypeDependent() || E->isValueDependent() ||
        E->isInstantiationDependent())) {
     auto TyposResolved = DelayedTypos.size();
     auto Result = TransformTypos(*this, InitDecl, Filter).Transform(E);
     TyposResolved -= DelayedTypos.size();
     if (Result.isInvalid() || Result.get() != E) {
       ExprEvalContexts.back().NumTypos -= TyposResolved;
       return Result;
     }
     assert(TyposResolved == 0 && "Corrected typo but got same Expr back?");
   }
   return E;
 }
 
 ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC,
                                      bool DiscardedValue,
                                      bool IsConstexpr) {
   ExprResult FullExpr = FE;
 
   if (!FullExpr.get())
     return ExprError();
 
   if (DiagnoseUnexpandedParameterPack(FullExpr.get()))

lib/Sema/TreeTransform.h

 protected:
   Sema &SemaRef;
 
   /// The set of local declarations that have been transformed, for
   /// cases where we are forced to build new declarations within the transformer
   /// rather than in the subclass (e.g., lambda closure types).
   llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;
 
+  /// Holds TypoExprs that are created during the transform. `TransformExpr`
+  /// and `TryTransform` will check for changes to this set and delete any
+  /// TypoExprs created from a failed transform. Otherwise, it is possible
+  /// that TypoExprs are created but are not reachable from the returned
+  /// ExprResult, meaning we will never correct the typos.
+  llvm::SmallSetVector<TypoExpr *, 2> TypoExprs;
+
+  /// Transform the given expression.
+  ///
+  /// By default, this routine transforms an expression by delegating to the
+  /// appropriate TransformXXXExpr function to build a new expression.
+  /// Subclasses may override this function to transform expressions using some
+  /// other mechanism.
+  ///
+  /// This method should does not handle clearing any TypoExprs and therefore
+  /// should not be called directly. Use `TransformExpr` instead.
+  ///
+  /// \returns the transformed expression.
+  ExprResult TransformExprWrapped(Expr *E);
+
 public:
   /// Initializes a new tree transformer.
   TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
 
   /// Retrieves a reference to the derived class.
   Derived &getDerived() { return static_cast<Derived&>(*this); }
 
   /// Retrieves a reference to the derived class.

 /// spelling to transform expressions stored within the attribute.
 ///
 /// \returns the transformed attribute.
 #define ATTR(X)
 #define PRAGMA_SPELLING_ATTR(X)                                                \
   const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
 #include "clang/Basic/AttrList.inc"
 
+  /// Try to transform the given expression, catching any traps. After
+  /// successfully applying the transformation, apply the filter.
+  ///
+  /// Any TypoExprs created during an invalid transformation will automatically
+  /// be cleared.
+  ExprResult TryTransformExpr(Expr *E,
+                              llvm::function_ref<ExprResult(Expr *)> Filter);
+
   /// Transform the given expression.
   ///
   /// By default, this routine transforms an expression by delegating to the
   /// appropriate TransformXXXExpr function to build a new expression.
   /// Subclasses may override this function to transform expressions using some
   /// other mechanism.
   ///
+  /// This method should also handle clearing any TypoExprs that are created
+  /// from an invalid transformation (see `TypoExprs`).
+  ///
   /// \returns the transformed expression.
   ExprResult TransformExpr(Expr *E);
 
   /// Transform the given initializer.
   ///
   /// By default, this routine transforms an initializer by stripping off the
   /// semantic nodes added by initialization, then passing the result to
   /// TransformExpr or TransformExprs.
#define OPENMP_CLAUSE(Name, Class)                                             \
   case OMPC_ ## Name :                                                         \
     return getDerived().Transform ## Class(cast<Class>(S));
 #include "clang/Basic/OpenMPKinds.def"
   }
 
   return S;
 }
 
-
 template<typename Derived>
-ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
+ExprResult TreeTransform<Derived>::TransformExprWrapped(Expr *E) {
   if (!E)
     return E;
 
   switch (E->getStmtClass()) {
     case Stmt::NoStmtClass: break;
 #define STMT(Node, Parent) case Stmt::Node##Class: break;
 #define ABSTRACT_STMT(Stmt)
 #define EXPR(Node, Parent)                                              \
     case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
 #include "clang/AST/StmtNodes.inc"
   }
 
   return E;
 }
 
 template<typename Derived>
+ExprResult TreeTransform<Derived>::TryTransformExpr(Expr *E,
+                              llvm::function_ref<ExprResult(Expr *)> Filter) {
+  Sema::SFINAETrap Trap(SemaRef);
+
+  auto StartSize = TypoExprs.size();
+  ExprResult Res = getDerived().TransformExpr(E);
+  if (Trap.hasErrorOccurred() || Res.isInvalid())
+    Res = ExprError();
+  else
+    Res = Filter(Res.get());
+
+  // Check if the final result is invalid; if so, clear any TypoExprs that have
+  // been created recursively.
+  //
+  // Note that there's no check for a `TypoExpr`
+  // result here as `TransformExpr` should have handled that case assuming our
+  // filter doesn't do anything wonky (return a different `Expr`).
+  //
+  // This is needed in addition to the checks in `TransformExpr` since an error
+  // may have occurred or the filter might have returned an invalid result.
+  if (Res.isInvalid()) {
+    for (auto Iterator = TypoExprs.begin() + StartSize;
+         Iterator != TypoExprs.end();) {
+      SemaRef.clearDelayedTypo(*Iterator);
+      Iterator = TypoExprs.erase(Iterator);
+    }
+  }
+
+  return Res;
+}
+
+template<typename Derived>
+ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
+  if (!E)
+    return E;
+
+  auto StartSize = TypoExprs.size();
+  ExprResult Res = getDerived().TransformExprWrapped(E);
+
+  // If the transformed Expr is valid, check if it's a TypoExpr so we can keep
+  // track of them. Otherwise, if the transform result is invalid, clear any
+  // TypoExprs that might have been created recursively (TODO: verify that
+  // this can happen in practice here instead of via an error trap).
+  if (Res.isUsable()) {
+    Expr *TransformedExpr = Res.get();
+    if (TypoExpr::classof(TransformedExpr)) {
+      TypoExprs.insert(reinterpret_cast<TypoExpr *>(TransformedExpr));
+    }
+  } else {
+    for (auto Iterator = TypoExprs.begin() + StartSize;
+         Iterator != TypoExprs.end();) {
+      SemaRef.clearDelayedTypo(*Iterator);
+      Iterator = TypoExprs.erase(Iterator);
+    }
+  }
+
+  return Res;
+}
+
+template<typename Derived>
 ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
                                                         bool NotCopyInit) {
   // Initializers are instantiated like expressions, except that various outer
   // layers are stripped.
   if (!Init)
     return Init;
 
   if (auto *FE = dyn_cast<FullExpr>(Init))

test/Sema/typo-correction-recursive.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Check the following typo correction behavior:
+// - multiple typos in a single member call chain are all diagnosed
+// - no typos are diagnosed for multiple typos in an expression when not all
+//   typos can be corrected
+
+class DeepClass
+{
+public:
+  void trigger() const;  // expected-note {{'trigger' declared here}}
+};
+
+class Y
+{
+public:
+  const DeepClass& getX() const { return m_deepInstance; }  // expected-note {{'getX' declared here}}
+private:
+  DeepClass m_deepInstance;
+  int m_n;
+};
+
+class Z
+{
+public:
+  const Y& getY0() const { return m_y0; }  // expected-note {{'getY0' declared here}}
+  const Y& getActiveY() const { return m_y0; }
+
+private:
+  Y m_y0;
+  Y m_y1;
+};
+
+Z z_obj;
+
+void testMultipleCorrections()
+{
+  z_obj.getY2().  // expected-error {{no member named 'getY2' in 'Z'; did you mean 'getY0'}}
+      getM().     // expected-error {{no member named 'getM' in 'Y'; did you mean 'getX'}}
+      triggee();  // expected-error {{no member named 'triggee' in 'DeepClass'; did you mean 'trigger'}}
+}
+
+void testNoCorrections()
+{
+  z_obj.getY2().  // expected-error {{no member named 'getY2' in 'Z'}}
+      getM().
+      thisDoesntSeemToMakeSense();
+}
+
+struct C {};
+struct D { int value; };
+struct A {
+  C get_me_a_C();
+};
+struct B {
+  D get_me_a_D();  // expected-note {{'get_me_a_D' declared here}}
+};
+class Scope {
+public:
+  A make_an_A();
+  B make_a_B();  // expected-note {{'make_a_B' declared here}}
+};
+
+Scope scope_obj;
+
+int testDiscardedCorrections() {
+  return scope_obj.make_an_E().  // expected-error {{no member named 'make_an_E' in 'Scope'; did you mean 'make_a_B'}}
+      get_me_a_Z().value;        // expected-error {{no member named 'get_me_a_Z' in 'B'; did you mean 'get_me_a_D'}}
+}
+
+class AmbiguousHelper {
+public:
+  int helpMe();
+  int helpBe();
+};
+class Ambiguous {
+public:
+  int calculateA();
+  int calculateB();
+
+  AmbiguousHelper getHelp1();
+  AmbiguousHelper getHelp2();
+};
+
+Ambiguous ambiguous_obj;
+
+int testDirectAmbiguousCorrection() {
+  return ambiguous_obj.calculateZ();  // expected-error {{no member named 'calculateZ' in 'Ambiguous'}}
+}
+
+int testRecursiveAmbiguousCorrection() {
+  return ambiguous_obj.getHelp3().    // expected-error {{no member named 'getHelp3' in 'Ambiguous'}}
+      helpCe();
+}
+
+
+class DeepAmbiguityHelper {
+public:
+  DeepAmbiguityHelper& help1();
+  DeepAmbiguityHelper& help2();
+
+  DeepAmbiguityHelper& methodA();
+  DeepAmbiguityHelper& somethingMethodB();
+  DeepAmbiguityHelper& functionC();
+  DeepAmbiguityHelper& deepMethodD();
+  DeepAmbiguityHelper& asDeepAsItGets();
+};
+
+DeepAmbiguityHelper deep_obj;
+
+int testDeepAmbiguity() {
+  deep_obj.
+      methodB(). // expected-error {{no member named 'methodB' in 'DeepAmbiguityHelper'}}
+      somethingMethodC().
+      functionD().
+      deepMethodD().
+      help3().
+      asDeepASItGet().
+      functionE();
+}