[AST] Flag the typo-corrected nodes for better tooling

[arphaman]

Summary

This patch adds a new boolean field to the DeclRefExpr, MemberExpr, CXXCtorInitializer, ObjCIvarRefExpr, ObjCPropertyRefExpr nodes which is set to true when these nodes have been produced during typo-correction.

This is useful for Clang-based tooling as it can distinguish between true references and the typo-corrected references. The initial tooling support uses the flag to prevent token annotation for typo-corrected references and to prevent finding typo-corrected references during single TU reference search.

[arphaman]

ping

[ilya-biryukov]

Sorry, not familiar enough with the AST bits yet to LGTM this.

Looks good from a higher-level perspective, though.
It's a bit of a shame that's it is still super-easy to write code that does not account for typo-corrected nodes. A more explicit approach, similar to non-canonical and sugared Types, would probably be nicer, but getting there seems to be hard and may not be worth the effort.

[ahatanak]

Could you rebase this patch against ToT?

Also, it's not clear to me why only four Exprs (DeclRefExpr, MemberExpr, ObjCIvarRefExpr, and ObjCPropertyRefExpr) should have the IsTypoCorrected flag. Can you elaborate on how you chose that set of Exprs and whether you plan to add the flag to other Exprs?

include/clang/AST/DeclCXX.h

class CXXCtorInitializer final {
   /// \brief Whether or not the initializer is explicitly written
   /// in the sources.
   unsigned IsWritten : 1;
 
   /// If IsWritten is true, then this number keeps track of the textual order
   /// of this initializer in the original sources, counting from 0.
   unsigned SourceOrder : 13;
 
+  /// Whether this initializer was typo-corrected.
+  unsigned IsTypoCorrected : 1;
+
 public:
   /// \brief Creates a new base-class initializer.
   explicit
   CXXCtorInitializer(ASTContext &Context, TypeSourceInfo *TInfo, bool IsVirtual,
                      SourceLocation L, Expr *Init, SourceLocation R,
                      SourceLocation EllipsisLoc);
 
   /// \brief Creates a new member initializer.
void setSourceOrder(int Pos) {
     SourceOrder = static_cast<unsigned>(Pos);
   }
 
   SourceLocation getLParenLoc() const { return LParenLoc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
 
   /// \brief Get the initializer.
   Expr *getInit() const { return static_cast<Expr*>(Init); }
+
+  /// True iff the initializer was constructed during typo-correction.
+  bool isTypoCorrected() const { return IsTypoCorrected; }
+
+  void setIsTypoCorrected(bool V = true) { IsTypoCorrected = V; }
 };
 
 /// Description of a constructor that was inherited from a base class.
 class InheritedConstructor {
   ConstructorUsingShadowDecl *Shadow;
   CXXConstructorDecl *BaseCtor;
 
 public:

include/clang/AST/Expr.h

const Expr *skipRValueSubobjectAdjustments(
       SmallVectorImpl<const Expr *> &CommaLHS,
       SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
   const Expr *skipRValueSubobjectAdjustments() const {
     SmallVector<const Expr *, 8> CommaLHSs;
     SmallVector<SubobjectAdjustment, 8> Adjustments;
     return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
   }
 
+  /// True iff the expression was constructed during typo-correction.
+  bool isTypoCorrected() const;
+
+  void setIsTypoCorrected(bool V = true);
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() >= firstExprConstant &&
            T->getStmtClass() <= lastExprConstant;
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Primary Expressions.
DeclRefExpr(ValueDecl *D, bool RefersToEnclosingVariableOrCapture, QualType T,
     : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
       D(D), Loc(L), DNLoc(LocInfo) {
     DeclRefExprBits.HasQualifier = 0;
     DeclRefExprBits.HasTemplateKWAndArgsInfo = 0;
     DeclRefExprBits.HasFoundDecl = 0;
     DeclRefExprBits.HadMultipleCandidates = 0;
     DeclRefExprBits.RefersToEnclosingVariableOrCapture =
         RefersToEnclosingVariableOrCapture;
+    DeclRefExprBits.IsTypoCorrected = 0;
     computeDependence(D->getASTContext());
   }
 
   static DeclRefExpr *
   Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
          SourceLocation TemplateKWLoc, ValueDecl *D,
          bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc,
          QualType T, ExprValueKind VK, NamedDecl *FoundD = nullptr,
public:
   }
 
   /// \brief Does this DeclRefExpr refer to an enclosing local or a captured
   /// variable?
   bool refersToEnclosingVariableOrCapture() const {
     return DeclRefExprBits.RefersToEnclosingVariableOrCapture;
   }
 
+  /// True iff the expression was constructed during typo-correction.
+  bool isTypoCorrected() const { return DeclRefExprBits.IsTypoCorrected; }
+
+  void setIsTypoCorrected(bool V = true) {
+    DeclRefExprBits.IsTypoCorrected = V;
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == DeclRefExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc,
       : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(),
              base->isValueDependent(), base->isInstantiationDependent(),
              base->containsUnexpandedParameterPack()),
         Base(base), MemberDecl(memberdecl), MemberDNLoc(NameInfo.getInfo()),
         MemberLoc(NameInfo.getLoc()), OperatorLoc(operatorloc),
         IsArrow(isarrow), HasQualifierOrFoundDecl(false),
         HasTemplateKWAndArgsInfo(false), HadMultipleCandidates(false) {
     assert(memberdecl->getDeclName() == NameInfo.getName());
+    MemberExprBits.IsTypoCorrected = 0;
   }
 
   // NOTE: this constructor should be used only when it is known that
   // the member name can not provide additional syntactic info
   // (i.e., source locations for C++ operator names or type source info
   // for constructors, destructors and conversion operators).
   MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc,
              ValueDecl *memberdecl, SourceLocation l, QualType ty,
              ExprValueKind VK, ExprObjectKind OK)
       : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(),
              base->isValueDependent(), base->isInstantiationDependent(),
              base->containsUnexpandedParameterPack()),
         Base(base), MemberDecl(memberdecl), MemberDNLoc(), MemberLoc(l),
         OperatorLoc(operatorloc), IsArrow(isarrow),
         HasQualifierOrFoundDecl(false), HasTemplateKWAndArgsInfo(false),
-        HadMultipleCandidates(false) {}
+        HadMultipleCandidates(false) {
+    MemberExprBits.IsTypoCorrected = 0;
+  }
 
   static MemberExpr *Create(const ASTContext &C, Expr *base, bool isarrow,
                             SourceLocation OperatorLoc,
                             NestedNameSpecifierLoc QualifierLoc,
                             SourceLocation TemplateKWLoc, ValueDecl *memberdecl,
                             DeclAccessPair founddecl,
                             DeclarationNameInfo MemberNameInfo,
                             const TemplateArgumentListInfo *targs, QualType ty,
public:
   /// \brief Returns true if virtual dispatch is performed.
   /// If the member access is fully qualified, (i.e. X::f()), virtual
   /// dispatching is not performed. In -fapple-kext mode qualified
   /// calls to virtual method will still go through the vtable.
   bool performsVirtualDispatch(const LangOptions &LO) const {
     return LO.AppleKext || !hasQualifier();
   }
 
+  /// True iff the expression was constructed during typo-correction.
+  bool isTypoCorrected() const { return MemberExprBits.IsTypoCorrected; }
+
+  void setIsTypoCorrected(bool V = true) { MemberExprBits.IsTypoCorrected = V; }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MemberExprClass;
   }
 
