// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#ifndef CARBON_TOOLCHAIN_PARSE_NODE_IDS_H_
#define CARBON_TOOLCHAIN_PARSE_NODE_IDS_H_
#include "toolchain/base/index_base.h"
#include "toolchain/lex/token_index.h"
#include "toolchain/parse/node_kind.h"
namespace Carbon::Parse {
// Represents an invalid node id of any type
struct NoneNodeId {};
// A lightweight handle representing a node in the tree.
//
// Objects of this type are small and cheap to copy and store. They don't
// contain any of the information about the node, and serve as a handle that
// can be used with the underlying tree to query for detailed information.
struct NodeId : public IdBase<nodeid> {
 static constexpr llvm::StringLiteral Label = "node";
 // We give NodeId a bit in addition to TokenIndex in order to account for
 // virtual nodes, where a token may produce two nodes.
 static constexpr int32_t Bits = Lex::TokenIndex::Bits + 1;
 // The maximum ID, non-inclusive.
 static constexpr int Max = 1 << Bits; // A node ID with no value. static constexpr NoneNodeId None; constexpr explicit NodeId(int32_t index) : IdBase(index) { CARBON_DCHECK(index < Max, "Index out of range: {0}", index); } explicit(false) constexpr NodeId(NoneNodeId /*none*/) : IdBase(NoneIndex) {} }; // For looking up the type associated with a given id type. template <typename T>
struct NodeForId;
// `<kindname>Id` is a typed version of `NodeId` that references a node of kind
// `<kindname>`:
template <const NodeKind& K>
struct NodeIdForKind : public NodeId {
 // NOLINTNEXTLINE(readability-identifier-naming)
 static const NodeKind& Kind;
 // Provide a factory function for construction from `NodeId`. This doesn't
 // validate the type, so it's unsafe.
 static constexpr auto UnsafeMake(NodeId node_id) -> NodeIdForKind {
 return NodeIdForKind(node_id);
 }
 explicit(false) constexpr NodeIdForKind(NoneNodeId /*none*/)
 : NodeId(NoneIndex) {}
 private:
 // Private to prevent accidental explicit construction from an untyped
 // NodeId.
 explicit constexpr NodeIdForKind(NodeId node_id) : NodeId(node_id) {}
};
template <const NodeKind& K>
const NodeKind& NodeIdForKind<k>::Kind = K;
#define CARBON_PARSE_NODE_KIND(KindName) \
 using KindName##Id = NodeIdForKind<nodekind::kindname>;
#include "toolchain/parse/node_kind.def"
// NodeId that matches any NodeKind whose `category()` overlaps with `Category`.
template <nodecategory::rawenumtype Category>
struct NodeIdInCategory : public NodeId {
 // Provide a factory function for construction from `NodeId`. This doesn't
 // validate the type, so it's unsafe.
 static constexpr auto UnsafeMake(NodeId node_id) -> NodeIdInCategory {
 return NodeIdInCategory(node_id);
 }
 // Support conversion from `NodeIdForKind<kind>` if Kind's category
 // overlaps with `Category`.
 template <const NodeKind& Kind>
 explicit(false) NodeIdInCategory(NodeIdForKind<kind> node_id)
 : NodeId(node_id) {
 CARBON_CHECK(Kind.category().HasAnyOf(Category));
 }
 explicit(false) constexpr NodeIdInCategory(NoneNodeId /*none*/)
 : NodeId(NoneIndex) {}
 private:
 // Private to prevent accidental explicit construction from an untyped
 // NodeId.
 explicit constexpr NodeIdInCategory(NodeId node_id) : NodeId(node_id) {}
};
// Aliases for `NodeIdInCategory` to describe particular categories of nodes.
using AnyDeclId = NodeIdInCategory<nodecategory::decl>;
using AnyExprId = NodeIdInCategory<nodecategory::expr>;
using AnyImplAsId = NodeIdInCategory<nodecategory::implas>;
using AnyMemberAccessId =
 NodeIdInCategory<nodecategory::membername &#124; NodeCategory::MemberExpr &#124; NodeCategory::IntConst>;
using AnyModifierId = NodeIdInCategory<nodecategory::modifier>;
using AnyPatternId = NodeIdInCategory<nodecategory::pattern>;
using AnyStatementId =
 NodeIdInCategory<nodecategory::statement &#124; NodeCategory::Decl>;
using AnyRequirementId = NodeIdInCategory<nodecategory::requirement>;
using AnyNonExprNameId = NodeIdInCategory<nodecategory::nonexprname>;
using AnyPackageNameId = NodeIdInCategory<nodecategory::packagename>;
// NodeId with kind that matches one of the `T::Kind`s.
template <typename... T>
 requires(sizeof...(T)>= 2)
struct NodeIdOneOf : public NodeId {
 private:
 // True if `OtherT` is one of `T`.
 template <typename OtherT>
 static constexpr bool Contains = (std::is_same<othert, T>{} &#124;&#124; ...);
 // True if `NodeIdOneOf<subsett...>` is a subset of this `NodeIdOneOf`.
 template <typename Unused>
 static constexpr bool IsSubset = false;
 template <typename... SubsetT>
 static constexpr bool IsSubset<nodeidoneof<subsett...>> =
 (Contains<subsett> && ...);
 // Private to prevent accidental explicit construction from an untyped
 // NodeId.
 explicit constexpr NodeIdOneOf(NodeId node_id) : NodeId(node_id) {}
 public:
 // Provide a factory function for construction from `NodeId`. This doesn't
 // validate the type, so it's unsafe.
 static constexpr auto UnsafeMake(NodeId node_id) -> NodeIdOneOf {
 return NodeIdOneOf(node_id);
 }
 template <const NodeKind& Kind>
 requires(Contains<nodeidforkind<kind>>)
 explicit(false) NodeIdOneOf(NodeIdForKind<kind> node_id) : NodeId(node_id) {}
 template <typename OtherNodeIdOneOf>
 requires(IsSubset<othernodeidoneof>)
 explicit(false) NodeIdOneOf(OtherNodeIdOneOf node_id) : NodeId(node_id) {}
 explicit(false) constexpr NodeIdOneOf(NoneNodeId /*none*/)
 : NodeId(NoneIndex) {}
};
using AnyClassDeclId =
 NodeIdOneOf<classdeclid, ClassDefinitionStartId, // TODO: This may be wrong? But we have choice types produce a // class, so they are a form of class decls. This avoids // duplicating all of SemIR::ClassDecl. ChoiceDefinitionStartId>;
using AnyFunctionDeclId = NodeIdOneOf<functiondeclid, FunctionDefinitionStartId, BuiltinFunctionDefinitionStartId>;
using AnyImplDeclId = NodeIdOneOf<impldeclid, ImplDefinitionStartId>;
using AnyInterfaceDeclId =
 NodeIdOneOf<interfacedeclid, InterfaceDefinitionStartId>;
using AnyNamespaceId =
 NodeIdOneOf<namespaceid, ImportDeclId, LibraryDeclId, PackageDeclId>;
using AnyPackagingDeclId =
 NodeIdOneOf<importdeclid, LibraryDeclId, PackageDeclId>;
using AnyPointerDeferenceExprId =
 NodeIdOneOf<prefixoperatorstarid, PointerMemberAccessExprId>;
using AnyRuntimeBindingPatternName =
 NodeIdOneOf<identifiernamenotbeforeparamsid, SelfValueNameId, UnderscoreNameId>;
// NodeId with kind that is anything but T::Kind.
template <typename T>
struct NodeIdNot : public NodeId {
 constexpr explicit NodeIdNot(NodeId node_id) : NodeId(node_id) {}
 explicit(false) constexpr NodeIdNot(NoneNodeId /*none*/)
 : NodeId(NoneIndex) {}
};
// Note that the support for extracting these types using the `Tree::Extract*`
// functions is defined in `extract.cpp`.
} // namespace Carbon::Parse
#endif // CARBON_TOOLCHAIN_PARSE_NODE_IDS_H_
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="http://docs.carbon-lang.dev/toolchain/parse/node_ids.h">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="http://docs.carbon-lang.dev/toolchain/parse/node_ids.h" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>