/**

* Provides classes representing C/C++ enums and enum constants.

*/

import semmle.code.cpp.Type

private import semmle.code.cpp.internal.ResolveClass

/**

* A C/C++ enum [N4140 7.2]. For example, the types `MyEnum` and

* `MyScopedEnum` in:

* ```

* enum MyEnum {

* MyEnumConstant

* };

*

* enum class MyScopedEnum {

* MyScopedEnumConstant

* };

* ```

* This includes C++ scoped enums, see the `ScopedEnum` QL class.

*/

class Enum extends UserType, IntegralOrEnumType {

/** Gets an enumerator of this enumeration. */

EnumConstant getAnEnumConstant() { result.getDeclaringEnum() = this }

/**

* Gets the enumerator of this enumeration that was declared at the zero-based position `index`.

* For example, `zero` is at index 2 in the following declaration:

* ```

* enum ReversedOrder {

* two = 2,

* one = 1,

* zero = 0

* };

* ```

*/

EnumConstant getEnumConstant(int index) {

enumconstants(unresolveElement(result), underlyingElement(this), index, _, _, _)

}

override string getAPrimaryQlClass() { result = "Enum" }

/**

* Gets a descriptive string for the enum. This method is only intended to

* be used for debugging purposes. For more information, see the comment

* for `Type.explain`.

*/

override string explain() { result = "enum " + this.getName() }

override int getSize() {

// Workaround for extractor bug CPP-348: No size information for enums.

// If the extractor didn't provide a size, assume four bytes.

result = UserType.super.getSize()

or

not exists(UserType.super.getSize()) and result = 4

}

/** See `Type.isDeeplyConst` and `Type.isDeeplyConstBelow`. Internal. */

override predicate isDeeplyConstBelow() { any() } // No subparts

/**

* Holds if this enum has an enum-base [N4140 7.2].

* For example: `enum E : int`.

*/

predicate hasExplicitUnderlyingType() { derivations(_, underlyingElement(this), _, _, _) }

/**

* The type of the enum-base [N4140 7.2], if it is specified.

* For example: `int` in `enum E : int`.

*/

Type getExplicitUnderlyingType() {

derivations(_, underlyingElement(this), _, unresolveElement(result), _)

}

}

/**

* A C/C++ enum that is directly enclosed by a function. For example, the type

* `MyLocalEnum` in:

* ```

* void myFunction() {

* enum MyLocalEnum {

* MyLocalEnumConstant

* };

* }

* ```

*/

class LocalEnum extends Enum {

LocalEnum() { this.isLocal() }

override string getAPrimaryQlClass() { result = "LocalEnum" }

}

/**

* A C/C++ enum that is declared within a class/struct. For example, the type

* `MyNestedEnum` in:

* ```

* class MyClass {

* public:

* enum MyNestedEnum {

* MyNestedEnumConstant

* };

* };

* ```

*/

class NestedEnum extends Enum {

NestedEnum() { this.isMember() }

override string getAPrimaryQlClass() { result = "NestedEnum" }

/** Holds if this member is private. */

predicate isPrivate() { this.hasSpecifier("private") }

/** Holds if this member is protected. */

predicate isProtected() { this.hasSpecifier("protected") }

/** Holds if this member is public. */

predicate isPublic() { this.hasSpecifier("public") }

}

/**

* A C++ scoped enum, that is, an enum whose constants must be qualified with

* the name of the enum. For example, the type `Color` in:

* ```

* enum class Color {

* red,

* blue

* }

* ```

*/

class ScopedEnum extends Enum {

ScopedEnum() { usertypes(underlyingElement(this), _, 13) }

override string getAPrimaryQlClass() { result = "ScopedEnum" }

}

/**

* A C/C++ enumerator [N4140 7.2], also known as an enumeration constant.

*

* For example the enumeration constant `green` in:

* ```

* enum {

* red,

* green,

* blue

* }

* ```

*/

class EnumConstant extends Declaration, @enumconstant {

/**

* Gets the enumeration of which this enumerator is a member.

*/

Enum getDeclaringEnum() {

enumconstants(underlyingElement(this), unresolveElement(result), _, _, _, _)

}

override string getAPrimaryQlClass() { result = "EnumConstant" }

override Class getDeclaringType() { result = this.getDeclaringEnum().getDeclaringType() }

/**

* Gets the name of this enumerator.

*/

override string getName() { enumconstants(underlyingElement(this), _, _, _, result, _) }

/**

* Gets the value that this enumerator is initialized to, as a

* string. This can be a value explicitly given to the enumerator, or an

* automatically assigned value.

*/

string getValue() { result = this.getInitializer().getExpr().getValue() }

/** Gets the type of this enumerator. */

Type getType() { enumconstants(underlyingElement(this), _, _, unresolveElement(result), _, _) }

/** Gets the location of a declaration of this enumerator. */

override Location getADeclarationLocation() { result = this.getDefinitionLocation() }

/** Gets the location of the definition of this enumerator. */

override Location getDefinitionLocation() {

enumconstants(underlyingElement(this), _, _, _, _, result)

}

/** Gets the location of the definition of this enumerator. */

override Location getLocation() { result = this.getDefinitionLocation() }

/** Gets the initializer of this enumerator, if any. */

Initializer getInitializer() { result.getDeclaration() = this }

/** Gets an access of this enumerator. */

EnumConstantAccess getAnAccess() { result.getTarget() = this }

/** Gets a specifier of this enumerator. */

override Specifier getASpecifier() {

varspecifiers(underlyingElement(this), unresolveElement(result))

}

/**

* An attribute of this enumerator.

*

* Note that allowing attributes on enumerators is a language extension

* which is only supported by Clang.

*/

Attribute getAnAttribute() { varattributes(underlyingElement(this), unresolveElement(result)) }

}