   // Iterators
   child_range children() { return child_range(&Base, &Base+1); }
   const_child_range children() const {
     return const_child_range(&Base, &Base + 1);

include/clang/AST/ExprObjC.h

class ObjCIvarRefExpr : public Expr {
   SourceLocation Loc;
   /// OpLoc - This is the location of '.' or '->'
   SourceLocation OpLoc;
   
   bool IsArrow:1;      // True if this is "X->F", false if this is "X.F".
   bool IsFreeIvar:1;   // True if ivar reference has no base (self assumed).
 
 public:
-  ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t,
-                  SourceLocation l, SourceLocation oploc,
-                  Expr *base,
-                  bool arrow = false, bool freeIvar = false) :
-    Expr(ObjCIvarRefExprClass, t, VK_LValue,
+  ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, SourceLocation l,
+                  SourceLocation oploc, Expr *base, bool arrow = false,
+                  bool freeIvar = false)
+      : Expr(ObjCIvarRefExprClass, t, VK_LValue,
              d->isBitField() ? OK_BitField : OK_Ordinary,
-         /*TypeDependent=*/false, base->isValueDependent(), 
+             /*TypeDependent=*/false, base->isValueDependent(),
              base->isInstantiationDependent(),
-         base->containsUnexpandedParameterPack()), 
-    D(d), Base(base), Loc(l), OpLoc(oploc),
-    IsArrow(arrow), IsFreeIvar(freeIvar) {}
+             base->containsUnexpandedParameterPack()),
+        D(d), Base(base), Loc(l), OpLoc(oploc), IsArrow(arrow),
+        IsFreeIvar(freeIvar) {
+    ObjCIvarRefExprBits.IsTypoCorrected = 0;
+  }
 
   explicit ObjCIvarRefExpr(EmptyShell Empty)
-    : Expr(ObjCIvarRefExprClass, Empty) {}
+      : Expr(ObjCIvarRefExprClass, Empty) {
+    ObjCIvarRefExprBits.IsTypoCorrected = 0;
+  }
 
   ObjCIvarDecl *getDecl() { return D; }
   const ObjCIvarDecl *getDecl() const { return D; }
   void setDecl(ObjCIvarDecl *d) { D = d; }
 
   const Expr *getBase() const { return cast<Expr>(Base); }
   Expr *getBase() { return cast<Expr>(Base); }
   void setBase(Expr * base) { Base = base; }
public:
   SourceLocation getLocStart() const LLVM_READONLY {
     return isFreeIvar() ? Loc : getBase()->getLocStart();
   }
   SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
   
   SourceLocation getOpLoc() const { return OpLoc; }
   void setOpLoc(SourceLocation L) { OpLoc = L; }
 
+  /// True iff the expression was constructed during typo-correction.
+  bool isTypoCorrected() const { return ObjCIvarRefExprBits.IsTypoCorrected; }
+
+  void setIsTypoCorrected(bool V = true) {
+    ObjCIvarRefExprBits.IsTypoCorrected = V;
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCIvarRefExprClass;
   }
 
   // Iterators
   child_range children() { return child_range(&Base, &Base+1); }
 };
 
ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t,
                       SourceLocation l, Expr *base)
     : Expr(ObjCPropertyRefExprClass, t, VK, OK,
            /*TypeDependent=*/false, base->isValueDependent(),
            base->isInstantiationDependent(),
            base->containsUnexpandedParameterPack()),
       PropertyOrGetter(PD, false), SetterAndMethodRefFlags(),
       IdLoc(l), ReceiverLoc(), Receiver(base) {
     assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
+    ObjCPropertyRefExprBits.IsTypoCorrected = 0;
   }
   
   ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t,
                       ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation l, SourceLocation sl, QualType st)
     : Expr(ObjCPropertyRefExprClass, t, VK, OK,
            /*TypeDependent=*/false, false, st->isInstantiationDependentType(),
            st->containsUnexpandedParameterPack()),
       PropertyOrGetter(PD, false), SetterAndMethodRefFlags(),
       IdLoc(l), ReceiverLoc(sl), Receiver(st.getTypePtr()) {
     assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
+    ObjCPropertyRefExprBits.IsTypoCorrected = 0;
   }
 
   ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
                       QualType T, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation IdLoc, Expr *Base)
     : Expr(ObjCPropertyRefExprClass, T, VK, OK, false,
            Base->isValueDependent(), Base->isInstantiationDependent(),
            Base->containsUnexpandedParameterPack()),
       PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
       IdLoc(IdLoc), ReceiverLoc(), Receiver(Base) {
     assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
+    ObjCPropertyRefExprBits.IsTypoCorrected = 0;
   }
 
   ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
                       QualType T, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation IdLoc,
                       SourceLocation SuperLoc, QualType SuperTy)
     : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),
       PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
       IdLoc(IdLoc), ReceiverLoc(SuperLoc), Receiver(SuperTy.getTypePtr()) {
     assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
+    ObjCPropertyRefExprBits.IsTypoCorrected = 0;
   }
 
   ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
                       QualType T, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation IdLoc,
                       SourceLocation ReceiverLoc, ObjCInterfaceDecl *Receiver)
     : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),
       PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
       IdLoc(IdLoc), ReceiverLoc(ReceiverLoc), Receiver(Receiver) {
     assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
+    ObjCPropertyRefExprBits.IsTypoCorrected = 0;
   }
 
   explicit ObjCPropertyRefExpr(EmptyShell Empty)
-    : Expr(ObjCPropertyRefExprClass, Empty) {}
+      : Expr(ObjCPropertyRefExprClass, Empty) {
+    ObjCPropertyRefExprBits.IsTypoCorrected = 0;
+  }
 
   bool isImplicitProperty() const { return PropertyOrGetter.getInt(); }
   bool isExplicitProperty() const { return !PropertyOrGetter.getInt(); }
 
   ObjCPropertyDecl *getExplicitProperty() const {
     assert(!isImplicitProperty());
     return cast<ObjCPropertyDecl>(PropertyOrGetter.getPointer());
   }
public:
   /// Determine the type of the base, regardless of the kind of receiver.
   QualType getReceiverType(const ASTContext &ctx) const;
 
   SourceLocation getLocStart() const LLVM_READONLY {
     return isObjectReceiver() ? getBase()->getLocStart() :getReceiverLocation();
   }
   SourceLocation getLocEnd() const LLVM_READONLY { return IdLoc; }
 
