//===--- DependenceFlags.h ------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_DEPENDENCEFLAGS_H
#define LLVM_CLANG_AST_DEPENDENCEFLAGS_H

#include "clang/Basic/BitmaskEnum.h"
#include "llvm/ADT/BitmaskEnum.h"
#include <cstdint>

namespace clang {
struct ExprDependenceScope {
  enum ExprDependence : uint8_t {
    UnexpandedPack = 1,
    // This expr depends in any way on
    //   - a template parameter, it implies that the resolution of this expr may
    //     cause instantiation to fail
    //   - or an error (often in a non-template context)
    //
    // Note that C++ standard doesn't define the instantiation-dependent term,
    // we follow the formal definition coming from the Itanium C++ ABI, and
    // extend it to errors.
    Instantiation = 2,
    // The type of this expr depends on a template parameter, or an error.
    Type = 4,
    // The value of this expr depends on a template parameter, or an error.
    Value = 8,

    // clang extension: this expr contains or references an error, and is
    // considered dependent on how that error is resolved.
    Error = 16,

    None = 0,
    All = 31,

    TypeValue = Type | Value,
    TypeInstantiation = Type | Instantiation,
    ValueInstantiation = Value | Instantiation,
    TypeValueInstantiation = Type | Value | Instantiation,
    ErrorDependent = Error | ValueInstantiation,

    LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Error)
  };
};
using ExprDependence = ExprDependenceScope::ExprDependence;

struct TypeDependenceScope {
  enum TypeDependence : uint8_t {
    /// Whether this type contains an unexpanded parameter pack
    /// (for C++11 variadic templates)
    UnexpandedPack = 1,
    /// Whether this type somehow involves
    ///   - a template parameter, even if the resolution of the type does not
    ///     depend on a template parameter.
    ///   - or an error.
    Instantiation = 2,
    /// Whether this type
    ///   - is a dependent type (C++ [temp.dep.type])
    ///   - or it somehow involves an error, e.g. decltype(recovery-expr)
    Dependent = 4,
    /// Whether this type is a variably-modified type (C99 6.7.5).
    VariablyModified = 8,

    /// Whether this type references an error, e.g. decltype(err-expression)
    /// yields an error type.
    Error = 16,

    None = 0,
    All = 31,

    DependentInstantiation = Dependent | Instantiation,

    LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Error)
  };
};
using TypeDependence = TypeDependenceScope::TypeDependence;

#define LLVM_COMMON_DEPENDENCE(NAME)                                           \
  struct NAME##Scope {                                                         \
    enum NAME : uint8_t {                                                      \
      UnexpandedPack = 1,                                                      \
      Instantiation = 2,                                                       \
      Dependent = 4,                                                           \
      Error = 8,                                                               \
                                                                               \
      None = 0,                                                                \
      DependentInstantiation = Dependent | Instantiation,                      \
      All = 15,                                                                \
                                                                               \
      LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Error)                        \
    };                                                                         \
  };                                                                           \
  using NAME = NAME##Scope::NAME;

LLVM_COMMON_DEPENDENCE(NestedNameSpecifierDependence)
LLVM_COMMON_DEPENDENCE(TemplateNameDependence)
LLVM_COMMON_DEPENDENCE(TemplateArgumentDependence)
#undef LLVM_COMMON_DEPENDENCE

// A combined space of all dependence concepts for all node types.
// Used when aggregating dependence of nodes of different types.
class Dependence {
public:
  enum Bits : uint8_t {
    None = 0,

    // Contains a template parameter pack that wasn't expanded.
    UnexpandedPack = 1,
    // Depends on a template parameter or an error in some way.
    // Validity depends on how the template is instantiated or the error is
    // resolved.
    Instantiation = 2,
    // Expression type depends on template context, or an error.
    // Value and Instantiation should also be set.
    Type = 4,
    // Expression value depends on template context, or an error.
    // Instantiation should also be set.
    Value = 8,
    // Depends on template context, or an error.
    // The type/value distinction is only meaningful for expressions.
    Dependent = Type | Value,
    // Includes an error, and depends on how it is resolved.
    Error = 16,
    // Type depends on a runtime value (variable-length array).
    VariablyModified = 32,

