From 42dd0e69f99bf5c66c3ed4c62af20d0e34eb7839 Mon Sep 17 00:00:00 2001
From: Dieter Baron <dillo@nih.at>
Date: Sat, 17 Aug 2024 16:19:26 +0200
Subject: [PATCH] Fix more warnings.

---
 src/AddressingModeMatcher.cc |  2 +-
 src/Assembler.cc             |  8 +++----
 src/BinaryExpression.cc      |  1 +
 src/BodyParser.cc            |  1 +
 src/CMakeLists.txt           |  1 -
 src/CPU.h                    |  4 ++--
 src/CPUParser.cc             |  8 +++----
 src/Callable.cc              |  5 ++---
 src/Callable.h               |  4 ++--
 src/Checksum.h               |  2 --
 src/ChecksumAlgorithm.cc     |  1 +
 src/ChecksumBody.cc          |  4 +---
 src/ChecksumBody.h           |  1 +
 src/Command.cc               |  1 -
 src/Command.h                |  2 ++
 src/Commandline.cc           |  3 +--
 src/Commandline.h            |  1 -
 src/DataBody.h               |  2 +-
 src/EvaluationContext.cc     |  1 +
 src/FileTokenizer.cc         |  6 ++---
 src/Function.h               |  2 +-
 src/Instruction.h            |  3 +--
 src/InstructionEncoder.cc    |  5 +++--
 src/InstructionEncoder.h     |  4 +---
 src/IntegerEncoder.h         |  1 -
 src/LabelBody.h              |  3 +--
 src/LabelExpression.cc       |  6 ++---
 src/LabelExpression.h        |  8 +++----
 src/Macro.cc                 |  3 ---
 src/Macro.h                  |  1 -
 src/MacroBody.cc             |  3 +--
 src/MacroBody.h              |  2 +-
 src/Memory.cc                |  3 +--
 src/MemoryBody.cc            |  5 +++--
 src/MemoryBody.h             |  1 -
 src/MemoryMap.cc             |  2 +-
 src/Object.h                 |  1 -
 src/ObjectFile.cc            | 35 +++++++++++++++--------------
 src/ObjectFile.h             |  6 ++---
 src/ObjectFileParser.h       |  2 --
 src/ParseException.cc        |  8 +++----
 src/ParseException.h         | 14 +++++-------
 src/ParsedValue.h            |  5 +++--
 src/Range.cc                 |  1 -
 src/SequenceTokenizer.cc     |  2 +-
 src/SequenceTokenizer.h      |  4 ++--
 src/SizeRange.cc             |  3 +--
 src/StringEncoding.cc        |  2 +-
 src/Symbol.cc                |  7 ++----
 src/TargetParser.cc          |  5 ++---
 src/TargetParser.h           |  2 +-
 src/Token.cc                 |  2 ++
 src/Token.h                  | 12 +++++-----
 src/TokenGroup.h             |  2 +-
 src/Tokenizer.cc             |  4 ++--
 src/Tokenizer.h              |  4 ++--
 src/UnaryExpression.cc       |  1 +
 src/Unresolved.cc            |  2 +-
 src/Value.h                  |  1 -
 src/VariableEntity.cc        | 32 ---------------------------
 src/VariableEntity.h         | 43 ------------------------------------
 src/xlr8.cc                  |  2 --
 62 files changed, 105 insertions(+), 207 deletions(-)
 delete mode 100644 src/VariableEntity.cc
 delete mode 100644 src/VariableEntity.h