+  /// True iff the expression was constructed during typo-correction.
+  bool isTypoCorrected() const {
+    return ObjCPropertyRefExprBits.IsTypoCorrected;
+  }
+
+  void setIsTypoCorrected(bool V = true) {
+    ObjCPropertyRefExprBits.IsTypoCorrected = V;
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCPropertyRefExprClass;
   }
 
   // Iterators
   child_range children() {
     if (Receiver.is<Stmt*>()) {
       Stmt **begin = reinterpret_cast<Stmt**>(&Receiver); // hack!

include/clang/AST/Stmt.h

class DeclRefExprBitfields {
     friend class ASTStmtReader; // deserialization
     unsigned : NumExprBits;
 
     unsigned HasQualifier : 1;
     unsigned HasTemplateKWAndArgsInfo : 1;
     unsigned HasFoundDecl : 1;
     unsigned HadMultipleCandidates : 1;
     unsigned RefersToEnclosingVariableOrCapture : 1;
+    unsigned IsTypoCorrected : 1;
+  };
+
+  class MemberExprBitfields {
+    friend class MemberExpr;
+    friend class ASTStmtReader;
+    unsigned : NumExprBits;
+
+    unsigned IsTypoCorrected : 1;
+  };
+
+  class ObjCIvarRefExprBitfields {
+    friend class ObjCIvarRefExpr;
+    friend class ASTStmtReader;
+    unsigned : NumExprBits;
+
+    unsigned IsTypoCorrected : 1;
+  };
+
+  class ObjCPropertyRefExprBitfields {
+    friend class ObjCPropertyRefExpr;
+    friend class ASTStmtReader;
+    unsigned : NumExprBits;
+
+    unsigned IsTypoCorrected : 1;
   };
 
   class CastExprBitfields {
     friend class CastExpr;
     unsigned : NumExprBits;
 
     unsigned Kind : 6;
     unsigned BasePathSize : 32 - 6 - NumExprBits;
union {
     StmtBitfields StmtBits;
     CompoundStmtBitfields CompoundStmtBits;
     IfStmtBitfields IfStmtBits;
     ExprBitfields ExprBits;
     CharacterLiteralBitfields CharacterLiteralBits;
     FloatingLiteralBitfields FloatingLiteralBits;
     UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits;
     DeclRefExprBitfields DeclRefExprBits;
+    MemberExprBitfields MemberExprBits;
+    ObjCIvarRefExprBitfields ObjCIvarRefExprBits;
+    ObjCPropertyRefExprBitfields ObjCPropertyRefExprBits;
     CastExprBitfields CastExprBits;
     CallExprBitfields CallExprBits;
     ExprWithCleanupsBitfields ExprWithCleanupsBits;
     PseudoObjectExprBitfields PseudoObjectExprBits;
     ObjCIndirectCopyRestoreExprBitfields ObjCIndirectCopyRestoreExprBits;
     InitListExprBitfields InitListExprBits;
     TypeTraitExprBitfields TypeTraitExprBits;
     CoawaitExprBitfields CoawaitBits;

lib/AST/DeclCXX.cpp

bool CXXMethodDecl::isLambdaStaticInvoker() const {
   return false;
 }
 
 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
                                        TypeSourceInfo *TInfo, bool IsVirtual,
                                        SourceLocation L, Expr *Init,
                                        SourceLocation R,
                                        SourceLocation EllipsisLoc)
-  : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init), 
-    LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual), 
-    IsWritten(false), SourceOrder(0)
-{
-}
+    : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init),
+      LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual),
+      IsWritten(false), SourceOrder(0), IsTypoCorrected(false) {}
 
-CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
-                                       FieldDecl *Member,
+CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, FieldDecl *Member,
                                        SourceLocation MemberLoc,
                                        SourceLocation L, Expr *Init,
                                        SourceLocation R)
     : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
       LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
-    IsWritten(false), SourceOrder(0)
-{
-}
+      IsWritten(false), SourceOrder(0), IsTypoCorrected(false) {}
 
 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
                                        IndirectFieldDecl *Member,
                                        SourceLocation MemberLoc,
                                        SourceLocation L, Expr *Init,
                                        SourceLocation R)
     : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
       LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
-    IsWritten(false), SourceOrder(0)
-{
-}
+      IsWritten(false), SourceOrder(0), IsTypoCorrected(false) {}
 
 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
-                                       TypeSourceInfo *TInfo,
-                                       SourceLocation L, Expr *Init, 
-                                       SourceLocation R)
-  : Initializee(TInfo), MemberOrEllipsisLocation(), Init(Init),
-    LParenLoc(L), RParenLoc(R), IsDelegating(true), IsVirtual(false),
-    IsWritten(false), SourceOrder(0)
-{
-}
+                                       TypeSourceInfo *TInfo, SourceLocation L,
+                                       Expr *Init, SourceLocation R)
+    : Initializee(TInfo), MemberOrEllipsisLocation(), Init(Init), LParenLoc(L),
+      RParenLoc(R), IsDelegating(true), IsVirtual(false), IsWritten(false),
+      SourceOrder(0), IsTypoCorrected(false) {}
 
 TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
   if (isBaseInitializer())
     return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
   else
     return TypeLoc();
 }
 

lib/AST/Expr.cpp

#define STMT(type, base) \
   case Stmt::type##Class: break;
 #define EXPR(type, base) \
   case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
 #include "clang/AST/StmtNodes.inc"
   }
   llvm_unreachable("unknown expression kind");
 }
 
+bool Expr::isTypoCorrected() const {
+  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(this))
+    return DRE->isTypoCorrected();
+  if (const auto *ME = dyn_cast<MemberExpr>(this))
+    return ME->isTypoCorrected();
+  if (const auto *IVar = dyn_cast<ObjCIvarRefExpr>(this))
+    return IVar->isTypoCorrected();
+  if (const auto *PRef = dyn_cast<ObjCPropertyRefExpr>(this))
+    return PRef->isTypoCorrected();
+  return false;
+}
+
+void Expr::setIsTypoCorrected(bool V) {
+  if (auto *DRE = dyn_cast<DeclRefExpr>(this))
+    DRE->setIsTypoCorrected(V);
+  else if (auto *ME = dyn_cast<MemberExpr>(this))
+    ME->setIsTypoCorrected(V);
+  else if (auto *IVar = dyn_cast<ObjCIvarRefExpr>(this))
+    IVar->setIsTypoCorrected(V);
+  else if (auto *PRef = dyn_cast<ObjCPropertyRefExpr>(this))
+    PRef->setIsTypoCorrected(V);
+}
+
 //===----------------------------------------------------------------------===//
 // Primary Expressions.
 //===----------------------------------------------------------------------===//
 
 /// \brief Compute the type-, value-, and instantiation-dependence of a 
 /// declaration reference
 /// based on the declaration being referenced.
 static void computeDeclRefDependence(const ASTContext &Ctx, NamedDecl *D,
DeclRefExpr::DeclRefExpr(const ASTContext &Ctx,
   }
   DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
   if (FoundD)
     *getTrailingObjects<NamedDecl *>() = FoundD;
   DeclRefExprBits.HasTemplateKWAndArgsInfo
     = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;
   DeclRefExprBits.RefersToEnclosingVariableOrCapture =
       RefersToEnclosingVariableOrCapture;
+  DeclRefExprBits.IsTypoCorrected = 0;
   if (TemplateArgs) {
     bool Dependent = false;
     bool InstantiationDependent = false;
     bool ContainsUnexpandedParameterPack = false;
     getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
         TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
         Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);
     assert(!Dependent && "built a DeclRefExpr with dependent template args");

lib/Sema/SemaDecl.cpp

Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
   if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
     ExprResult E = LookupInObjCMethod(Result, S, Name, true);
     if (E.get() || E.isInvalid())
       return E;
   }
 
   bool SecondTry = false;
   bool IsFilteredTemplateName = false;