    // Dependence that is propagated syntactically, regardless of semantics.
    Syntactic = UnexpandedPack | Instantiation | Error,
    // Dependence that is propagated semantically, even in cases where the
    // type doesn't syntactically appear. This currently excludes only
    // UnexpandedPack. Even though Instantiation dependence is also notionally
    // syntactic, we also want to propagate it semantically because anything
    // that semantically depends on an instantiation-dependent entity should
    // always be instantiated when that instantiation-dependent entity is.
    Semantic =
        Instantiation | Type | Value | Dependent | Error | VariablyModified,

    LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/VariablyModified)
  };

  Dependence() : V(None) {}

  Dependence(TypeDependence D)
      : V(translate(D, TypeDependence::UnexpandedPack, UnexpandedPack) |
          translate(D, TypeDependence::Instantiation, Instantiation) |
          translate(D, TypeDependence::Dependent, Dependent) |
          translate(D, TypeDependence::Error, Error) |
          translate(D, TypeDependence::VariablyModified, VariablyModified)) {}

  Dependence(ExprDependence D)
      : V(translate(D, ExprDependence::UnexpandedPack, UnexpandedPack) |
             translate(D, ExprDependence::Instantiation, Instantiation) |
             translate(D, ExprDependence::Type, Type) |
             translate(D, ExprDependence::Value, Value) |
             translate(D, ExprDependence::Error, Error)) {}

  Dependence(NestedNameSpecifierDependence D) :
    V ( translate(D, NNSDependence::UnexpandedPack, UnexpandedPack) |
            translate(D, NNSDependence::Instantiation, Instantiation) |
            translate(D, NNSDependence::Dependent, Dependent) |
            translate(D, NNSDependence::Error, Error)) {}

  Dependence(TemplateArgumentDependence D)
      : V(translate(D, TADependence::UnexpandedPack, UnexpandedPack) |
          translate(D, TADependence::Instantiation, Instantiation) |
          translate(D, TADependence::Dependent, Dependent) |
          translate(D, TADependence::Error, Error)) {}

  Dependence(TemplateNameDependence D)
      : V(translate(D, TNDependence::UnexpandedPack, UnexpandedPack) |
             translate(D, TNDependence::Instantiation, Instantiation) |
             translate(D, TNDependence::Dependent, Dependent) |
             translate(D, TNDependence::Error, Error)) {}

  /// Extract only the syntactic portions of this type's dependence.
  Dependence syntactic() {
    Dependence Result = *this;
    Result.V &= Syntactic;
    return Result;
  }

  /// Extract the semantic portions of this type's dependence that apply even
  /// to uses where the type does not appear syntactically.
  Dependence semantic() {
    Dependence Result = *this;
    Result.V &= Semantic;
    return Result;
  }

  TypeDependence type() const {
    return translate(V, UnexpandedPack, TypeDependence::UnexpandedPack) |
           translate(V, Instantiation, TypeDependence::Instantiation) |
           translate(V, Dependent, TypeDependence::Dependent) |
           translate(V, Error, TypeDependence::Error) |
           translate(V, VariablyModified, TypeDependence::VariablyModified);
  }

  ExprDependence expr() const {
    return translate(V, UnexpandedPack, ExprDependence::UnexpandedPack) |
           translate(V, Instantiation, ExprDependence::Instantiation) |
           translate(V, Type, ExprDependence::Type) |
           translate(V, Value, ExprDependence::Value) |
           translate(V, Error, ExprDependence::Error);
  }

  NestedNameSpecifierDependence nestedNameSpecifier() const {
    return translate(V, UnexpandedPack, NNSDependence::UnexpandedPack) |
           translate(V, Instantiation, NNSDependence::Instantiation) |
           translate(V, Dependent, NNSDependence::Dependent) |
           translate(V, Error, NNSDependence::Error);
  }

  TemplateArgumentDependence templateArgument() const {
    return translate(V, UnexpandedPack, TADependence::UnexpandedPack) |
           translate(V, Instantiation, TADependence::Instantiation) |
           translate(V, Dependent, TADependence::Dependent) |
           translate(V, Error, TADependence::Error);
  }

  TemplateNameDependence templateName() const {
    return translate(V, UnexpandedPack, TNDependence::UnexpandedPack) |
           translate(V, Instantiation, TNDependence::Instantiation) |
           translate(V, Dependent, TNDependence::Dependent) |
           translate(V, Error, TNDependence::Error);
  }

