Files
carbon-lang/toolchain/check/sem_ir_diagnostic_converter.cpp
T
Jon Ross-PerkinsandGeoff Romer 4c4c4a4d2c Add RawStringOstream for slightly simpler streaming to strings (#4817)
This adds a RawStringOstream. Versus TestRawOstream, which is
consolidated over to RawStringOstream, it uses a string for storage
instead of a vector, mainly to support move-to-string semantics. Versus
llvm::raw_string_ostream, it owns the string and supports pwrite (which
is needed for driver and its fd_ostream compatibility requirement).

This converts most uses of llvm::raw_string_ostream, leaving behind a
few in InstNamer that explicitly cannot own the string, such as:

```
     llvm::raw_string_ostream(name)
          << "_" << tree.tokens().GetColumnNumber(token);
```

I have this as its own library so that it can use CHECK.

Yes this doesn't save much code, but it's code we repeatedly write.

---------

Co-authored-by: Geoff Romer <gromer@google.com>
2025-01-18 01:11:44 +00:00

208 lines
7.8 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
#include "toolchain/check/sem_ir_diagnostic_converter.h"
#include "common/raw_string_ostream.h"
#include "toolchain/sem_ir/stringify_type.h"
namespace Carbon::Check {
auto SemIRDiagnosticConverter::ConvertLoc(SemIRLoc loc,
ContextFnT context_fn) const
-> ConvertedDiagnosticLoc {
auto converted = ConvertLocImpl(loc, context_fn);
// Use the token when possible, but -1 is the default value.
auto last_offset = -1;
if (last_token_.is_valid()) {
last_offset = sem_ir_->parse_tree().tokens().GetByteOffset(last_token_);
}
// When the diagnostic is in the same file, we use the last possible offset;
// otherwise, we ignore the offset because it's probably in that file.
if (converted.loc.filename == sem_ir_->filename()) {
converted.last_byte_offset =
std::max(converted.last_byte_offset, last_offset);
} else {
converted.last_byte_offset = last_offset;
}
return converted;
}
auto SemIRDiagnosticConverter::ConvertLocImpl(SemIRLoc loc,
ContextFnT context_fn) const
-> ConvertedDiagnosticLoc {
// Cursors for the current IR and instruction in that IR.
const auto* cursor_ir = sem_ir_;
auto cursor_inst_id = SemIR::InstId::Invalid;
// Notes an import on the diagnostic and updates cursors to point at the
// imported IR.
auto follow_import_ref = [&](SemIR::ImportIRInstId import_ir_inst_id) {
auto import_ir_inst = cursor_ir->import_ir_insts().Get(import_ir_inst_id);
const auto& import_ir = cursor_ir->import_irs().Get(import_ir_inst.ir_id);
CARBON_CHECK(import_ir.decl_id.is_valid(),
"If we get invalid locations here, we may need to more "
"thoroughly track ImportDecls.");
ConvertedDiagnosticLoc in_import_loc;
auto import_loc_id = cursor_ir->insts().GetLocId(import_ir.decl_id);
if (import_loc_id.is_node_id()) {
// For imports in the current file, the location is simple.
in_import_loc = ConvertLocInFile(cursor_ir, import_loc_id.node_id(),
loc.token_only, context_fn);
} else if (import_loc_id.is_import_ir_inst_id()) {
// For implicit imports, we need to unravel the location a little
// further.
auto implicit_import_ir_inst =
cursor_ir->import_ir_insts().Get(import_loc_id.import_ir_inst_id());
const auto& implicit_ir =
cursor_ir->import_irs().Get(implicit_import_ir_inst.ir_id);
auto implicit_loc_id =
implicit_ir.sem_ir->insts().GetLocId(implicit_import_ir_inst.inst_id);
CARBON_CHECK(implicit_loc_id.is_node_id(),
"Should only be one layer of implicit imports");
in_import_loc =
ConvertLocInFile(implicit_ir.sem_ir, implicit_loc_id.node_id(),
loc.token_only, context_fn);
}
// TODO: Add an "In implicit import of prelude." note for the case where we
// don't have a location.
if (import_loc_id.is_valid()) {
// TODO: Include the name of the imported library in the diagnostic.
CARBON_DIAGNOSTIC(InImport, LocationInfo, "in import");
context_fn(in_import_loc.loc, InImport);
}
cursor_ir = import_ir.sem_ir;
cursor_inst_id = import_ir_inst.inst_id;
};
// If the location is is an import, follows it and returns nullopt.
// Otherwise, it's a parse node, so return the final location.
auto handle_loc =
[&](SemIR::LocId loc_id) -> std::optional<ConvertedDiagnosticLoc> {
if (loc_id.is_import_ir_inst_id()) {
follow_import_ref(loc_id.import_ir_inst_id());
return std::nullopt;
} else {
// Parse nodes always refer to the current IR.
return ConvertLocInFile(cursor_ir, loc_id.node_id(), loc.token_only,
context_fn);
}
};
// Handle the base location.
if (loc.is_inst_id) {
cursor_inst_id = loc.inst_id;
} else {
if (auto diag_loc = handle_loc(loc.loc_id)) {
return *diag_loc;
}
CARBON_CHECK(cursor_inst_id.is_valid(), "Should have been set");
}
while (true) {
if (cursor_inst_id.is_valid()) {
auto cursor_inst = cursor_ir->insts().Get(cursor_inst_id);
if (auto bind_ref = cursor_inst.TryAs<SemIR::ExportDecl>();
bind_ref && bind_ref->value_id.is_valid()) {
cursor_inst_id = bind_ref->value_id;
continue;
}
// If the parse node is valid, use it for the location.
if (auto loc_id = cursor_ir->insts().GetLocId(cursor_inst_id);
loc_id.is_valid()) {
if (auto diag_loc = handle_loc(loc_id)) {
return *diag_loc;
}
continue;
}
// If a namespace has an instruction for an import, switch to looking at
// it.
if (auto ns = cursor_inst.TryAs<SemIR::Namespace>()) {
if (ns->import_id.is_valid()) {
cursor_inst_id = ns->import_id;
continue;
}
}
}
// Invalid parse node but not an import; just nothing to point at.
return ConvertLocInFile(cursor_ir, Parse::NodeId::Invalid, loc.token_only,
context_fn);
}
}
auto SemIRDiagnosticConverter::ConvertArg(llvm::Any arg) const -> llvm::Any {
if (auto* library_name_id = llvm::any_cast<SemIR::LibraryNameId>(&arg)) {
std::string library_name;
if (*library_name_id == SemIR::LibraryNameId::Default) {
library_name = "default library";
} else if (!library_name_id->is_valid()) {
library_name = "library <invalid>";
} else {
RawStringOstream stream;
stream << "library \""
<< sem_ir_->string_literal_values().Get(
library_name_id->AsStringLiteralValueId())
<< "\"";
library_name = stream.TakeStr();
}
return library_name;
}
if (auto* name_id = llvm::any_cast<SemIR::NameId>(&arg)) {
return sem_ir_->names().GetFormatted(*name_id).str();
}
if (auto* type_of_expr = llvm::any_cast<TypeOfInstId>(&arg)) {
if (!type_of_expr->inst_id.is_valid()) {
return "<none>";
}
// TODO: Where possible, produce a better description of the type based on
// the expression.
return "`" +
StringifyTypeExpr(
*sem_ir_,
sem_ir_->types().GetInstId(
sem_ir_->insts().Get(type_of_expr->inst_id).type_id())) +
"`";
}
if (auto* type_expr = llvm::any_cast<InstIdAsType>(&arg)) {
return "`" + StringifyTypeExpr(*sem_ir_, type_expr->inst_id) + "`";
}
if (auto* type_expr = llvm::any_cast<InstIdAsRawType>(&arg)) {
return StringifyTypeExpr(*sem_ir_, type_expr->inst_id);
}
if (auto* type = llvm::any_cast<TypeIdAsRawType>(&arg)) {
return StringifyTypeExpr(*sem_ir_,
sem_ir_->types().GetInstId(type->type_id));
}
if (auto* type_id = llvm::any_cast<SemIR::TypeId>(&arg)) {
return "`" +
StringifyTypeExpr(*sem_ir_, sem_ir_->types().GetInstId(*type_id)) +
"`";
}
if (auto* typed_int = llvm::any_cast<TypedInt>(&arg)) {
return llvm::APSInt(typed_int->value,
!sem_ir_->types().IsSignedInt(typed_int->type));
}
return DiagnosticConverter<SemIRLoc>::ConvertArg(arg);
}
auto SemIRDiagnosticConverter::ConvertLocInFile(const SemIR::File* sem_ir,
Parse::NodeId node_id,
bool token_only,
ContextFnT context_fn) const
-> ConvertedDiagnosticLoc {
return node_converters_[sem_ir->check_ir_id().index]->ConvertLoc(
Parse::NodeLoc(node_id, token_only), context_fn);
}
} // namespace Carbon::Check