+  bool IsTypoCorrected = false;
 
 Corrected:
   switch (Result.getResultKind()) {
   case LookupResult::NotFound:
     // If an unqualified-id is followed by a '(', then we have a function
     // call.
     if (!SS.isSet() && NextToken.is(tok::l_paren)) {
       // In C++, this is an ADL-only call.
if (!SecondTry && CCC) {
 
         // If we found an Objective-C instance variable, let
         // LookupInObjCMethod build the appropriate expression to
         // reference the ivar.
         // FIXME: This is a gross hack.
         if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
           Result.clear();
           ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
+          if (E.isUsable())
+            E.get()->setIsTypoCorrected();
           return E;
         }
 
+        IsTypoCorrected = true;
         goto Corrected;
       }
     }
 
     // We failed to correct; just fall through and let the parser deal with it.
     Result.suppressDiagnostics();
     return NameClassification::Unknown();
 
if ((NextToken.is(tok::identifier) ||
     TypeDecl *Type = Result.getAsSingle<TypeDecl>();
     DiagnoseUseOfDecl(Type, NameLoc);
     QualType T = Context.getTypeDeclType(Type);
     if (SS.isNotEmpty())
       return buildNestedType(*this, SS, T, NameLoc);
     return ParsedType::make(T);
   }
 
-  if (FirstDecl->isCXXClassMember())
-    return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
-                                           nullptr, S);
+  if (FirstDecl->isCXXClassMember()) {
+    ExprResult ME = BuildPossibleImplicitMemberExpr(SS, SourceLocation(),
+                                                    Result, nullptr, S);
+    if (IsTypoCorrected && ME.isUsable())
+      ME.get()->setIsTypoCorrected();
+    return ME;
+  }
 
   bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
-  return BuildDeclarationNameExpr(SS, Result, ADL);
+  ExprResult DNE = BuildDeclarationNameExpr(SS, Result, ADL);
+  if (IsTypoCorrected && DNE.isUsable())
+    DNE.get()->setIsTypoCorrected();
+  return DNE;
 }
 
 Sema::TemplateNameKindForDiagnostics
 Sema::getTemplateNameKindForDiagnostics(TemplateName Name) {
   auto *TD = Name.getAsTemplateDecl();
   if (!TD)
     return TemplateNameKindForDiagnostics::DependentTemplate;
   if (isa<ClassTemplateDecl>(TD))

lib/Sema/SemaDeclCXX.cpp

if (!TyD) {
                CTK_ErrorRecovery, ClassDecl))) {
         if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
           // We have found a non-static data member with a similar
           // name to what was typed; complain and initialize that
           // member.
           diagnoseTypo(Corr,
                        PDiag(diag::err_mem_init_not_member_or_class_suggest)
                          << MemberOrBase << true);
-          return BuildMemberInitializer(Member, Init, IdLoc);
+          MemInitResult MI = BuildMemberInitializer(Member, Init, IdLoc);
+          if (MI.isUsable())
+            MI.get()->setIsTypoCorrected();
+          return MI;
         } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
           const CXXBaseSpecifier *DirectBaseSpec;
           const CXXBaseSpecifier *VirtualBaseSpec;
           if (FindBaseInitializer(*this, ClassDecl,
                                   Context.getTypeDeclType(Type),
                                   DirectBaseSpec, VirtualBaseSpec)) {
             // We have found a direct or virtual base class with a
             // similar name to what was typed; complain and initialize

lib/Sema/SemaExprCXX.cpp

if (ND->isCXXClassMember()) {
             NewSS, /*TemplateKWLoc*/ SourceLocation(), R,
             /*TemplateArgs*/ nullptr, /*S*/ nullptr);
     } else if (auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
       return SemaRef.LookupInObjCMethod(R, Consumer.getScope(),
                                         Ivar->getIdentifier());
     }
   }
 
-  return SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
-                                          /*AcceptInvalidDecl*/ true);
+  ExprResult Result =
+      SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
+  if (Result.isUsable())
+    Result.get()->setIsTypoCorrected();
+  return Result;
 }
 
 namespace {
 class FindTypoExprs : public RecursiveASTVisitor<FindTypoExprs> {
   llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs;
 
 public:
   explicit FindTypoExprs(llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs)

lib/Sema/SemaExprMember.cpp

TE = SemaRef.CorrectTypoDelayed(
       [=](Sema &SemaRef, TypoExpr *TE, TypoCorrection TC) mutable {
         LookupResult R(Q.SemaRef, Q.NameInfo, Q.LookupKind, Q.Redecl);
         R.clear(); // Ensure there's no decls lingering in the shared state.
         R.suppressDiagnostics();
         R.setLookupName(TC.getCorrection());
         for (NamedDecl *ND : TC)
           R.addDecl(ND);
         R.resolveKind();
-        return SemaRef.BuildMemberReferenceExpr(
+        ExprResult CorrectedME = SemaRef.BuildMemberReferenceExpr(
             BaseExpr, BaseExpr->getType(), OpLoc, IsArrow, SS, SourceLocation(),
             nullptr, R, nullptr, nullptr);
+        if (CorrectedME.isUsable())
+          CorrectedME.get()->setIsTypoCorrected();
+        return CorrectedME;
       },
       Sema::CTK_ErrorRecovery, DC);
 
   return false;
 }
 
 static ExprResult LookupMemberExpr(Sema &S, LookupResult &R,
                                    ExprResult &BaseExpr, bool &IsArrow,
if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
     if (S.RequireCompleteType(OpLoc, BaseType,
                               diag::err_typecheck_incomplete_tag,
                               BaseExpr.get()))
       return ExprError();
 
     ObjCInterfaceDecl *ClassDeclared = nullptr;
     ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
 
+    bool IsTypoCorrected = false;
     if (!IV) {
       // Attempt to correct for typos in ivar names.
       auto Validator = llvm::make_unique<DeclFilterCCC<ObjCIvarDecl>>();
       Validator->IsObjCIvarLookup = IsArrow;
       if (TypoCorrection Corrected = S.CorrectTypo(
               R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr,
               std::move(Validator), Sema::CTK_ErrorRecovery, IDecl)) {
         IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>();
         S.diagnoseTypo(
             Corrected,
             S.PDiag(diag::err_typecheck_member_reference_ivar_suggest)
                 << IDecl->getDeclName() << MemberName);
+        IsTypoCorrected = true;
 
         // Figure out the class that declares the ivar.
         assert(!ClassDeclared);
 
         Decl *D = cast<Decl>(IV->getDeclContext());
         if (auto *Category = dyn_cast<ObjCCategoryDecl>(D))
           D = Category->getClassInterface();
 
if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
     ObjCIvarRefExpr *Result = new (S.Context) ObjCIvarRefExpr(
         IV, IV->getUsageType(BaseType), MemberLoc, OpLoc, BaseExpr.get(),
         IsArrow);
 
     if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
       if (!S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc))
         S.recordUseOfEvaluatedWeak(Result);
     }
+    if (IsTypoCorrected)
+      Result->setIsTypoCorrected();
 
     return Result;
   }
 
   // Objective-C property access.
   const ObjCObjectPointerType *OPT;
   if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
     if (!SS.isEmpty() && !SS.isInvalid()) {

lib/Sema/SemaExprObjC.cpp

if (TypoResult.isIdentifier() &&
           << OPT->getInterfaceDecl()->getName()
           << FixItHint::CreateReplacement(BaseExpr->getSourceRange(),
                                           OPT->getInterfaceDecl()->getName());
           return ExprError();
         }
     } else {
       diagnoseTypo(Corrected, PDiag(diag::err_property_not_found_suggest)
                                 << MemberName << QualType(OPT, 0));
-      return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc,
-                                       TypoResult, MemberLoc,
-                                       SuperLoc, SuperType, Super);
+      ExprResult CorrectPRE =
+          HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc, TypoResult, MemberLoc,
+      if (CorrectPRE.isUsable())
+        CorrectPRE.get()->setIsTypoCorrected();
+      return CorrectPRE;
     }
   }
   ObjCInterfaceDecl *ClassDeclared;
   if (ObjCIvarDecl *Ivar = 
       IFace->lookupInstanceVariable(Member, ClassDeclared)) {
     QualType T = Ivar->getType();
     if (const ObjCObjectPointerType * OBJPT = 
         T->getAsObjCInterfacePointerType()) {

lib/Sema/SemaOverload.cpp

   else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
     NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
                                         ExplicitTemplateArgs);
   else
     NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
 
   if (NewFn.isInvalid())
     return ExprError();
+  if (AllowTypoCorrection)
+    NewFn.get()->setIsTypoCorrected();
 
   // This shouldn't cause an infinite loop because we're giving it
   // an expression with viable lookup results, which should never
   // end up here.
   return SemaRef.ActOnCallExpr(/*Scope*/ nullptr, NewFn.get(), LParenLoc,
                                MultiExprArg(Args.data(), Args.size()),
                                RParenLoc);
 }

