Better error reporting for "using" related errors

Author: Git-i

include/yoyo/parser.h

@@ -23,7 +23,7 @@ namespace Yoyo
  std::unique_ptr<Statement> parseInterfaceDeclaration(Token identifier);
  std::unique_ptr<Statement> parseUnionDeclaration(Token identifier);
  std::unique_ptr<Statement> parseMacroDeclaration(Token identifier);
- std::unique_ptr<Statement> parseUsingDeclaration();
+ std::unique_ptr<Statement> parseUsingDeclaration(Token);
  std::unordered_map<std::string, std::unique_ptr<Expression>> parseObjectLiteral();
  std::unique_ptr<Statement> parseDeclaration();
  std::unique_ptr<Statement> parseReturnStatement(Token);

src/yoyo/constexpr_eval.cpp

@@ -20,7 +20,10 @@ namespace Yoyo
  ModuleBase* module = irgen->module;
  std::string hash = irgen->block_hash;
  Type tp{ .name = nexpr->text };
- irgen->apply_using(tp, module, hash);
+ if (auto err = irgen->apply_using(tp, module, hash)) {
+ err->span = SourceSpan{ nexpr->beg, nexpr->end };
+ irgen->error(*err);
+ }
  auto [blk, dets] = module->findConst(hash, nexpr->text);
  if (!dets)
  {

src/yoyo/error.cpp

@@ -77,10 +77,7 @@ namespace Yoyo
 std::string Error::to_string(const SourceView& view, bool enable_color) const
 {
 std::vector<std::string> lines;
-size_t begin = std::max(size_t(1), span.begin.line - 1);
-size_t end = std::min(view.lines.size() + 1, span.end.line + 2);
-for (auto line : std::views::iota(begin, end))
-{
+auto render_line = [this, &view, enable_color, &lines](size_t line) {
 std::string line_body(view.lines[line - 1]);
 //apply color for the portion of text that is in error
 if (enable_color && span.end.line >= line && span.begin.line <= line)
@@ -94,6 +91,24 @@ namespace Yoyo
 }
 lines.emplace_back(std::format("{: >4} │ {}\n", line, line_body));
 lines.emplace_back(markers_for(" ", enable_color, line, markers, view));
+};
+size_t begin = std::max(size_t(1), span.begin.line - 1);
+size_t end = std::min(view.lines.size() + 1, span.end.line + 2);
+std::vector<size_t> rendered_lines;
+for (auto line : std::views::iota(begin, end))
+{
+rendered_lines.push_back(line);
+render_line(line);
+}
+
+for (auto& marker : markers) {
+if (auto it = std::ranges::find(rendered_lines, marker.first.begin.line); it != rendered_lines.end())
+continue;
+lines.emplace_back("\n");
+for (auto line : std::views::iota(marker.first.begin.line, marker.first.end.line + 1)) {
+rendered_lines.push_back(line);
+render_line(line);
+}
 }
 auto result = std::format("{}{}:{}:{} error: {}{}\n",
 enable_color ? "\033[1;31m" : "",

src/yoyo/expression_type_checker.cpp

@@ -420,7 +420,10 @@ namespace Yoyo
  ModuleBase* module = irgen->module;
  std::string hash = irgen->block_hash;
  Type tp{ .name = expr->text };
- irgen->apply_using(tp, module, hash);
+ if (auto err = irgen->apply_using(tp, module, hash)) {
+ err->span = { expr->beg, expr->end };
+ irgen->error(*err);
+ }
  if(auto [name_prefix, fn] = module->findFunction(hash, expr->text); fn)
  {
  irgen->saturateSignature(fn->sig, irgen->module);

src/yoyo/ir_gen.cpp

@@ -398,7 +398,7 @@ namespace Yoyo
  if (auto hs = this_md->hashOf(this_hsh, tp.name); hs && *hs == this_hsh && contains(stat, tp.name)) {
  //ambiguous
  if (contributing_stat) {
- Error err(SourceSpan{}, "The name " + tp.name + " is ambiguous in this context");
+ Error err(SourceSpan{}, "The name \"" + tp.name + "\" is ambiguous in this context");
  err.markers.emplace_back(SourceSpan{ contributing_stat->beg, contributing_stat->end }, "Can be accessed from here");
  err.markers.emplace_back(SourceSpan{ stat->beg, stat->end }, "Can also be accessed from here");
  return err;
@@ -409,10 +409,10 @@ namespace Yoyo
  }
  }
  // remove this if ambiguity is resolved be how deep the declaration is
- if (contributing_stat) break;
+ //if (contributing_stat) break;
  }
  if (exists && contributing_stat) {
- Error err(SourceSpan{}, "The name " + tp.name + " exists in this context but is imported");
+ Error err(SourceSpan{}, "The name \"" + tp.name + "\" exists in this context but is imported");
  err.markers.emplace_back(SourceSpan{ contributing_stat->beg, contributing_stat->end }, "Import happens here");
  return err;
  }

src/yoyo/parser.cpp

@@ -122,7 +122,7 @@ namespace Yoyo
  auto iden = Get();
  if(!iden) return nullptr;
  if(iden->type == TokenType::Operator) return parseOperatorOverload(iden.value());
- if (iden->type == TokenType::Using) return parseUsingDeclaration();
+ if (iden->type == TokenType::Using) return parseUsingDeclaration(iden.value());
  if(iden->type != TokenType::Identifier) error("Expected Identifier", iden);
  Get();//discard the ':'
  auto look_ahead = Peek();
@@ -416,7 +416,7 @@ namespace Yoyo
  }
  std::unique_ptr<Statement> Parser::parseMacroDeclaration(Token identifier)
  {
- if (!discard(TokenType::Macro)) error("Expected 'union'", Peek());
+ if (!discard(TokenType::Macro)) error("Expected 'macro'", Peek());
  // only single param macros for now
  if (!discard(TokenType::LParen)) error("Expected '('", Peek());
  auto iden = Get();
@@ -441,7 +441,7 @@ namespace Yoyo
  auto end = decl->body->end;
  return Statement::attachSLAndParent(std::move(decl), identifier.loc, end, parent);
  }
- std::unique_ptr<Statement> Parser::parseUsingDeclaration()
+ std::unique_ptr<Statement> Parser::parseUsingDeclaration(Token using_tok)
  {
  // modify the behaviour of the type parser to allow for ::{...} and ::*
  in_using_stat = true;
@@ -450,7 +450,9 @@ namespace Yoyo
  if (!tp) return nullptr;
  if (!discard(TokenType::SemiColon)) { error("Expected ';'", Peek()); return nullptr; }
  if (tp->name == "__star__") {
- return std::make_unique<UsingStatement>(UsingStatement::UsingAll{ .block = tp->block_hash });
+ return Statement::attachSLAndParent(
+ std::make_unique<UsingStatement>(UsingStatement::UsingAll{ .block = tp->block_hash }),
+ using_tok.loc, discardLocation);
  }
  else if (tp->name == "__multi__") {
  //should have just used std::move tbh
@@ -459,17 +461,17 @@ namespace Yoyo
  std::ranges::transform(tp->subtypes, std::back_inserter(entities), [](const Type& t) { return t.name; });
  return entities;
  };
- return std::make_unique<UsingStatement>(UsingStatement::UsingMultiple{
+ return Statement::attachSLAndParent(std::make_unique<UsingStatement>(UsingStatement::UsingMultiple{
  .block = tp->block_hash,
  .entities = make_entities()
- });
+ }), using_tok.loc, discardLocation);
  }
  if (!tp->subtypes.empty()) { error("Cannot instantiate generics here", Peek()); }
 
- return std::make_unique<UsingStatement>(UsingStatement::UsingSingle{
+ return Statement::attachSLAndParent(std::make_unique<UsingStatement>(UsingStatement::UsingSingle{
  .block = tp->block_hash,
  .entity = tp->name
- });
+ }), using_tok.loc, discardLocation);
  }
  Attribute parseAttribute(Parser& p)
  {

src/yoyo/type.cpp

@@ -835,10 +835,12 @@ namespace Yoyo
  std::string FunctionSignature::pretty_name(const std::string& block_hash) const
  {
  std::string final_str = "fn(";
- if (parameters.size() >= 1) final_str.append(parameters[0].type.pretty_name(block_hash));
- for (auto& param : std::ranges::subrange(parameters.begin() + 1, parameters.end()))
- {
- final_str.append(", " + param.type.pretty_name(block_hash));
+ if (parameters.size() >= 1) {
+ final_str.append(parameters[0].type.pretty_name(block_hash));
+ for (auto& param : std::ranges::subrange(parameters.begin() + 1, parameters.end()))
+ {
+ final_str.append(", " + param.type.pretty_name(block_hash));
+ }
  }
  final_str.append(")");
  return final_str;

tests/ir_gen_test.cpp

@@ -269,6 +269,7 @@ Module2: struct = {
 }
 Module3: struct = {
  Type: struct = { to_str: fn(&this) -> str = return "Module 3 type"; }
+ print: fn = return;
 }
 using test::print;
 main: fn = {