text: //===--- SemaFixItUtils.h - Sema FixIts -------------------------*- C++ -*-===//
  //
  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  // See https://llvm.org/LICENSE.txt for license information.
  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  //
  //===----------------------------------------------------------------------===//
  //
  //  This file defines helper classes for generation of Sema FixItHints.
  //
  //===----------------------------------------------------------------------===//
  #ifndef LLVM_CLANG_SEMA_SEMAFIXITUTILS_H
  #define LLVM_CLANG_SEMA_SEMAFIXITUTILS_H
  
  #include "clang/AST/Expr.h"
  
  namespace clang {
  
  enum OverloadFixItKind {
    OFIK_Undefined = 0,
    OFIK_Dereference,
    OFIK_TakeAddress,
    OFIK_RemoveDereference,
    OFIK_RemoveTakeAddress
  };
  
  class Sema;
  
  /// The class facilities generation and storage of conversion FixIts. Hints for
  /// new conversions are added using TryToFixConversion method. The default type
  /// conversion checker can be reset.
  struct ConversionFixItGenerator {
    /// Performs a simple check to see if From type can be converted to To type.
    static bool compareTypesSimple(CanQualType From,
                                   CanQualType To,
                                   Sema &S,
                                   SourceLocation Loc,
                                   ExprValueKind FromVK);
  
    /// The list of Hints generated so far.
    std::vector<FixItHint> Hints;
  
    /// The number of Conversions fixed. This can be different from the size
    /// of the Hints vector since we allow multiple FixIts per conversion.
    unsigned NumConversionsFixed;
  
    /// The type of fix applied. If multiple conversions are fixed, corresponds
    /// to the kid of the very first conversion.
    OverloadFixItKind Kind;
  
    typedef bool (*TypeComparisonFuncTy) (const CanQualType FromTy,
                                          const CanQualType ToTy,
                                          Sema &S,
                                          SourceLocation Loc,
                                          ExprValueKind FromVK);
    /// The type comparison function used to decide if expression FromExpr of
    /// type FromTy can be converted to ToTy. For example, one could check if
    /// an implicit conversion exists. Returns true if comparison exists.
    TypeComparisonFuncTy CompareTypes;
  
    ConversionFixItGenerator(TypeComparisonFuncTy Foo): NumConversionsFixed(0),
                                                        Kind(OFIK_Undefined),
                                                        CompareTypes(Foo) {}
  
    ConversionFixItGenerator(): NumConversionsFixed(0),
                                Kind(OFIK_Undefined),
                                CompareTypes(compareTypesSimple) {}
  
    /// Resets the default conversion checker method.
    void setConversionChecker(TypeComparisonFuncTy Foo) {
      CompareTypes = Foo;
    }
  
    /// If possible, generates and stores a fix for the given conversion.
    bool tryToFixConversion(const Expr *FromExpr,
                            const QualType FromQTy, const QualType ToQTy,
                            Sema &S);
  
    void clear() {
      Hints.clear();
      NumConversionsFixed = 0;
    }
  
    bool isNull() {
      return (NumConversionsFixed == 0);
    }
  };
  
  } // endof namespace clang
  #endif
  