lib/Sema/SemaPseudoObject.cpp

Rebuilder(Sema &S, const SpecificRebuilderRefTy &SpecificCallback)
           SpecificCallback(SpecificCallback) {}
 
     Expr *rebuildObjCPropertyRefExpr(ObjCPropertyRefExpr *refExpr) {
       // Fortunately, the constraint that we're rebuilding something
       // with a base limits the number of cases here.
       if (refExpr->isClassReceiver() || refExpr->isSuperReceiver())
         return refExpr;
 
+      ObjCPropertyRefExpr *Result;
       if (refExpr->isExplicitProperty()) {
-        return new (S.Context) ObjCPropertyRefExpr(
+        Result = new (S.Context) ObjCPropertyRefExpr(
             refExpr->getExplicitProperty(), refExpr->getType(),
             refExpr->getValueKind(), refExpr->getObjectKind(),
             refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
-      }
-      return new (S.Context) ObjCPropertyRefExpr(
+      } else {
+        Result = new (S.Context) ObjCPropertyRefExpr(
             refExpr->getImplicitPropertyGetter(),
             refExpr->getImplicitPropertySetter(), refExpr->getType(),
             refExpr->getValueKind(), refExpr->getObjectKind(),
             refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
       }
+      if (refExpr->isTypoCorrected())
+        Result->setIsTypoCorrected();
+      return Result;
+    }
     Expr *rebuildObjCSubscriptRefExpr(ObjCSubscriptRefExpr *refExpr) {
       assert(refExpr->getBaseExpr());
       assert(refExpr->getKeyExpr());
 
       return new (S.Context) ObjCSubscriptRefExpr(
           SpecificCallback(refExpr->getBaseExpr(), 0),
           SpecificCallback(refExpr->getKeyExpr(), 1), refExpr->getType(),
           refExpr->getValueKind(), refExpr->getObjectKind(),

lib/Sema/SemaTemplateInstantiateDecl.cpp

if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
       NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
                                        Init->getSourceLocation());
     }
 
     if (NewInit.isInvalid()) {
       AnyErrors = true;
       New->setInvalidDecl();
     } else {
+      if (Init->isTypoCorrected())
+        NewInit.get()->setIsTypoCorrected();
       NewInits.push_back(NewInit.get());
     }
   }
 
   // Assign all the initializers to the new constructor.
   ActOnMemInitializers(New,
                        /*FIXME: ColonLoc */
                        SourceLocation(),

lib/Sema/TreeTransform.h

if (E->hasExplicitTemplateArgs()) {
     TransArgs.setLAngleLoc(E->getLAngleLoc());
     TransArgs.setRAngleLoc(E->getRAngleLoc());
     if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                                 E->getNumTemplateArgs(),
                                                 TransArgs))
       return ExprError();
   }
 
-  return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
-                                         TemplateArgs);
+  ExprResult Result =
+      getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo, TemplateArgs);
+  if (E->isTypoCorrected() && Result.isUsable())
+    Result.getAs<DeclRefExpr>()->setIsTypoCorrected();
+  return Result;
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
   return E;
 }
 
TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
   NamedDecl *FirstQualifierInScope = nullptr;
   DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
   if (MemberNameInfo.getName()) {
     MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
     if (!MemberNameInfo.getName())
       return ExprError();
   }
 
-  return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
-                                        E->isArrow(),
-                                        QualifierLoc,
-                                        TemplateKWLoc,
-                                        MemberNameInfo,
-                                        Member,
-                                        FoundDecl,
-                                        (E->hasExplicitTemplateArgs()
-                                           ? &TransArgs : nullptr),
-                                        FirstQualifierInScope);
+  ExprResult Result = getDerived().RebuildMemberExpr(
+      Base.get(), FakeOperatorLoc, E->isArrow(), QualifierLoc, TemplateKWLoc,
+      MemberNameInfo, Member, FoundDecl,
+      (E->hasExplicitTemplateArgs() ? &TransArgs : nullptr),
+  if (E->isTypoCorrected() && Result.isUsable())
+    E->setIsTypoCorrected();
+  return Result;
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
   ExprResult LHS = getDerived().TransformExpr(E->getLHS());
   if (LHS.isInvalid())
     return ExprError();
TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 
   // We don't need to transform the ivar; it will never change.
 
   // If nothing changed, just retain the existing expression.
   if (!getDerived().AlwaysRebuild() &&
       Base.get() == E->getBase())
     return E;
 
-  return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
-                                             E->getLocation(),
-                                             E->isArrow(), E->isFreeIvar());
+  ExprResult Result = getDerived().RebuildObjCIvarRefExpr(
+      Base.get(), E->getDecl(), E->getLocation(), E->isArrow(),
+      E->isFreeIvar());
+  if (E->isTypoCorrected() && Result.isUsable())
+    Result.getAs<ObjCIvarRefExpr>()->setIsTypoCorrected();
+  return Result;
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
   // 'super' and types never change. Property never changes. Just
   // retain the existing expression.
   if (!E->isObjectReceiver())
     return E;
 
   // Transform the base expression.
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
     return ExprError();
 
   // We don't need to transform the property; it will never change.
 
   // If nothing changed, just retain the existing expression.
   if (!getDerived().AlwaysRebuild() &&
       Base.get() == E->getBase())
     return E;
 