private:
  Bits V;

  template <typename T, typename U>
  static U translate(T Bits, T FromBit, U ToBit) {
    return (Bits & FromBit) ? ToBit : static_cast<U>(0);
  }

  // Abbreviations to make conversions more readable.
  using NNSDependence = NestedNameSpecifierDependence;
  using TADependence = TemplateArgumentDependence;
  using TNDependence = TemplateNameDependence;
};

/// Computes dependencies of a reference with the name having template arguments
/// with \p TA dependencies.
inline ExprDependence toExprDependence(TemplateArgumentDependence TA) {
  return Dependence(TA).expr();
}
inline ExprDependence toExprDependenceForImpliedType(TypeDependence D) {
  return Dependence(D).semantic().expr();
}
inline ExprDependence toExprDependenceAsWritten(TypeDependence D) {
  return Dependence(D).expr();
}
// Note: it's often necessary to strip `Dependent` from qualifiers.
// If V<T>:: refers to the current instantiation, NNS is considered dependent
// but the containing V<T>::foo likely isn't.
inline ExprDependence toExprDependence(NestedNameSpecifierDependence D) {
  return Dependence(D).expr();
}
inline ExprDependence turnTypeToValueDependence(ExprDependence D) {
  // Type-dependent expressions are always be value-dependent, so we simply drop
  // type dependency.
  return D & ~ExprDependence::Type;
}
inline ExprDependence turnValueToTypeDependence(ExprDependence D) {
  // Type-dependent expressions are always be value-dependent.
  if (D & ExprDependence::Value)
    D |= ExprDependence::Type;
  return D;
}

// Returned type-dependence will never have VariablyModified set.
inline TypeDependence toTypeDependence(ExprDependence D) {
  return Dependence(D).type();
}
inline TypeDependence toTypeDependence(NestedNameSpecifierDependence D) {
  return Dependence(D).type();
}
inline TypeDependence toTypeDependence(TemplateNameDependence D) {
  return Dependence(D).type();
}
inline TypeDependence toTypeDependence(TemplateArgumentDependence D) {
  return Dependence(D).type();
}

inline TypeDependence toSyntacticDependence(TypeDependence D) {
  return Dependence(D).syntactic().type();
}
inline TypeDependence toSemanticDependence(TypeDependence D) {
  return Dependence(D).semantic().type();
}

inline NestedNameSpecifierDependence
toNestedNameSpecifierDependendence(TypeDependence D) {
  return Dependence(D).nestedNameSpecifier();
}

inline TemplateArgumentDependence
toTemplateArgumentDependence(TypeDependence D) {
  return Dependence(D).templateArgument();
}
inline TemplateArgumentDependence
toTemplateArgumentDependence(TemplateNameDependence D) {
  return Dependence(D).templateArgument();
}
inline TemplateArgumentDependence
toTemplateArgumentDependence(ExprDependence D) {
  return Dependence(D).templateArgument();
}

inline TemplateNameDependence
toTemplateNameDependence(NestedNameSpecifierDependence D) {
  return Dependence(D).templateName();
}

LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();

} // namespace clang
#endif