Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- 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