+  ExprResult Result;
   if (E->isExplicitProperty())
-    return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
-                                                   E->getExplicitProperty(),
-                                                   E->getLocation());
-
-  return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
-                                                 SemaRef.Context.PseudoObjectTy,
-                                                 E->getImplicitPropertyGetter(),
-                                                 E->getImplicitPropertySetter(),
-                                                 E->getLocation());
+    Result = getDerived().RebuildObjCPropertyRefExpr(
+        Base.get(), E->getExplicitProperty(), E->getLocation());
+  else
+    Result = getDerived().RebuildObjCPropertyRefExpr(
+        Base.get(), SemaRef.Context.PseudoObjectTy,
+        E->getImplicitPropertyGetter(), E->getImplicitPropertySetter(),
+  if (E->isTypoCorrected() && Result.isUsable())
+    Result.getAs<ObjCPropertyRefExpr>()->setIsTypoCorrected();
+  return Result;
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
   // Transform the base expression.
   ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
   if (Base.isInvalid())

lib/Serialization/ASTReader.cpp

else
       BOMInit = new (Context)
           CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
                              LParenLoc, Init, RParenLoc);
 
     if (/*IsWritten*/Record[Idx++]) {
       unsigned SourceOrder = Record[Idx++];
       BOMInit->setSourceOrder(SourceOrder);
     }
+    if (/*IsTypoCorrected*/ Record[Idx++])
+      Init->setIsTypoCorrected();
 
     CtorInitializers[i] = BOMInit;
   }
 
   return CtorInitializers;
 }
 
 NestedNameSpecifier *

lib/Serialization/ASTReaderStmt.cpp

 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
   VisitExpr(E);
 
   E->DeclRefExprBits.HasQualifier = Record.readInt();
   E->DeclRefExprBits.HasFoundDecl = Record.readInt();
   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
   E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
   E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
+  E->DeclRefExprBits.IsTypoCorrected = Record.readInt();
   unsigned NumTemplateArgs = 0;
   if (E->hasTemplateKWAndArgsInfo())
     NumTemplateArgs = Record.readInt();
 
   if (E->hasQualifier())
     new (E->getTrailingObjects<NestedNameSpecifierLoc>())
         NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
 

 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
   VisitExpr(E);
   E->setDecl(ReadDeclAs<ObjCIvarDecl>());
   E->setLocation(ReadSourceLocation());
   E->setOpLoc(ReadSourceLocation());
   E->setBase(Record.readSubExpr());
   E->setIsArrow(Record.readInt());
   E->setIsFreeIvar(Record.readInt());
+  E->setIsTypoCorrected(Record.readInt());
 }
 
 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
   VisitExpr(E);
   unsigned MethodRefFlags = Record.readInt();
+  E->setIsTypoCorrected(Record.readInt());
   bool Implicit = Record.readInt() != 0;
   if (Implicit) {
     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>();
     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>();
     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
   } else {
     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
   }
while (true) {
 
     case EXPR_MEMBER: {
       // We load everything here and fully initialize it at creation.
       // That way we can use MemberExpr::Create and don't have to duplicate its
       // logic with a MemberExpr::CreateEmpty.
 
       assert(Record.getIdx() == 0);
       NestedNameSpecifierLoc QualifierLoc;
+      bool IsTypoCorrected = Record.readInt();
       if (Record.readInt()) { // HasQualifier.
         QualifierLoc = Record.readNestedNameSpecifierLoc();
       }
 
       SourceLocation TemplateKWLoc;
       TemplateArgumentListInfo ArgInfo;
       bool HasTemplateKWAndArgsInfo = Record.readInt();
       if (HasTemplateKWAndArgsInfo) {
case EXPR_MEMBER: {
       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
       bool IsArrow = Record.readInt();
       SourceLocation OperatorLoc = Record.readSourceLocation();
 
       S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
                              HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
                              VK, OK);
+      if (IsTypoCorrected)
+        cast<MemberExpr>(S)->setIsTypoCorrected();
       Record.readDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
                                     MemberD->getDeclName());
       if (HadMultipleCandidates)
         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
       break;
     }
 
     case EXPR_BINARY_OPERATOR:

lib/Serialization/ASTWriter.cpp

for (auto *Init : CtorInits) {
 
     Writer.AddSourceLocation(Init->getMemberLocation());
     Writer.AddStmt(Init->getInit());
     Writer.AddSourceLocation(Init->getLParenLoc());
     Writer.AddSourceLocation(Init->getRParenLoc());
     Writer.push_back(Init->isWritten());
     if (Init->isWritten())
       Writer.push_back(Init->getSourceOrder());
+    Writer.push_back(Init->isTypoCorrected());
   }
 
   return Writer.Emit(serialization::DECL_CXX_CTOR_INITIALIZERS);
 }
 
 // FIXME: Move this out of the main ASTRecordWriter interface.
 void ASTRecordWriter::AddCXXCtorInitializers(
     ArrayRef<CXXCtorInitializer *> CtorInits) {

lib/Serialization/ASTWriterDecl.cpp

void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
   //DeclRefExpr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
                            1)); // RefersToEnclosingVariableOrCapture
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsTypoCorrected
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
   DeclRefExprAbbrev = Stream.EmitAbbrev(std::move(Abv));
 
   // Abbreviation for EXPR_INTEGER_LITERAL
   Abv = std::make_shared<BitCodeAbbrev>();
   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
   //Stmt

lib/Serialization/ASTWriterStmt.cpp

 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
   VisitExpr(E);
 
   Record.push_back(E->hasQualifier());
   Record.push_back(E->getDecl() != E->getFoundDecl());
   Record.push_back(E->hasTemplateKWAndArgsInfo());
   Record.push_back(E->hadMultipleCandidates());
   Record.push_back(E->refersToEnclosingVariableOrCapture());
+  Record.push_back(E->isTypoCorrected());
 
   if (E->hasTemplateKWAndArgsInfo()) {
     unsigned NumTemplateArgs = E->getNumTemplateArgs();
     Record.push_back(NumTemplateArgs);
   }
 
   DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
 
for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
     Record.AddStmt(*Arg);
   Code = serialization::EXPR_CALL;
 }
 
 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
   // Don't call VisitExpr, we'll write everything here.
 
