contrib/llvm/tools/clang/include/clang/Sema/TemplateDeduction.h

   1 //===- TemplateDeduction.h - C++ template argument deduction ----*- C++ -*-===/
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //===----------------------------------------------------------------------===/
   8 //
   9 //  This file provides types used with Sema's template argument deduction
  10 // routines.
  11 //
  12 //===----------------------------------------------------------------------===/
  13 #ifndef LLVM_CLANG_SEMA_TEMPLATE_DEDUCTION_H
  14 #define LLVM_CLANG_SEMA_TEMPLATE_DEDUCTION_H
  15
  16 #include "clang/AST/DeclTemplate.h"
  17 #include "clang/Basic/PartialDiagnostic.h"
  18 #include "llvm/ADT/SmallVector.h"
  19
  20 namespace clang {
  21
  22 class TemplateArgumentList;
  23
  24 namespace sema {
  25
  26 /// \brief Provides information about an attempted template argument
  27 /// deduction, whose success or failure was described by a
  28 /// TemplateDeductionResult value.
  29 class TemplateDeductionInfo {
  30   /// \brief The deduced template argument list.
  31   ///
  32   TemplateArgumentList *Deduced;
  33
  34   /// \brief The source location at which template argument
  35   /// deduction is occurring.
  36   SourceLocation Loc;
  37
  38   /// \brief Have we suppressed an error during deduction?
  39   bool HasSFINAEDiagnostic;
  40
  41   /// \brief Warnings (and follow-on notes) that were suppressed due to
  42   /// SFINAE while performing template argument deduction.
  43   SmallVector<PartialDiagnosticAt, 4> SuppressedDiagnostics;
  44
  45   TemplateDeductionInfo(const TemplateDeductionInfo &) LLVM_DELETED_FUNCTION;
  46   void operator=(const TemplateDeductionInfo &) LLVM_DELETED_FUNCTION;
  47
  48 public:
  49   TemplateDeductionInfo(SourceLocation Loc)
  50     : Deduced(0), Loc(Loc), HasSFINAEDiagnostic(false), Expression(0) { }
  51
  52   /// \brief Returns the location at which template argument is
  53   /// occurring.
  54   SourceLocation getLocation() const {
  55     return Loc;
  56   }
  57
  58   /// \brief Take ownership of the deduced template argument list.
  59   TemplateArgumentList *take() {
  60     TemplateArgumentList *Result = Deduced;
  61     Deduced = 0;
  62     return Result;
  63   }
  64
  65   /// \brief Take ownership of the SFINAE diagnostic.
  66   void takeSFINAEDiagnostic(PartialDiagnosticAt &PD) {
  67     assert(HasSFINAEDiagnostic);
  68     PD.first = SuppressedDiagnostics.front().first;
  69     PD.second.swap(SuppressedDiagnostics.front().second);
  70     SuppressedDiagnostics.clear();
  71     HasSFINAEDiagnostic = false;
  72   }
  73
  74   /// \brief Provide a new template argument list that contains the
  75   /// results of template argument deduction.
  76   void reset(TemplateArgumentList *NewDeduced) {
  77     Deduced = NewDeduced;
  78   }
  79
  80   /// \brief Is a SFINAE diagnostic available?
  81   bool hasSFINAEDiagnostic() const {
  82     return HasSFINAEDiagnostic;
  83   }
  84
  85   /// \brief Set the diagnostic which caused the SFINAE failure.
  86   void addSFINAEDiagnostic(SourceLocation Loc, PartialDiagnostic PD) {
  87     // Only collect the first diagnostic.
  88     if (HasSFINAEDiagnostic)
  89       return;
  90     SuppressedDiagnostics.clear();
  91     SuppressedDiagnostics.push_back(
  92         std::make_pair(Loc, PartialDiagnostic::NullDiagnostic()));
  93     SuppressedDiagnostics.back().second.swap(PD);
  94     HasSFINAEDiagnostic = true;
  95   }
  96
  97   /// \brief Add a new diagnostic to the set of diagnostics
  98   void addSuppressedDiagnostic(SourceLocation Loc,
  99                                PartialDiagnostic PD) {
 100     if (HasSFINAEDiagnostic)
 101       return;
 102     SuppressedDiagnostics.push_back(
 103         std::make_pair(Loc, PartialDiagnostic::NullDiagnostic()));
 104     SuppressedDiagnostics.back().second.swap(PD);
 105   }
 106
 107   /// \brief Iterator over the set of suppressed diagnostics.
 108   typedef SmallVectorImpl<PartialDiagnosticAt>::const_iterator
 109     diag_iterator;
 110
 111   /// \brief Returns an iterator at the beginning of the sequence of suppressed
 112   /// diagnostics.
 113   diag_iterator diag_begin() const { return SuppressedDiagnostics.begin(); }
 114
 115   /// \brief Returns an iterator at the end of the sequence of suppressed
 116   /// diagnostics.
 117   diag_iterator diag_end() const { return SuppressedDiagnostics.end(); }
 118
 119   /// \brief The template parameter to which a template argument
 120   /// deduction failure refers.
 121   ///
 122   /// Depending on the result of template argument deduction, this
 123   /// template parameter may have different meanings:
 124   ///
 125   ///   TDK_Incomplete: this is the first template parameter whose
 126   ///   corresponding template argument was not deduced.
 127   ///
 128   ///   TDK_Inconsistent: this is the template parameter for which
 129   ///   two different template argument values were deduced.
 130   TemplateParameter Param;
 131
 132   /// \brief The first template argument to which the template
 133   /// argument deduction failure refers.
 134   ///
 135   /// Depending on the result of the template argument deduction,
 136   /// this template argument may have different meanings:
 137   ///
 138   ///   TDK_Inconsistent: this argument is the first value deduced
 139   ///   for the corresponding template parameter.
 140   ///
 141   ///   TDK_SubstitutionFailure: this argument is the template
 142   ///   argument we were instantiating when we encountered an error.
 143   ///
 144   ///   TDK_NonDeducedMismatch: this is the component of the 'parameter'
 145   ///   of the deduction, directly provided in the source code.
 146   TemplateArgument FirstArg;
 147
 148   /// \brief The second template argument to which the template
 149   /// argument deduction failure refers.
 150   ///
 151   ///   TDK_NonDeducedMismatch: this is the mismatching component of the
 152   ///   'argument' of the deduction, from which we are deducing arguments.
 153   ///
 154   /// FIXME: Finish documenting this.
 155   TemplateArgument SecondArg;
 156
 157   /// \brief The expression which caused a deduction failure.
 158   ///
 159   ///   TDK_FailedOverloadResolution: this argument is the reference to
 160   ///   an overloaded function which could not be resolved to a specific
 161   ///   function.
 162   Expr *Expression;
 163 };
 164
 165 }
 166 }
 167
 168 #endif