mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-04 22:02:52 +01:00
Jon Ross-Perkins
6b5eb1a101
High level, replacing `Id::Invalid` with `Id::None` and `Id::is_valid` with `Id::has_value` for clarity, as discussed [here](https://discord.com/channels/655572317891461132/655578254970716160/1331664574545395794). The `IntId` refactoring is needed together with `AnyIdBase` because it's also used with `ValueStore`. Note, trying to be careful not to rewrite `EnumBase::InvalidIndex`, or `is_valid` in general (e.g., `IdKind::is_valid`). I've tried to sequence commits here: 1. Automatic replacements: - `((?:Id|Index)(?: |::|\(|Base(?:\(|::)))Invalid((?:Index)?\W)` -> `$1None$2` - `<invalid>` -> `<none>` - `InvalidNodeId` -> `NoneNodeId` - `/\*invalid\*/` -> `/*none*/` - `id((?:_|\(\))(?:\.|->))is_valid` -> `id$1has_value` 2. Manual edits: - In `int.h` and `int_test.cpp` - `IntT` has `is_value`, which I'm renaming to `is_embedded_value`. - Manual edits to comments in this file. - `AnyIdBase` and `IdBase` - Declaration of `is_valid` -> `has_value`, `InvalidIndex` -> `NoneIndex`. - In `ids.h` and `ids.cpp` - `is_valid` -> `has_value` - `// An explicitly invalid ID.` -> `// An ID with no value.`; similar for index - Various math on `InvalidIndex` -> `NoneIndex` - Various mentions of "valid" in comments - In `value_store.h`, for `IdT::Invalid`, plus one comment - In `impl.h` and `tokenized_buffer.h`, we had different initialization of `::None` values (versus `ids.h` syntax) that I fixed manually. - Spot checks to compile - Particularly where `is_valid` replacements didn't catch spots due to different naming. 3. Autoupdate tests 4. verbose.carbon (NOAUTOUPDATE) 5. Comment spot checks Note there are probably other mentions of "Invalid" that should be swept up, but I'd like to argue for merging and separating out remaining cleanup since this is so sweeping (and likely to hit merge conflicts from churn). We'll probably have lingering mentions of "invalid" for a bit regardless, just because there are uses of "invalid" in non-Id APIs.
88 lines
3.2 KiB
C++
88 lines
3.2 KiB
C++
// 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_CHECK_NODE_ID_TRAVERSAL_H_
|
|
#define CARBON_TOOLCHAIN_CHECK_NODE_ID_TRAVERSAL_H_
|
|
|
|
#include "common/ostream.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "toolchain/check/context.h"
|
|
#include "toolchain/check/deferred_definition_worklist.h"
|
|
#include "toolchain/parse/tree.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
// A traversal of the node IDs in the parse tree, in the order in which we need
|
|
// to check them.
|
|
class NodeIdTraversal {
|
|
public:
|
|
explicit NodeIdTraversal(Context& context, llvm::raw_ostream* vlog_stream);
|
|
|
|
// Finds the next `NodeId` to type-check. Returns nullopt if the traversal is
|
|
// complete.
|
|
auto Next() -> std::optional<Parse::NodeId>;
|
|
|
|
// Performs any processing necessary after we type-check a node.
|
|
auto Handle(Parse::NodeKind parse_kind) -> void;
|
|
|
|
private:
|
|
// State used to track the next deferred function definition that we will
|
|
// encounter and need to reorder.
|
|
class NextDeferredDefinitionCache {
|
|
public:
|
|
explicit NextDeferredDefinitionCache(const Parse::Tree* tree);
|
|
|
|
// Set the specified deferred definition index as being the next one that
|
|
// will be encountered.
|
|
auto SkipTo(Parse::DeferredDefinitionIndex next_index) -> void;
|
|
|
|
// Returns the index of the next deferred definition to be encountered.
|
|
auto index() const -> Parse::DeferredDefinitionIndex { return index_; }
|
|
|
|
// Returns the ID of the start node of the next deferred definition.
|
|
auto start_id() const -> Parse::NodeId { return start_id_; }
|
|
|
|
private:
|
|
const Parse::Tree* tree_;
|
|
Parse::DeferredDefinitionIndex index_ =
|
|
Parse::DeferredDefinitionIndex::None;
|
|
Parse::NodeId start_id_ = Parse::NodeId::None;
|
|
};
|
|
|
|
// A chunk of the parse tree that we need to type-check.
|
|
struct Chunk {
|
|
Parse::Tree::PostorderIterator it;
|
|
Parse::Tree::PostorderIterator end;
|
|
// The next definition that will be encountered after this chunk completes.
|
|
Parse::DeferredDefinitionIndex next_definition;
|
|
// Whether we are currently checking deferred definitions, rather than the
|
|
// tokens of this chunk. If so, we'll pull tasks off `worklist` and execute
|
|
// them until we're done with this batch of deferred definitions. Otherwise,
|
|
// we'll pull node IDs from `*it` until it reaches `end`.
|
|
bool checking_deferred_definitions = false;
|
|
};
|
|
|
|
// Re-enter a nested deferred definition scope.
|
|
auto PerformTask(
|
|
DeferredDefinitionWorklist::EnterDeferredDefinitionScope&& enter) -> void;
|
|
|
|
// Leave a nested or top-level deferred definition scope.
|
|
auto PerformTask(
|
|
DeferredDefinitionWorklist::LeaveDeferredDefinitionScope&& leave) -> void;
|
|
|
|
// Resume checking a deferred definition.
|
|
auto PerformTask(
|
|
DeferredDefinitionWorklist::CheckSkippedDefinition&& parse_definition)
|
|
-> void;
|
|
|
|
Context& context_;
|
|
NextDeferredDefinitionCache next_deferred_definition_;
|
|
DeferredDefinitionWorklist worklist_;
|
|
llvm::SmallVector<Chunk> chunks_;
|
|
};
|
|
|
|
} // namespace Carbon::Check
|
|
|
|
#endif // CARBON_TOOLCHAIN_CHECK_NODE_ID_TRAVERSAL_H_
|