+  Record.push_back(E->isTypoCorrected());
   Record.push_back(E->hasQualifier());
   if (E->hasQualifier())
     Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
 
   Record.push_back(E->HasTemplateKWAndArgsInfo);
   if (E->HasTemplateKWAndArgsInfo) {
     Record.AddSourceLocation(E->getTemplateKeywordLoc());
     unsigned NumTemplateArgs = E->getNumTemplateArgs();

 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
   VisitExpr(E);
   Record.AddDeclRef(E->getDecl());
   Record.AddSourceLocation(E->getLocation());
   Record.AddSourceLocation(E->getOpLoc());
   Record.AddStmt(E->getBase());
   Record.push_back(E->isArrow());
   Record.push_back(E->isFreeIvar());
+  Record.push_back(E->isTypoCorrected());
   Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
 }
 
 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
   VisitExpr(E);
   Record.push_back(E->SetterAndMethodRefFlags.getInt());
+  Record.push_back(E->isTypoCorrected());
   Record.push_back(E->isImplicitProperty());
   if (E->isImplicitProperty()) {
     Record.AddDeclRef(E->getImplicitPropertyGetter());
     Record.AddDeclRef(E->getImplicitPropertySetter());
   } else {
     Record.AddDeclRef(E->getExplicitProperty());
   }
   Record.AddSourceLocation(E->getLocation());

test/Index/typo-annotate-tokens.mm

+// RUN: c-index-test -test-annotate-tokens=%s:1:1:33:1 %s -fspell-checking | FileCheck %s
+
+struct Structure {};
+
+Structure *test555() {
+  Structure *myOwnStringOrig = 0;
+  return myOwnStringNew; // CHECK: Identifier: "myOwnStringNew" {{\[}}[[@LINE]]:10 - [[@LINE]]:24{{\]}} ReturnStmt=
+}
+
+class AClass {
+public:
+  int MyField;
+  void MyMethod();
+
+  void anotherMethod();
+
+  AClass() : MyFild(0) {} // CHECK: Identifier: "MyFild" {{\[}}[[@LINE]]:14 - [[@LINE]]:20{{\]}} CXXConstructor=AClass
+};
+
+void AClass::anotherMethod() {
+  MYField = 0; // CHECK: Identifier: "MYField" {{\[}}[[@LINE]]:3 - [[@LINE]]:10{{\]}} BinaryOperator=
+  MYMethod();  // CHECK: Identifier: "MYMethod" {{\[}}[[@LINE]]:3 - [[@LINE]]:11{{\]}} CallExpr=MyMethod
+}
+
+@interface MyInterface
+
+@property int MyProperty;
+
+@end
+
+void foo(MyInterface *I) {
+  I.MyProprty = 0; // CHECK: Identifier: "MyProprty" {{\[}}[[@LINE]]:5 - [[@LINE]]:14{{\]}} BinaryOperator=
+}

test/Index/typo-file-refs.cpp

+struct Structure {};
+
+Structure *test555() {
+  Structure *myOwnStringOrig = 0;
+  return myOwnStringNew;
+}
+
+class AClass {
+public:
+  int MyField;
+  void MyMethod();
+
+  void anotherMethod();
+
+  AClass() : MyFild(0) {}
+};
+
+void AClass::anotherMethod() {
+  MYField = 0;
+  MYMethod();
+}
+
+void refMember(AClass *C) {
+  C->MyFild = 1;
+  C->MyMethd();
+}
+
+// RUN: c-index-test \
+
+// RUN:  -file-refs-at=%s:4:14 \
+// CHECK:      VarDecl=myOwnStringOrig:4:14 (Definition)
+// CHECK-NEXT: VarDecl=myOwnStringOrig:4:14 (Definition) =[4:14 - 4:29]
+// CHECK-NOT:  DeclRefExpr=myOwnStringOrig
+
+// RUN:  -file-refs-at=%s:10:7 \
+// CHECK-NEXT: FieldDecl=MyField:10:7 (Definition)
+// CHECK-NEXT: FieldDecl=MyField:10:7 (Definition) =[10:7 - 10:14]
+// CHECK-NOT:  =MyField
+
+// RUN:  -file-refs-at=%s:11:8 \
+// CHECK-NEXT: CXXMethod=MyMethod:11:8
+// CHECK-NEXT: CXXMethod=MyMethod:11:8 =[11:8 - 11:16]
+// CHECK-NOT:  MemberRefExpr=MyMethod
+
+// RUN:   %s -fspell-checking | FileCheck %s

test/Index/typo-file-refs.m

+struct Structure {
+  int MyCField;
+};
+
+void testMember(struct Structure *x) {
+  x->MyField = 0;
+}
+
+@interface MyInterface
+
+@property int MyProperty;
+
+- (int)MyImplicit;
+- (void)setMyImplicit:(int)x;
+
+@property (class) int MyClassProperty;
+
+- (void)MyMethod;
+
+@end
+
+@implementation MyInterface {
+  int MyIVar;
+}
+
+- (void) method {
+  MyiVar = 0;
+  self->MyiVar = 1;
+
+  self.MyProprty = 0;
+  int x = self.MyProprty;
+
+  int y = self.MyImplict;
+  self.MyImplict = 2;
+
+  MyInterface.MyClassProprty = 0;
+  int z = MyInterface.MyClassProprty;
+
+  [self MyMethd];
+}
+
+@end
+
+// RUN: c-index-test \
+
+// RUN:  -file-refs-at=%s:2:7 \
+// CHECK:      FieldDecl=MyCField:2:7 (Definition)
+// CHECK-NEXT: FieldDecl=MyCField:2:7 (Definition) =[2:7 - 2:15]
+// CHECK-NOT:  MemberRefExpr=MyCField
+
+// RUN:  -file-refs-at=%s:23:7 \
+// CHECK-NEXT: ObjCIvarDecl=MyIVar:23:7 (Definition)
+// CHECK-NEXT: ObjCIvarDecl=MyIVar:23:7 (Definition) =[23:7 - 23:13]
+// CHECK-NOT:  MemberRefExpr=MyIVar
+
+// RUN:  -file-refs-at=%s:11:15 \
+// CHECK-NEXT: ObjCPropertyDecl=MyProperty:11:15
+// CHECK-NEXT: ObjCPropertyDecl=MyProperty:11:15 =[11:15 - 11:25]
+// CHECK-NOT:  MemberRefExpr=MyProperty
+
+// RUN:  -file-refs-at=%s:13:8 \
+// CHECK-NEXT: ObjCInstanceMethodDecl=MyImplicit:13:8
+// CHECK-NEXT: ObjCInstanceMethodDecl=MyImplicit:13:8 =[13:8 - 13:18]
+// CHECK-NOT:  MyImplicit
+
+// RUN:  -file-refs-at=%s:16:23 \
+// CHECK-NEXT: ObjCPropertyDecl=MyClassProperty:16:23 [class,]
+// CHECK-NEXT: ObjCPropertyDecl=MyClassProperty:16:23 [class,] =[16:23 - 16:38]
+// CHECK-NOT:  MyClassProperty
+
+// RUN:  -file-refs-at=%s:18:9 \
+// CHECK-NEXT: ObjCInstanceMethodDecl=MyMethod:18:9
+// CHECK-NEXT: ObjCInstanceMethodDecl=MyMethod:18:9 =[18:9 - 18:17]
+// CHECK-NOT:  MyMethod
+
+// RUN:   %s -fspell-checking | FileCheck %s