diff --git a/src/AddressingModeMatcher.cc b/src/AddressingModeMatcher.cc
index 7d31e43..d2efc02 100644
--- a/src/AddressingModeMatcher.cc
+++ b/src/AddressingModeMatcher.cc
@@ -91,7 +91,7 @@ AddressingModeMatcherElement::elements_for(const AddressingMode::Notation::Eleme
 
     switch (element.type) {
         case AddressingMode::Notation::ARGUMENT: {
-            auto it = arguments.find(element.symbol);
+            const auto it = arguments.find(element.symbol);
             if (it == arguments.end()) {
                 throw Exception("unknown argument '%s'", element.symbol.c_str());
             }
diff --git a/src/Assembler.cc b/src/Assembler.cc
index 34fd2e6..2d34b72 100644
--- a/src/Assembler.cc
+++ b/src/Assembler.cc
@@ -171,10 +171,10 @@ void Assembler::parse_assignment(Visibility visibility, const Token& name, bool
 }
 
 void Assembler::parse_cpu() {
-    auto name = tokenizer.expect(Token::STRING, TokenGroup::newline);
+    const auto name = tokenizer.expect(Token::STRING, TokenGroup::newline);
 
     try {
-        auto new_cpu = &CPU::get(name.as_symbol(), tokenizer.current_file());
+        const auto new_cpu = &CPU::get(name.as_symbol(), tokenizer.current_file());
 
         if (target) {
             had_cpu = true;
@@ -489,9 +489,7 @@ void Assembler::parse_visibility() {
 }
 
 void Assembler::set_target(const Target* new_target) {
-    if (target) {
-        // TODO: check that target and new_target are compatible
-    }
+    // TODO: check that target and new_target are compatible
     target = new_target;
     if (target) {
         tokenizer.set_target(target);
diff --git a/src/BinaryExpression.cc b/src/BinaryExpression.cc
index 3cb00f0..1a6d13b 100644
--- a/src/BinaryExpression.cc
+++ b/src/BinaryExpression.cc
@@ -31,6 +31,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BinaryExpression.h"
 
+#include "Exception.h"
 #include "VariableExpression.h"
 
 std::optional<Expression> BinaryExpression::evaluated(const EvaluationContext& context) const {
diff --git a/src/BodyParser.cc b/src/BodyParser.cc
index 5dd53cb..e4f3b90 100644
--- a/src/BodyParser.cc
+++ b/src/BodyParser.cc
@@ -478,6 +478,7 @@ void BodyParser::parse_error() {
     else {
         tokenizer.unget(token);
     }
+    throw ParseException(location, message.as_string());
 }
 
 void BodyParser::parse_unnamed_label() { current_body->append(Body(Symbol(), current_size())); }
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6f6ac81..e799ff8 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -95,7 +95,6 @@ add_library(xlr8-library STATIC
         Util.cc
         Value.cc
         ValueExpression.cc
-        VariableEntity.cc
         VariableExpression.cc
         Visibility.cc
         VoidExpression.cc)
diff --git a/src/CPU.h b/src/CPU.h
index 3f9b77d..12a3883 100644
--- a/src/CPU.h
+++ b/src/CPU.h
@@ -59,9 +59,9 @@ class CPU {
 
     void setup(FileTokenizer& tokenizer) const;
 
-    [[nodiscard]] bool uses_empty_mnemonic() const {return instructions.find(Symbol()) != instructions.end();}
+    [[nodiscard]] bool uses_empty_mnemonic() const {return instructions.contains(Symbol());}
     [[nodiscard]] bool uses_braces() const {return uses_punctuation(Symbol("("));}
-    [[nodiscard]] bool uses_punctuation(Symbol symbol) const {return punctuation.find(symbol) != punctuation.end();}
+    [[nodiscard]] bool uses_punctuation(Symbol symbol) const {return punctuation.contains(symbol);}
 
 private:
     std::unordered_map<Symbol, AddressingMode> addressing_modes;
diff --git a/src/CPUParser.cc b/src/CPUParser.cc
index 44c2a03..ff44a2a 100644
--- a/src/CPUParser.cc
+++ b/src/CPUParser.cc
@@ -167,8 +167,7 @@ void CPUParser::parse_addressing_mode() {
                 default_value = Value{default_value_token.as_value()};
             }
             addressing_mode.arguments[pair.first.as_symbol()] = std::make_unique<AddressingMode::Argument>(argument_type, default_value);
-            auto encoding_argument_type = argument_type->as_encoding();
-            if (encoding_argument_type) {
+            if (argument_type->is_encoding()) {
                 auto argument_variable_name = pair.first.as_symbol();
                 unencoded_encoding_arguments.insert(argument_variable_name);
             }
@@ -280,8 +279,7 @@ void CPUParser::parse_argument_type() {
             throw ParseException(type, "unknown argument type '%s'", type.as_string().c_str());
         }
         argument_type = (this->*it->second)(name, parameters.get());
-        auto encoding_type = argument_type->as_encoding();
-        if (encoding_type) {
+        if (auto encoding_type = argument_type->as_encoding()) {
             auto range_name = Symbol(".range(" + name.as_string() + ")");
             cpu.add_argument_type(range_name, encoding_type->range_type(range_name));
         }
@@ -321,7 +319,7 @@ void CPUParser::parse_instruction() {
         if (!pair.first.is_name()) {
             throw ParseException(pair.first, "addressing mode must be name");
         }
-        if (addressing_mode_names.find(pair.first) == addressing_mode_names.end()) {
+        if (!addressing_mode_names.contains(pair.first)) {
             throw ParseException(pair.first, "unknown addressing mode");
         }
         auto it = instruction.opcodes.find(pair.first.as_symbol());
diff --git a/src/Callable.cc b/src/Callable.cc
index b894952..3a84341 100644
--- a/src/Callable.cc
+++ b/src/Callable.cc
@@ -48,7 +48,7 @@ void Callable::initialize() {
     }
 }
 
-Callable::Callable(ObjectFile* owner, Token name_, const std::shared_ptr<ParsedValue>& definition): Entity(owner, name_, definition) {
+Callable::Callable(ObjectFile* owner, const Token& name_, const std::shared_ptr<ParsedValue>& definition): Entity(owner, name_, definition) {
     initialize();
     auto parameters = definition->as_dictionary();
 
@@ -88,8 +88,7 @@ void Callable::Arguments::serialize(std::ostream& stream) const {
             stream << ", ";
         }
         stream << name(index);
-        auto value = default_argument(index);
-        if (value) {
+        if (auto value = default_argument(index)) {
             stream << " = " << *value;
         }
     }
diff --git a/src/Callable.h b/src/Callable.h
index 9d06426..6dce6b7 100644
--- a/src/Callable.h
+++ b/src/Callable.h
@@ -55,8 +55,8 @@ class Callable: public Entity {
         std::vector<Expression> default_arguments;
     };
 
-    Callable(ObjectFile* owner, Token name, const std::shared_ptr<ParsedValue>& definition);
-    Callable(ObjectFile* owner, Token name, Visibility visibility, bool default_only, Arguments arguments): Entity(owner, name, visibility, default_only), arguments(std::move(arguments)) {}
+    Callable(ObjectFile* owner, const Token& name, const std::shared_ptr<ParsedValue>& definition);
+    Callable(ObjectFile* owner, const Token& name, Visibility visibility, bool default_only, Arguments arguments): Entity(owner, name, visibility, default_only), arguments(std::move(arguments)) {}
     [[nodiscard]] Symbol argument_name(size_t index) const {return arguments.name(index);}
     [[nodiscard]] std::optional<Expression> default_argument(size_t index) const {return arguments.default_argument(index);}
 
diff --git a/src/Checksum.h b/src/Checksum.h
index dae507d..216a4f9 100644
--- a/src/Checksum.h
+++ b/src/Checksum.h
@@ -32,8 +32,6 @@ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include <cstdint>
-
 #include "Symbol.h"
 #include "Value.h"
 
diff --git a/src/ChecksumAlgorithm.cc b/src/ChecksumAlgorithm.cc
index bc9fbbd..f301393 100644
--- a/src/ChecksumAlgorithm.cc
+++ b/src/ChecksumAlgorithm.cc
@@ -32,6 +32,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "ChecksumAlgorithm.h"
 
 #include "ChecksumAlgorithmXor.h"
+#include "Exception.h"
 
 // clang-format off
 const std::unordered_map<Symbol, std::shared_ptr<ChecksumAlgorithm>(*)(Symbol)> ChecksumAlgorithm::algorithms = {
diff --git a/src/ChecksumBody.cc b/src/ChecksumBody.cc
index e2c06ad..5e3c25a 100644
--- a/src/ChecksumBody.cc
+++ b/src/ChecksumBody.cc
@@ -33,7 +33,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Body.h"
 #include "ExpressionParser.h"
 #include "ParseException.h"
-#include "VariableExpression.h"
 
 Body ChecksumBody::parse(Tokenizer& tokenizer) {
     auto algorithm_name = tokenizer.next();
@@ -79,8 +78,7 @@ std::optional<Body> ChecksumBody::evaluated(const EvaluationContext& context) co
     auto new_parameters = parameters;
     auto fully_evaluated = new_start.value_or(start).has_value() && new_end.value_or(end).has_value();
     for (auto& [name, expression] : parameters) {
-        auto new_expression = expression.evaluated(context);
-        if (new_expression) {
+        if (auto new_expression = expression.evaluated(context)) {
             new_parameters[name] = *new_expression;
             if (!new_expression->has_value()) {
                 fully_evaluated = false;
diff --git a/src/ChecksumBody.h b/src/ChecksumBody.h
index 777813c..4dd78c4 100644
--- a/src/ChecksumBody.h
+++ b/src/ChecksumBody.h
@@ -36,6 +36,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BodyElement.h"
 #include "ChecksumAlgorithm.h"
+#include "Exception.h"
 #include "Symbol.h"
 
 class ChecksumBody: public BodyElement {
diff --git a/src/Command.cc b/src/Command.cc
index ea1fe86..52c8330 100644
--- a/src/Command.cc
+++ b/src/Command.cc
@@ -35,7 +35,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <utility>
 
 #include "config.h"
 
diff --git a/src/Command.h b/src/Command.h
index 718f8d8..f26a3ad 100644
--- a/src/Command.h
+++ b/src/Command.h
@@ -40,6 +40,8 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class Command {
 public:
     Command(const std::vector<Commandline::Option>& options, std::string arguments, const std::string& name);
+    virtual ~Command() = default;
+
     int run(int argc, char * const argv[]);
 
     std::string program_name;
diff --git a/src/Commandline.cc b/src/Commandline.cc
index 588b145..0db4e37 100644
--- a/src/Commandline.cc
+++ b/src/Commandline.cc
@@ -38,7 +38,6 @@
 #include <sstream>
 #include <iostream>
 #include <unordered_map>
-#include <utility>
 
 Commandline::Commandline(std::vector<Option> options_, std::string arguments_, std::string header_, std::string footer_, std::string version_) : options(std::move(options_)), arguments(std::move(arguments_)), header(std::move(header_)), footer(std::move(footer_)), version(std::move(version_)), options_sorted(false) {
     add_option(Option("help", 'h', "display this help message"));
@@ -166,7 +165,7 @@ std::optional<std::string> ParsedCommandline::find_first(const std::string &name
 }
 
 [[maybe_unused]] std::optional<std::string> ParsedCommandline::find_last(const std::string &name) const {
-    for (auto it = options.rbegin(); it != options.rend(); it++) {
+    for (auto it = options.rbegin(); it != options.rend(); ++it) {
         const auto &option = *it;
 
         if (option.name == name) {
diff --git a/src/Commandline.h b/src/Commandline.h
index bc2b88b..cbe6210 100644
--- a/src/Commandline.h
+++ b/src/Commandline.h
@@ -37,7 +37,6 @@
 
 #include <optional>
 #include <string>
-#include <utility>
 #include <vector>
 
 class ParsedCommandline {
diff --git a/src/DataBody.h b/src/DataBody.h
index fd48ba5..5ebedd0 100644
--- a/src/DataBody.h
+++ b/src/DataBody.h
@@ -41,7 +41,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 class DataBodyElement {
 public:
-    DataBodyElement(Expression expression, std::optional<Encoder> encoding): expression(std::move(expression)), encoding(encoding) {}
+    DataBodyElement(Expression expression, std::optional<Encoder> encoding): expression(std::move(expression)), encoding(std::move(encoding)) {}
 
     [[nodiscard]] std::optional<uint64_t> size() const {return size_range().size();}
     [[nodiscard]] SizeRange size_range() const;
diff --git a/src/EvaluationContext.cc b/src/EvaluationContext.cc
index 75afc72..f53c570 100644
--- a/src/EvaluationContext.cc
+++ b/src/EvaluationContext.cc
@@ -32,6 +32,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "EvaluationContext.h"
 
 #include "Entity.h"
+#include "Exception.h"
 
 EvaluationContext::EvaluationContext(EvaluationResult& result, EvaluationType type, std::shared_ptr<Environment> environment, std::unordered_set<Symbol> defines, const SizeRange& offset): type(type), environment(std::move(environment)), defines{std::move(defines)}, offset(offset), result(result) {
     if (type == MACRO_EXPANSION) {
diff --git a/src/FileTokenizer.cc b/src/FileTokenizer.cc
index 8a0d971..ce42a2c 100644
--- a/src/FileTokenizer.cc
+++ b/src/FileTokenizer.cc
@@ -60,7 +60,7 @@ const std::unordered_map<Token, FileTokenizer::PreprocessorDirective> FileTokeni
 };
 // clang-format on
 
-FileTokenizer::FileTokenizer(const Path& path, const Target* target, bool use_preprocessor, const std::unordered_set<Symbol>& defines) : path{path}, use_preprocessor{use_preprocessor}, defines{defines}, target{target} {
+FileTokenizer::FileTokenizer(const Path& path, const Target* target, bool use_preprocessor, const std::unordered_set<Symbol>& defines) : defines{defines}, use_preprocessor{use_preprocessor}, path{path}, target{target} {
     if (use_preprocessor) {
         add_literal(token_define);
         add_literal(token_include);
@@ -616,7 +616,7 @@ void FileTokenizer::Source::reset_to(const Location& new_location) {
     column = new_location.start_column;
 }
 
-std::optional<Token::Type> FileTokenizer::MatcherNode::match(FileTokenizer::Source& source, std::string& name) {
+std::optional<Token::Type> FileTokenizer::MatcherNode::match(FileTokenizer::Source& source, std::string& name) { // NOLINT(misc-no-recursion)
     auto c = source.next();
     if (c == EOF) {
         if (name.empty()) {
@@ -665,7 +665,7 @@ std::optional<Token::Type> FileTokenizer::MatcherNode::match(FileTokenizer::Sour
     return it->second->match(source, name);
 }
 
-void FileTokenizer::MatcherNode::add(const char* string, Token::Type type, const std::unordered_set<char>& new_suffix, bool match_in_word_) {
+void FileTokenizer::MatcherNode::add(const char* string, Token::Type type, const std::unordered_set<char>& new_suffix, bool match_in_word_) { // NOLINT(misc-no-recursion)
     if (string[0] == '\0') {
         if (match_type.has_value() && (match_type.value() != type || match_in_word != match_in_word_)) {
             throw Exception("literal already defined with different type"); // TODO: include more detail
diff --git a/src/Function.h b/src/Function.h
index 835f100..2ae998a 100644
--- a/src/Function.h
+++ b/src/Function.h
@@ -37,7 +37,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class Function: public Callable {
   public:
     Function(ObjectFile* owner, const Token& name, const std::shared_ptr<ParsedValue>& definition);
-    Function(ObjectFile* owner, Token name, Visibility visibility, bool default_only, Arguments arguments, Expression definition): Callable(owner, name, visibility, default_only, std::move(arguments)), definition(definition) {}
+    Function(ObjectFile* owner, const Token& name, Visibility visibility, bool default_only, Arguments arguments, const Expression& definition): Callable(owner, name, visibility, default_only, std::move(arguments)), definition(definition) {}
     Expression call(const Location& location, const std::vector<Expression>& arguments) const;
     void serialize(std::ostream& stream) const;
 
diff --git a/src/Instruction.h b/src/Instruction.h
index 7924782..4f04dbd 100644
--- a/src/Instruction.h
+++ b/src/Instruction.h
@@ -34,12 +34,11 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <string>
 
-#include "BaseExpression.h"
 #include "Symbol.h"
 
 class Instruction {
 public:
-    bool has_addressing_mode(Symbol addressing_mode) const {return opcodes.find(addressing_mode) != opcodes.end();}
+    bool has_addressing_mode(Symbol addressing_mode) const {return opcodes.contains(addressing_mode);}
     uint64_t opcode(Symbol addressing_mode) const;
 
     std::unordered_map<Symbol, uint64_t> opcodes; // keys are addressing modes
diff --git a/src/InstructionEncoder.cc b/src/InstructionEncoder.cc
index 835fa69..83964b1 100644
--- a/src/InstructionEncoder.cc
+++ b/src/InstructionEncoder.cc
@@ -34,12 +34,13 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <algorithm>
 
 #include "Assembler.h"
+#include "ExpressionNode.h"
+#include "InRangeExpression.h"
 #include "ParseException.h"
 #include "TokenNode.h"
-#include "ExpressionNode.h"
 #include "Util.h"
 
-Body InstructionEncoder::encode(const Token& name, const std::vector<std::shared_ptr<Node>>& arguments, const std::shared_ptr<Environment>& environment, const SizeRange& offset, bool& uses_pc) {
+Body InstructionEncoder::encode(const Token& name, const std::vector<std::shared_ptr<Node>>& arguments, const std::shared_ptr<Environment>& environment, const SizeRange& offset, bool& uses_pc) const {
     const auto instruction = cpu->instruction(name.as_symbol());
     if (instruction == nullptr) {
         throw ParseException(name, "unknown instruction '%s'", name.as_string().c_str());
diff --git a/src/InstructionEncoder.h b/src/InstructionEncoder.h
index 309a065..e3b5b3f 100644
--- a/src/InstructionEncoder.h
+++ b/src/InstructionEncoder.h
@@ -36,8 +36,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Target.h"
 #include "IfBody.h"
 #include "DataBody.h"
-#include "InRangeExpression.h"
-#include "ValueExpression.h"
 #include "LabelBody.h"
 
 
@@ -45,7 +43,7 @@ class InstructionEncoder {
 public:
     explicit InstructionEncoder(const CPU* cpu): cpu(cpu) {}
 
-    [[nodiscard]] Body encode(const Token& name, const std::vector<std::shared_ptr<Node>>& arguments, const std::shared_ptr<Environment>& environment, const SizeRange& offset, bool& uses_pc);
+    [[nodiscard]] Body encode(const Token& name, const std::vector<std::shared_ptr<Node>>& arguments, const std::shared_ptr<Environment>& environment, const SizeRange& offset, bool& uses_pc) const;
 
 private:
     class Variant {
diff --git a/src/IntegerEncoder.h b/src/IntegerEncoder.h
index 36ee754..b73054a 100644
--- a/src/IntegerEncoder.h
+++ b/src/IntegerEncoder.h
@@ -33,7 +33,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INTEGER_ENCODER_H
 
 #include "BaseEncoder.h"
-#include "BaseExpression.h"
 #include "Environment.h"
 #include "Value.h"
 
diff --git a/src/LabelBody.h b/src/LabelBody.h
index 4e36dd8..0e77385 100644
--- a/src/LabelBody.h
+++ b/src/LabelBody.h
@@ -33,14 +33,13 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define LABEL_BODY_H
 
 #include "Body.h"
-#include "Value.h"
 #include "Exception.h"
 #include "SizeRange.h"
 
 class LabelBody: public BodyElement {
 public:
     explicit LabelBody(Symbol name): name(name) {}
-    LabelBody(Symbol name, SizeRange offset, bool added_to_environment, size_t unnamed_index): name(name), offset(offset), added_to_environment(added_to_environment), unnamed_index(unnamed_index) {}
+    LabelBody(Symbol name, const SizeRange& offset, bool added_to_environment, size_t unnamed_index): name(name), offset(offset), unnamed_index(unnamed_index), added_to_environment(added_to_environment) {}
 
     void encode(std::string &bytes, const Memory* memory) const override {}
     [[nodiscard]] bool empty() const override {return added_to_environment && offset.size();}
diff --git a/src/LabelExpression.cc b/src/LabelExpression.cc
index bf03be5..8d6c81c 100644
--- a/src/LabelExpression.cc
+++ b/src/LabelExpression.cc
@@ -39,7 +39,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "VariableExpression.h"
 #include <complex>
 
-LabelExpression::LabelExpression(const Location& location, const Entity* object, Symbol label_name, SizeRange offset) : BaseExpression(location), label_type(LabelExpressionType::NAMED), object(object), object_name(object ? object->name.as_symbol() : Symbol()), label_name(label_name), offset(offset) {}
+LabelExpression::LabelExpression(const Location& location, const Entity* object, Symbol label_name, const SizeRange& offset) : BaseExpression(location), label_type(LabelExpressionType::NAMED), object_name(object ? object->name.as_symbol() : Symbol()), label_name(label_name), object(object), offset(offset) {}
 
 Expression LabelExpression::create(const Location& location, const std::vector<Expression>& arguments) {
     if (arguments.size() == 1) {
@@ -70,7 +70,7 @@ Expression LabelExpression::create(const Location& location, const std::vector<E
     else if (arguments.size() == 2) {
         auto object_name = arguments[0].as_variable();
         auto label_name = arguments[1].as_variable();
-        if (object_name || label_name) {
+        if (object_name && label_name) {
             return Expression(std::make_shared<LabelExpression>(location, object_name->variable(),                label_name->variable()));
         }
         else {
@@ -83,7 +83,7 @@ Expression LabelExpression::create(const Location& location, const std::vector<E
 
 }
 
-Expression LabelExpression::create(const Location& location, const Entity* object, Symbol label_name, SizeRange offset, SizeRange scope_offset, bool keep) {
+Expression LabelExpression::create(const Location& location, const Entity* object, Symbol label_name, const SizeRange& offset, const SizeRange& scope_offset, bool keep) {
     if (!keep && offset.has_size() && scope_offset.has_size()) {
         return {location, Expression({}, *offset.size()), Expression::ADD, Expression({}, *scope_offset.size())};
     }
diff --git a/src/LabelExpression.h b/src/LabelExpression.h
index 3655474..dd4c597 100644
--- a/src/LabelExpression.h
+++ b/src/LabelExpression.h
@@ -38,11 +38,11 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class LabelExpression: public BaseExpression {
 public:
     LabelExpression(const Location& location, Symbol object_name, Symbol label_name): BaseExpression(location), label_type(LabelExpressionType::NAMED), object_name(object_name), label_name(label_name) {}
-    LabelExpression(const Location& location, Symbol object_name, Symbol label_name, SizeRange offset): BaseExpression(location), label_type(LabelExpressionType::NAMED), object_name(object_name), label_name(label_name), offset(offset) {}
-    LabelExpression(const Location& location, const Entity* object, Symbol label_name, SizeRange offset);
-    LabelExpression(const Location& location, LabelExpressionType type, size_t unnamed_index, SizeRange offset): BaseExpression(location), label_type(type), offset(offset), unnamed_index(unnamed_index) {}
+    LabelExpression(const Location& location, Symbol object_name, Symbol label_name, const SizeRange& offset): BaseExpression(location), label_type(LabelExpressionType::NAMED), object_name(object_name), label_name(label_name), offset(offset) {}
+    LabelExpression(const Location& location, const Entity* object, Symbol label_name, const SizeRange& offset);
+    LabelExpression(const Location& location, LabelExpressionType type, size_t unnamed_index, const SizeRange& offset): BaseExpression(location), label_type(type), offset(offset), unnamed_index(unnamed_index) {}
 
-    static Expression create(const Location& location, const Entity* object, Symbol label_name, SizeRange offset, SizeRange scope_offset = SizeRange(0), bool keep = false);
+    static Expression create(const Location& location, const Entity* object, Symbol label_name, const SizeRange& offset, const SizeRange& scope_offset = SizeRange(0), bool keep = false);
     static Expression create(const Location& location, const std::vector<Expression>& arguments);
     static Expression create(const Location& location, LabelExpressionType type, size_t unnamed_index = std::numeric_limits<size_t>::max(), SizeRange offset = SizeRange(0, {}));
 
diff --git a/src/Macro.cc b/src/Macro.cc
index 7aa6147..3d16504 100644
--- a/src/Macro.cc
+++ b/src/Macro.cc
@@ -31,9 +31,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Macro.h"
 
-#include <utility>
-#include "Exception.h"
-
 bool Macro::initialized = false;
 Token Macro::token_body;
 
diff --git a/src/Macro.h b/src/Macro.h
index e300c1c..b132f8c 100644
--- a/src/Macro.h
+++ b/src/Macro.h
@@ -34,7 +34,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Body.h"
 #include "Callable.h"
-#include "Symbol.h"
 
 class Macro: public Callable {
   public:
diff --git a/src/MacroBody.cc b/src/MacroBody.cc
index 43ffbb1..766d229 100644
--- a/src/MacroBody.cc
+++ b/src/MacroBody.cc
@@ -39,8 +39,7 @@ std::optional<Body> MacroBody::evaluated(const EvaluationContext& context) const
     auto new_macro = macro;
     auto changed = false;
     for (auto& argument: arguments) {
-        auto new_argument = argument.evaluated(context);
-        if (new_argument) {
+        if (auto new_argument = argument.evaluated(context)) {
             new_arguments.emplace_back(*new_argument);
             changed = true;
         }
diff --git a/src/MacroBody.h b/src/MacroBody.h
index d663ac2..f0b873b 100644
--- a/src/MacroBody.h
+++ b/src/MacroBody.h
@@ -38,7 +38,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 class MacroBody: public BodyElement {
   public:
-    MacroBody(Token name, std::vector<Expression> arguments, const Macro* macro = {}): BodyElement(SizeRange(0,{})), name(name), arguments(std::move(arguments)), macro(macro) {}
+    MacroBody(const Token& name, std::vector<Expression> arguments, const Macro* macro = {}): BodyElement(SizeRange(0,{})), name(name), macro(macro), arguments(std::move(arguments)) {}
 
     [[nodiscard]] std::shared_ptr<BodyElement> clone() const override {throw Exception("can't clone MacroBody");}
     [[nodiscard]] bool empty() const override {return false;}
diff --git a/src/Memory.cc b/src/Memory.cc
index 672c809..275e12d 100644
--- a/src/Memory.cc
+++ b/src/Memory.cc
@@ -36,7 +36,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <sstream>
 
 #include "Exception.h"
-#include "Int.h"
 
 Memory::Bank::Bank(Range range) : range(range) {
     memory = std::string(range.size, 0);
@@ -58,7 +57,7 @@ std::optional<uint64_t> Memory::Bank::allocate(const Range& allowed_range, Memor
         return {};
     }
 
-    for (auto it = blocks.begin(); it != blocks.end(); it++) {
+    for (auto it = blocks.begin(); it != blocks.end(); ++it) {
         if (it->allocation != FREE) {
             continue;
         }
diff --git a/src/MemoryBody.cc b/src/MemoryBody.cc
index 8335b7c..b9998bd 100644
--- a/src/MemoryBody.cc
+++ b/src/MemoryBody.cc
@@ -31,10 +31,11 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "MemoryBody.h"
 
+#include "Exception.h"
+
 MemoryBody::MemoryBody(Expression bank_, Expression start_address_, Expression end_address_): bank(std::move(bank_)), start_address(std::move(start_address_)), end_address(std::move(end_address_)) {
     auto minimum_start = start_address.minimum_value().value_or(Value(uint64_t{0}));
-    auto maximum_end = end_address.maximum_value();
-    if (maximum_end) {
+    if (auto maximum_end = end_address.maximum_value()) {
         size_range_.maximum = maximum_end->unsigned_value() - minimum_start.unsigned_value() + 1;
     }
 
diff --git a/src/MemoryBody.h b/src/MemoryBody.h
index 99017a8..dbd365d 100644
--- a/src/MemoryBody.h
+++ b/src/MemoryBody.h
@@ -33,7 +33,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define MEMORY_BODY_H
 
 #include "Body.h"
-#include "Exception.h"
 
 class MemoryBody: public BodyElement {
 public:
diff --git a/src/MemoryMap.cc b/src/MemoryMap.cc
index a309bb9..cf9907f 100644
--- a/src/MemoryMap.cc
+++ b/src/MemoryMap.cc
@@ -108,7 +108,7 @@ bool MemoryMap::is_abstract() const {
 }
 
 bool MemoryMap::is_compatible_with(const MemoryMap &other) const {
-    return std::all_of(other.sections.begin(), other.sections.end(), [this](const auto& pair) {
+    return std::ranges::all_of(other.sections, [this](const auto& pair) {
         auto& other_section = pair.second;
         auto this_section = section(pair.first);
         if (this_section == nullptr) {
diff --git a/src/Object.h b/src/Object.h
index 2893c55..50aa56e 100644
--- a/src/Object.h
+++ b/src/Object.h
@@ -33,7 +33,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define OBJECT_H
 
 #include <set>
-#include <vector>
 
 #include "Address.h"
 #include "Body.h"
diff --git a/src/ObjectFile.cc b/src/ObjectFile.cc
index 832ff25..96ef07f 100644
--- a/src/ObjectFile.cc
+++ b/src/ObjectFile.cc
@@ -70,7 +70,7 @@ void ObjectFile::serialize(std::ostream& stream) const {
         for (auto& library : imported_libraries) {
             names.emplace_back(library->name);
         }
-        std::sort(names.begin(), names.end());
+        std::ranges::sort(names);
         stream << ".import ";
         auto first = true;
         for (auto name_ : names) {
@@ -101,7 +101,7 @@ void ObjectFile::serialize(std::ostream& stream) const {
     for (const auto& pair : constants) {
         names.emplace_back(pair.first);
     }
-    std::sort(names.begin(), names.end());
+    std::ranges::sort(names);
     for (auto name_ : names) {
         stream << (*constants.find(name_)->second);
     }
@@ -110,7 +110,7 @@ void ObjectFile::serialize(std::ostream& stream) const {
     for (const auto& pair : functions) {
         names.emplace_back(pair.first);
     }
-    std::sort(names.begin(), names.end());
+    std::ranges::sort(names);
     for (auto name_ : names) {
         stream << *(functions.find(name_)->second);
     }
@@ -119,7 +119,7 @@ void ObjectFile::serialize(std::ostream& stream) const {
     for (const auto& pair : macros) {
         names.emplace_back(pair.first);
     }
-    std::sort(names.begin(), names.end());
+    std::ranges::sort(names);
     for (auto name_ : names) {
         stream << (*macros.find(name_)->second);
     }
@@ -128,7 +128,7 @@ void ObjectFile::serialize(std::ostream& stream) const {
     for (const auto& pair : objects) {
         names.emplace_back(pair.first);
     }
-    std::sort(names.begin(), names.end());
+    std::ranges::sort(names);
     for (auto name_ : names) {
         stream << *(objects.find(name_)->second);
     }
@@ -363,7 +363,9 @@ ObjectFile::ObjectFile() noexcept {
     private_environment = std::make_shared<Environment>(public_environment);
 }
 
-void ObjectFile::add_to_environment(Object* object) { add_to_environment(object->name.as_symbol(), object->visibility, Expression(object->name.location, object)); }
+void ObjectFile::add_to_environment(Object* object) {
+    add_to_environment(object->name.as_symbol(), object->visibility, Expression(object->name.location, object));
+}
 
 void ObjectFile::add_to_environment(Symbol symbol_name, Visibility visibility, Expression value) const {
     if (visibility == Visibility::PUBLIC) {
@@ -385,7 +387,7 @@ std::vector<Object*> ObjectFile::all_objects() {
     return v;
 }
 
-void ObjectFile::collect_explicitly_used_objects(std::unordered_set<Object*>& set) const {
+void ObjectFile::collect_explicitly_used_objects(std::unordered_set<Object*>& set) const { // NOLINT(misc-no-recursion)
     for (auto object : explicitly_used_objects) {
         set.insert(object);
     }
@@ -395,20 +397,21 @@ void ObjectFile::collect_explicitly_used_objects(std::unordered_set<Object*>& se
 }
 
 Object* ObjectFile::insert_object(std::unique_ptr<Object> object) {
-    auto own_object = object.get();
-    const auto it = objects.find(own_object->name.as_symbol());
-    if (it != objects.end()) {
+    auto [it, inserted] = objects.insert({object->name.as_symbol(), std::move(object)});
+    if (inserted) {
+        auto own_object = it->second.get();
+        own_object->set_owner(this);
+        add_to_environment(own_object);
+        return own_object;
+    }
+    else {
         if (object->is_default_only()) {
             object->set_owner(this);
-            unused_default_objects.insert(std::move(object));
-            return own_object;
+            auto [defaults_it, _] = unused_default_objects.insert(std::move(object));
+            return defaults_it->get();
         }
         throw ParseException(object->name, "redefinition of object '%s'", object->name.as_string().c_str()).appending(it->second->name.location, "previously defined here");
     }
-    objects[object->name.as_symbol()] = std::move(object);
-    own_object->set_owner(this);
-    add_to_environment(own_object);
-    return own_object;
 }
 
 void ObjectFile::add_function(std::unique_ptr<Function> function) {
diff --git a/src/ObjectFile.h b/src/ObjectFile.h
index 2c28ac6..6fe1d94 100644
--- a/src/ObjectFile.h
+++ b/src/ObjectFile.h
@@ -32,8 +32,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OBJECT_FILE_H
 #define OBJECT_FILE_H
 
-#include <map>
-
 #include "Function.h"
 #include "Macro.h"
 #include "Object.h"
@@ -45,7 +43,7 @@ class ObjectFile {
 public:
     class Constant: public Entity {
     public:
-        Constant(ObjectFile* owner, Token name, Visibility visibility, bool default_only, Expression value): Entity(owner, name, visibility, default_only), value(std::move(value)) {}
+        Constant(ObjectFile* owner, const Token& name, Visibility visibility, bool default_only, Expression value): Entity(owner, name, visibility, default_only), value(std::move(value)) {}
         Constant(ObjectFile* owner, const Token& name, const std::shared_ptr<ParsedValue>& definition);
 
         void serialize(std::ostream& stream) const;
@@ -77,7 +75,7 @@ class ObjectFile {
     [[nodiscard]] Macro* macro(Symbol macro_name);
     void mark_used(Object* object) {explicitly_used_objects.insert(object);}
     void mark_used(Symbol name) {explicitly_used_object_names.insert(name);}
-    void pin(Symbol name, Expression address) {pinned_objects[name] = Pinned{name, address};}
+    void pin(Symbol name, const Expression& address) {pinned_objects[name] = Pinned{name, address};}
     void remove_private_constants();
     void resolve_defaults();
     void serialize(std::ostream& stream) const;
diff --git a/src/ObjectFileParser.h b/src/ObjectFileParser.h
index dc92ab4..0a4e49e 100644
--- a/src/ObjectFileParser.h
+++ b/src/ObjectFileParser.h
@@ -32,8 +32,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OBJECT_FILE_PARSER_H
 #define OBJECT_FILE_PARSER_H
 
-#include <string>
-
 #include "FileParser.h"
 #include "ObjectFile.h"
 
diff --git a/src/ParseException.cc b/src/ParseException.cc
index 3f13815..90bd057 100644
--- a/src/ParseException.cc
+++ b/src/ParseException.cc
@@ -31,11 +31,9 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "ParseException.h"
 
-#include <utility>
-
 #include "Util.h"
 
-ParseException::ParseException(Location location, const char *format, ...): location(location) {
+ParseException::ParseException(const Location& location, const char *format, ...): location(location) {
     va_list ap;
     va_start(ap, format);
     message = string_format_v(format, ap);
@@ -49,11 +47,11 @@ ParseException::ParseException(const Token& token, const char *format, ...): loc
     va_end(ap);
 }
 
-ParseException ParseException::appending(Location note_location, const std::string& text) const {
+ParseException ParseException::appending(const Location& note_location, const std::string& text) const {
     return ParseException(location, message, {{note_location, text}});
 }
 
-ParseException::ParseException(Location location_, const Exception& exception): location(location_) {
+ParseException::ParseException(const Location& location_, const Exception& exception): location(location_) {
     if (auto parsed_exception = dynamic_cast<const ParseException*>(&exception)) {
         if (!parsed_exception->location.empty()) {
             location = parsed_exception->location;
diff --git a/src/ParseException.h b/src/ParseException.h
index 9922ea0..be98af7 100644
--- a/src/ParseException.h
+++ b/src/ParseException.h
@@ -34,8 +34,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Exception.h"
 
-#include <utility>
-
 #include "Location.h"
 #include "Token.h"
 
@@ -43,22 +41,22 @@ class ParseException: public Exception {
 public:
     class Note {
       public:
-        Note(Location location, std::string text) : location(location), text(std::move(text)) {}
+        Note(const Location& location, std::string text) : location(location), text(std::move(text)) {}
 
         Location location;
         std::string text;
     };
 
     ParseException(const Token& token, const Exception& exception): ParseException(token.location, exception) {}
-    ParseException(Location location, const Exception& exception);
-    ParseException(Location location, const char *format, ...) PRINTF_LIKE(3, 4);
+    ParseException(const Location& location, const Exception& exception);
+    ParseException(const Location& location, const char *format, ...) PRINTF_LIKE(3, 4);
     ParseException(const Token& token, const char* format, ...) PRINTF_LIKE(3, 4);
 
-    explicit ParseException(Location location, std::string message): Exception(std::move(message)), location(location) { }
+    explicit ParseException(const Location& location, std::string message): Exception(std::move(message)), location(location) { }
     ParseException(const Token& token, std::string message): ParseException(token.location, std::move(message)) {}
-    ParseException(Location location, std::string message, std::vector<Note> notes): Exception(std::move(message)), location(location), notes(std::move(notes)) {}
+    ParseException(const Location& location, std::string message, std::vector<Note> notes): Exception(std::move(message)), location(location), notes(std::move(notes)) {}
 
-    [[nodiscard]] ParseException appending(Location location, const std::string& text) const;
+    [[nodiscard]] ParseException appending(const Location& location, const std::string& text) const;
 
     Location location;
     std::vector<Note> notes;
diff --git a/src/ParsedValue.h b/src/ParsedValue.h
index 6e8c067..d401dc9 100644
--- a/src/ParsedValue.h
+++ b/src/ParsedValue.h
@@ -38,7 +38,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Token.h"
 #include "FileTokenizer.h"
 #include "TokenGroup.h"
-#include "BodyElement.h"
 #include "Body.h"
 
 class ParsedArray;
@@ -56,6 +55,8 @@ class ParsedValue {
         SCALAR_SINGULAR
     };
 
+    virtual ~ParsedValue() = default;
+
     [[nodiscard]] virtual Type type() const = 0;
 
     static void setup(FileTokenizer& tokenizer);
@@ -120,7 +121,7 @@ class ParsedDictionary: public ParsedValue {
 
     std::shared_ptr<ParsedValue> operator[](const Token& token) const;
     [[nodiscard]] std::shared_ptr<ParsedValue> get_optional(const Token& token) const;
-    [[nodiscard]] bool has_key(const Token& token) const {return entries.find(token) != entries.end();}
+    [[nodiscard]] bool has_key(const Token& token) const {return entries.contains(token);}
 
     std::unordered_map<Token, std::shared_ptr<ParsedValue>>::iterator begin() {return entries.begin();}
     std::unordered_map<Token, std::shared_ptr<ParsedValue>>::iterator end() {return entries.end();}
diff --git a/src/Range.cc b/src/Range.cc
index de94e20..7cf3c46 100644
--- a/src/Range.cc
+++ b/src/Range.cc
@@ -31,7 +31,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Range.h"
 
-#include <algorithm>
 #include <iomanip>
 
 #include "Exception.h"
diff --git a/src/SequenceTokenizer.cc b/src/SequenceTokenizer.cc
index cf141ba..3709bb4 100644
--- a/src/SequenceTokenizer.cc
+++ b/src/SequenceTokenizer.cc
@@ -51,7 +51,7 @@ Token SequenceTokenizer::sub_next() {
 }
 
 
-void SequenceTokenizer::set_location(Token token) {
+void SequenceTokenizer::set_location(const Token& token) {
     location = token.location;
     location.end_column = location.start_column;
 }
diff --git a/src/SequenceTokenizer.h b/src/SequenceTokenizer.h
index c82d39f..cdbbff2 100644
--- a/src/SequenceTokenizer.h
+++ b/src/SequenceTokenizer.h
@@ -38,7 +38,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 class SequenceTokenizer: public Tokenizer {
 public:
-    SequenceTokenizer(Location location, std::vector<Token> tokens): location(location), tokens(std::move(tokens)) { current_position = this->tokens.begin();}
+    SequenceTokenizer(const Location& location, std::vector<Token> tokens): location(location), tokens(std::move(tokens)) { current_position = this->tokens.begin();}
     explicit SequenceTokenizer(std::vector<Token> tokens);
 
     [[nodiscard]] Location current_location() const override {return location;}
@@ -52,7 +52,7 @@ class SequenceTokenizer: public Tokenizer {
     std::vector<Token> tokens;
     std::vector<Token>::iterator current_position;
 
-    void set_location(Token token);
+    void set_location(const Token& token);
 };
 
 #endif // SEQUENCE_TOKENIZER_H
diff --git a/src/SizeRange.cc b/src/SizeRange.cc
index 7f89089..5d80c8e 100644
--- a/src/SizeRange.cc
+++ b/src/SizeRange.cc
@@ -66,8 +66,7 @@ std::optional<uint64_t> SizeRange::size() const {
 }
 
 std::optional<Value> SizeRange::value() const {
-    auto s = size();
-    if (s) {
+    if (auto s = size()) {
         return Value(*s);
     }
     else {
diff --git a/src/StringEncoding.cc b/src/StringEncoding.cc
index b6a10f9..20ca60a 100644
--- a/src/StringEncoding.cc
+++ b/src/StringEncoding.cc
@@ -325,7 +325,7 @@ void StringEncoding::import_base(const Token& base_token, const std::shared_ptr<
                 if (auto uses = uses_v->as_array()) {
                     for (const auto& use_range_v: (*uses)) {
                         if (auto use_range = use_range_v->as_scalar()) {
-                            if (use_range->size() == 0 || !(*use_range)[0].is_unsigned()) {
+                            if (use_range->empty() || !(*use_range)[0].is_unsigned()) {
                                 throw ParseException(use_range_v->location, "invalid use range");
                             }
 
diff --git a/src/Symbol.cc b/src/Symbol.cc
index f52423c..beb439a 100644
--- a/src/Symbol.cc
+++ b/src/Symbol.cc
@@ -31,8 +31,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Symbol.h"
 
-#include "Exception.h"
-
 Symbol::Table* Symbol::global = nullptr;
 const std::string Symbol::empty_string{};
 
@@ -65,9 +63,8 @@ const std::string* Symbol::Table::intern(const std::string& string) {
     auto it = symbols.find(&string);
     if (it == symbols.end()) {
         auto interned_string = std::make_unique<std::string>(string);
-        auto new_id = interned_string.get();
-        symbols[new_id] = std::move(interned_string);
-        return new_id;
+        auto [new_it, _] = symbols.insert({interned_string.get(), std::move(interned_string)});
+        return new_it->first;
     }
     else {
         return it->second.get();
diff --git a/src/TargetParser.cc b/src/TargetParser.cc
index a2ee564..e676f37 100644
--- a/src/TargetParser.cc
+++ b/src/TargetParser.cc
@@ -148,8 +148,7 @@ void TargetParser::parse_section() {
         type = parse_type(type_parameter->as_singular_scalar()->token());
     }
     auto blocks = std::vector<MemoryMap::Block>();
-    auto segment = parameters->get_optional(token_segment_name);
-    if (segment) {
+    if (auto segment = parameters->get_optional(token_segment_name)) {
         if (parameters->has_key(token_address)) {
             throw ParseException(name, "segment and address are mutually exclusive");
         }
@@ -198,7 +197,7 @@ std::vector<MemoryMap::Block> TargetParser::parse_address(const ParsedValue *add
 }
 
 
-MemoryMap::AccessType TargetParser::parse_type(Token type) {
+MemoryMap::AccessType TargetParser::parse_type(const Token& type) {
     if (type == token_reserve_only) {
         return MemoryMap::RESERVE_ONLY;
     }
diff --git a/src/TargetParser.h b/src/TargetParser.h
index da2725c..d9acc98 100644
--- a/src/TargetParser.h
+++ b/src/TargetParser.h
@@ -63,7 +63,7 @@ class TargetParser: public FileParser {
 
     static std::vector<MemoryMap::Block> parse_address(const ParsedValue* address);
     static MemoryMap::Block parse_single_address(const ParsedScalar* address);
-    static MemoryMap::AccessType parse_type(Token type);
+    static MemoryMap::AccessType parse_type(const Token& type);
 
     Target target;
     std::unordered_set<Token> section_names;
diff --git a/src/Token.cc b/src/Token.cc
index 54b1385..69f4431 100644
--- a/src/Token.cc
+++ b/src/Token.cc
@@ -31,6 +31,8 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Token.h"
 
+#include "Exception.h"
+
 const std::string Token::empty_string;
 
 const Token Token::ampersand = Token(Token::PUNCTUATION, "&");
diff --git a/src/Token.h b/src/Token.h
index 53b25ed..f8d81fe 100644
--- a/src/Token.h
+++ b/src/Token.h
@@ -54,13 +54,13 @@ class Token {
     };
 
     Token() = default;
-    Token(Type type, Location location): type(type), location(location) {}
+    Token(Type type, const Location& location): location(location), type(type) {}
     Token(Type type, const std::string& name): Token(type, Location()) {value = Symbol(name);}
-    Token(Type type, Location location, Symbol symbol_): Token(type, location) {value = symbol_;}
-    Token(Type type, Location location, const std::string& string): Token(type, location, Symbol(string)) {}
-    Token(Type type, Location location, uint64_t integer, uint64_t default_size = 0): Token(type, location) {value = Value(integer, default_size);}
-    Token(Type type, Location location, double real): Token(type, location) {value = Value(real);}
-    Token(Location location, Value value_): Token(VALUE, location) {value = value_;}
+    Token(Type type, const Location& location, Symbol symbol_): Token(type, location) {value = symbol_;}
+    Token(Type type, const Location& location, const std::string& string): Token(type, location, Symbol(string)) {}
+    Token(Type type, const Location& location, uint64_t integer, uint64_t default_size = 0): Token(type, location) {value = Value(integer, default_size);}
+    Token(Type type, const Location& location, double real): Token(type, location) {value = Value(real);}
+    Token(const Location& location, Value value_): Token(VALUE, location) {value = value_;}
     ~Token() {}
 
     explicit operator bool() const {return type != END;}
diff --git a/src/TokenGroup.h b/src/TokenGroup.h
index e00c6fa..0f7c916 100644
--- a/src/TokenGroup.h
+++ b/src/TokenGroup.h
@@ -40,7 +40,7 @@ class TokenGroup {
     explicit TokenGroup(Token::Type type): types({ type }), name (Token::type_name(type)) {}
     TokenGroup(std::unordered_set<Token::Type> types, std::unordered_set<Token> tokens, std::string name): types (std::move(types)), tokens(std::move(tokens)), name(std::move(name)) {}
 
-    [[nodiscard]] bool contains(const Token& token) const {return contains_all || (types.find(token.get_type()) != types.end() || tokens.find(token) != tokens.end());}
+    [[nodiscard]] bool contains(const Token& token) const {return contains_all || types.contains(token.get_type()) || tokens.contains(token);}
 
     static const TokenGroup newline;
     static const TokenGroup all;
diff --git a/src/Tokenizer.cc b/src/Tokenizer.cc
index 7dfd271..e80b77b 100644
--- a/src/Tokenizer.cc
+++ b/src/Tokenizer.cc
@@ -45,7 +45,7 @@ Token Tokenizer::next() {
 
 
 
-void Tokenizer::unget(Token token) {
+void Tokenizer::unget(const Token& token) {
     if (ungot_token.has_value()) {
         throw Exception("trying to unget two tokens");
     }
@@ -177,7 +177,7 @@ Token Tokenizer::peek() {
     return token;
 }
 
-void Tokenizer::expect(Token token) {
+void Tokenizer::expect(const Token& token) {
     auto got = next();
     if (got != token) {
         throw ParseException(got, "expected %s", token.as_string().c_str());
diff --git a/src/Tokenizer.h b/src/Tokenizer.h
index d5f65f5..f1b3c12 100644
--- a/src/Tokenizer.h
+++ b/src/Tokenizer.h
@@ -40,7 +40,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class Tokenizer {
 public:
     Token next();
-    void unget(Token token);
+    void unget(const Token& token);
     Token peek();
     virtual ~Tokenizer() = default;
 
@@ -49,7 +49,7 @@ class Tokenizer {
     Token expect(Token::Type type);
     Token expect(Token::Type type, const TokenGroup& synchronize);
     Token expect(const TokenGroup& types, const TokenGroup& synchronize);
-    void expect(Token token);
+    void expect(const Token& token);
     void expect_litearls(const std::vector<Token::Type>& types, const TokenGroup& synchronize);
     void skip_until(const TokenGroup& types, bool including_terminator = false);
     void skip_until(const Token& token, bool including_terminator = false);
diff --git a/src/UnaryExpression.cc b/src/UnaryExpression.cc
index 8d9e5f7..c6e433b 100644
--- a/src/UnaryExpression.cc
+++ b/src/UnaryExpression.cc
@@ -32,6 +32,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "UnaryExpression.h"
 
 #include "EvaluationContext.h"
+#include "Exception.h"
 
 Expression UnaryExpression::create(const Location& location, Expression::UnaryOperation operation, Expression operand) {
     std::shared_ptr<BaseExpression> node;
diff --git a/src/Unresolved.cc b/src/Unresolved.cc
index ec73166..7cd094e 100644
--- a/src/Unresolved.cc
+++ b/src/Unresolved.cc
@@ -80,7 +80,7 @@ void Unresolved::Part::report() const {
     for (auto& it : unresolved) {
         unresolved_symbols.push_back(it.first);
     }
-    std::sort(unresolved_symbols.begin(), unresolved_symbols.end());
+    std::ranges::sort(unresolved_symbols);
 
     for (auto& unresolved_symbol : unresolved_symbols) {
         auto it = unresolved.find(unresolved_symbol);
diff --git a/src/Value.h b/src/Value.h
index 3ae17dd..30f80b7 100644
--- a/src/Value.h
+++ b/src/Value.h
@@ -32,7 +32,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef VALUE_H
 #define VALUE_H
 
-#include "Exception.h"
 #include <cstdint>
 #include <optional>
 #include <ostream>
diff --git a/src/VariableEntity.cc b/src/VariableEntity.cc
deleted file mode 100644
index b0ef3dc..0000000
--- a/src/VariableEntity.cc
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-VariableEntity.cc --
-
-Copyright (C) Dieter Baron
-
-The authors can be contacted at <accelerate@tpau.group>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. The names of the authors may not be used to endorse or promote
-  products derived from this software without specific prior
-  written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS
-OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
-GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
-IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include "VariableEntity.h"
diff --git a/src/VariableEntity.h b/src/VariableEntity.h
deleted file mode 100644
index fc4f025..0000000
--- a/src/VariableEntity.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef VARIABLE_ENTITY_H
-#define VARIABLE_ENTITY_H
-
-/*
-VariableEntity.h --
-
-Copyright (C) Dieter Baron
-
-The authors can be contacted at <accelerate@tpau.group>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. The names of the authors may not be used to endorse or promote
-  products derived from this software without specific prior
-  written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS
-OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
-GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
-IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include "Entity.h"
-
-class VariableEntity: public Entity {
-  public:
-
-};
-
-
-#endif // VARIABLE_ENTITY_H
diff --git a/src/xlr8.cc b/src/xlr8.cc
index ff58bb9..1b0e80b 100644
--- a/src/xlr8.cc
+++ b/src/xlr8.cc
@@ -40,7 +40,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Linker.h"
 #include "ObjectFileParser.h"
 #include "TargetGetter.h"
-#include "Util.h"
 #include "config.h"
 #include "CPUGetter.h"
 #include "ParseException.h"
@@ -48,7 +47,6 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class xlr8: public Command {
 public:
     xlr8(): Command(options, "file ...", "xlr8") {}
-    virtual ~xlr8() = default;
 
 protected:
     void process() override;