tools/libclang/CIndex.cpp

if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
       
       // Sort the initializers in source order
       llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
                            &CompareCXXCtorInitializers);
       
       // Visit the initializers in source order
       for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
         CXXCtorInitializer *Init = WrittenInits[I];
+        if (VisitTypoCorrected | !Init->isTypoCorrected()) {
           if (Init->isAnyMemberInitializer()) {
             if (Visit(MakeCursorMemberRef(Init->getAnyMember(),
                                           Init->getMemberLocation(), TU)))
               return true;
           } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) {
             if (Visit(TInfo->getTypeLoc()))
               return true;
           }
+        }
         
         // Visit the initializer value.
         if (Expr *Initializer = Init->getInit())
           if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest)))
             return true;
       } 
     }
     
class AnnotateTokensWorker {
 
   void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
   bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult,
                                              SourceRange);
 
 public:
   AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens,
                        CXTranslationUnit TU, SourceRange RegionOfInterest)
-    : Tokens(tokens), Cursors(cursors),
-      NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0),
-      AnnotateVis(TU,
-                  AnnotateTokensVisitor, this,
+      : Tokens(tokens), Cursors(cursors), NumTokens(numTokens), TokIdx(0),
+        PreprocessingTokIdx(0),
+        AnnotateVis(TU, AnnotateTokensVisitor, this,
                     /*VisitPreprocessorLast=*/true,
-                  /*VisitIncludedEntities=*/false,
-                  RegionOfInterest,
+                    /*VisitIncludedEntities=*/false, RegionOfInterest,
                     /*VisitDeclsOnly=*/false,
                     AnnotateTokensPostChildrenVisitor),
         SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()),
-      HasContextSensitiveKeywords(false) { }
+        HasContextSensitiveKeywords(false) {
+    // Don't annotate typo-corrected references.
+    AnnotateVis.setVisitTypoCorrected(false);
+  }
 
   void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
   enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
   bool postVisitChildren(CXCursor cursor);
   void AnnotateTokens();
   
   /// \brief Determine whether the annotator saw any cursors that have 
   /// context-sensitive keywords.
AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) {
 
   // Avoid having the cursor of an expression "overwrite" the annotation of the
   // variable declaration that it belongs to.
   // This can happen for C++ constructor expressions whose range generally
   // include the variable declaration, e.g.:
   //  MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor.
   if (clang_isExpression(cursorK) && MoreTokens()) {
     const Expr *E = getCursorExpr(cursor);
+    // Avoid annotating typo-corrected references.
+    if (E->isTypoCorrected())
+      return CXChildVisit_Continue;
     if (const Decl *D = getCursorParentDecl(cursor)) {
       const unsigned I = NextToken();
       if (E->getLocStart().isValid() && D->getLocation().isValid() &&
           E->getLocStart() == D->getLocation() &&
           E->getLocStart() == GetTokenLoc(I)) {
         updateCursorAnnotation(Cursors[I], updateC);
         AdvanceToken();
       }

tools/libclang/CIndexHigh.cpp

if (data->isHit(D)) {
     if ((cursor.kind == CXCursor_ObjCClassMethodDecl ||
          cursor.kind == CXCursor_ObjCInstanceMethodDecl) &&
          cxcursor::getSelectorIdentifierIndex(cursor) == -1)
       return CXChildVisit_Recurse;
 
     if (clang_isExpression(cursor.kind)) {
       if (cursor.kind == CXCursor_DeclRefExpr ||
           cursor.kind == CXCursor_MemberRefExpr) {
-        // continue..
+        // Avoid visiting typo-corrected references.
+        if (cxcursor::getCursorExpr(cursor)->isTypoCorrected())
+          return CXChildVisit_Continue;
 
       } else if (cursor.kind == CXCursor_ObjCMessageExpr &&
                  cxcursor::getSelectorIdentifierIndex(cursor) != -1) {
         // continue..
                 
       } else
         return CXChildVisit_Recurse;
     }
static bool findIdRefsInFile(CXTranslationUnit TU, CXCursor declCursor,
   if (!Dcl)
     return false;
 
   FindFileIdRefVisitData data(TU, FID, Dcl,
                               cxcursor::getSelectorIdentifierIndex(declCursor),
                               Visitor);
 
   if (const DeclContext *DC = Dcl->getParentFunctionOrMethod()) {
-    return clang_visitChildren(cxcursor::MakeCXCursor(cast<Decl>(DC), TU),
-                               findFileIdRefVisit, &data);
+    CursorVisitor CursorVis(TU, findFileIdRefVisit, &data,
+                            /*VisitPreprocessorLast=*/false);
+    // Don't include the typo-corrected references.
+    CursorVis.setVisitTypoCorrected(false);
+    return CursorVis.VisitChildren(cxcursor::MakeCXCursor(cast<Decl>(DC), TU));
   }
 
   SourceRange Range(SM.getLocForStartOfFile(FID), SM.getLocForEndOfFile(FID));
   CursorVisitor FindIdRefsVisitor(TU,
                                   findFileIdRefVisit, &data,
                                   /*VisitPreprocessorLast=*/true,
                                   /*VisitIncludedEntities=*/false,
                                   Range,
                                   /*VisitDeclsOnly=*/true);
+  // Don't include the typo-corrected references.
+  FindIdRefsVisitor.setVisitTypoCorrected(false);
   return FindIdRefsVisitor.visitFileRegion();
 }
 
 namespace {
 
 struct FindFileMacroRefVisitData {
   ASTUnit &Unit;
   const FileEntry *File;

tools/libclang/CursorVisitor.h

private:
   /// \brief When valid, a source range to which the cursor should restrict
   /// its search.
   SourceRange RegionOfInterest;
 
   /// \brief Whether we should only visit declarations and not preprocessing
   /// record entries.
   bool VisitDeclsOnly;
 
+  /// \brief Whether we should visit typo-corrected references.
+  bool VisitTypoCorrected = true;
+
   // FIXME: Eventually remove.  This part of a hack to support proper
   // iteration over all Decls contained lexically within an ObjC container.
   DeclContext::decl_iterator *DI_current;
   DeclContext::decl_iterator DE_current;
   SmallVectorImpl<Decl *>::iterator *FileDI_current;
   SmallVectorImpl<Decl *>::iterator FileDE_current;
 
   // Cache of pre-allocated worklists for data-recursion walk of Stmts.
public:
   bool visitFileRegion();
   
   bool visitPreprocessedEntitiesInRegion();
 
   bool shouldVisitIncludedEntities() const {
     return VisitIncludedEntities;
   }
 
+  void setVisitTypoCorrected(bool V = true) { VisitTypoCorrected = V; }
+
   template<typename InputIterator>
   bool visitPreprocessedEntities(InputIterator First, InputIterator Last,
                                  PreprocessingRecord &PPRec,
                                  FileID FID = FileID());
 
   bool VisitChildren(CXCursor Parent);
 
   // Declaration visitors