tidy: enforce adding override

It turns out that `HeaderFilterRegex` uses a Posix Extended Regular
Expression, which doesn't support lookbacks. The easiest solution is to
just fix the _one_ error in linenoise.h.

Note that the `run-clang-tidy` regex _does_ support lookbacks, since
it's a normal Python regex.

.clang-tidy

@@ -18,5 +18,8 @@ Checks:
 
   misc-unused-parameters,
 
-HeaderFilterRegex: src/include|tools/benchmark/include|tools/nodejs_api/src_cpp/include|tools/python_api/src_cpp/include|tools/rust_api/include|tools/shell/include/(?!linenoise.h)
+  modernize-use-override,
+
+HeaderFilterRegex:
+  src/include|tools/benchmark/include|tools/nodejs_api/src_cpp/include|tools/python_api/src_cpp/include|tools/rust_api/include|tools/shell/include
 WarningsAsErrors: "*"

src/include/binder/expression/function_expression.h

@@ -26,7 +26,7 @@ class FunctionExpression : public Expression {
         : Expression{expressionType, bindData->resultType, std::move(children), uniqueName},
           functionName{std::move(functionName)}, bindData{std::move(bindData)} {}
 
-    virtual ~FunctionExpression() = default;
+    ~FunctionExpression() override = default;
 
     inline std::string getFunctionName() const { return functionName; }
     inline function::FunctionBindData* getBindData() const { return bindData.get(); }

src/include/binder/expression/node_rel_expression.h

@@ -13,7 +13,7 @@ class NodeOrRelExpression : public Expression {
         std::string variableName, std::vector<common::table_id_t> tableIDs)
         : Expression{common::ExpressionType::PATTERN, std::move(dataType), std::move(uniqueName)},
           variableName(std::move(variableName)), tableIDs{std::move(tableIDs)} {}
-    virtual ~NodeOrRelExpression() override = default;
+    ~NodeOrRelExpression() override = default;
 
     inline std::string getVariableName() const { return variableName; }
 

src/include/common/serializer/buffered_file.h

@@ -14,7 +14,7 @@ struct FileInfo;
 
 class BufferedFileWriter : public Writer {
 public:
-    ~BufferedFileWriter() { flush(); }
+    ~BufferedFileWriter() override { flush(); }
     explicit BufferedFileWriter(std::unique_ptr<FileInfo> fileInfo)
         : buffer(std::make_unique<uint8_t[]>(BUFFER_SIZE)), fileOffset(0), bufferOffset(0),
           fileInfo(std::move(fileInfo)) {}

src/include/expression_evaluator/literal_evaluator.h

@@ -10,7 +10,7 @@ class LiteralExpressionEvaluator : public ExpressionEvaluator {
     LiteralExpressionEvaluator(std::shared_ptr<common::Value> value)
         : ExpressionEvaluator{true /* isResultFlat */}, value{std::move(value)} {}
 
-    ~LiteralExpressionEvaluator() = default;
+    ~LiteralExpressionEvaluator() override = default;
 
     inline void evaluate() override {}
 

src/include/expression_evaluator/path_evaluator.h

@@ -12,13 +12,14 @@ class PathExpressionEvaluator final : public ExpressionEvaluator {
         std::vector<std::unique_ptr<ExpressionEvaluator>> children)
         : ExpressionEvaluator{std::move(children)}, expression{std::move(expression)} {}
 
-    void init(const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager);
+    void init(
+        const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) override;
 
-    void evaluate();
+    void evaluate() override;
 
-    bool select(common::SelectionVector& /*selVector*/) { KU_UNREACHABLE; }
+    bool select(common::SelectionVector& /*selVector*/) override { KU_UNREACHABLE; }
 
-    inline std::unique_ptr<ExpressionEvaluator> clone() {
+    inline std::unique_ptr<ExpressionEvaluator> clone() override {
         std::vector<std::unique_ptr<ExpressionEvaluator>> clonedChildren;
         for (auto& child : children) {
             clonedChildren.push_back(child->clone());
@@ -44,7 +45,7 @@ class PathExpressionEvaluator final : public ExpressionEvaluator {
     };
 
     void resolveResultVector(
-        const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager);
+        const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) override;
 
     void copyNodes(common::sel_t resultPos, bool isEmptyRels);
     uint64_t copyRels(common::sel_t resultPos);

src/include/optimizer/logical_operator_collector.h

@@ -7,7 +7,7 @@ namespace optimizer {
 
 class LogicalOperatorCollector : public LogicalOperatorVisitor {
 public:
-    ~LogicalOperatorCollector() = default;
+    ~LogicalOperatorCollector() override = default;
 
     void collect(planner::LogicalOperator* op);
 

src/include/parser/visitor/statement_read_write_analyzer.h

@@ -12,15 +12,17 @@ class StatementReadWriteAnalyzer final : public StatementVisitor {
     bool isReadOnly(const Statement& statement);
 
 private:
-    inline void visitCreateTable(const Statement& /*statement*/) { readOnly = false; }
-    inline void visitDropTable(const Statement& /*statement*/) { readOnly = false; }
-    inline void visitAlter(const Statement& /*statement*/) { readOnly = false; }
-    inline void visitCopyFrom(const Statement& /*statement*/) { readOnly = false; }
-    inline void visitStandaloneCall(const Statement& /*statement*/) { readOnly = false; }
-    inline void visitCreateMacro(const Statement& /*statement*/) { readOnly = false; }
-    inline void visitCommentOn(const Statement& /*statement*/) { readOnly = false; }
-
-    inline void visitUpdatingClause(const UpdatingClause* /*updatingClause*/) { readOnly = false; }
+    inline void visitCreateTable(const Statement& /*statement*/) override { readOnly = false; }
+    inline void visitDropTable(const Statement& /*statement*/) override { readOnly = false; }
+    inline void visitAlter(const Statement& /*statement*/) override { readOnly = false; }
+    inline void visitCopyFrom(const Statement& /*statement*/) override { readOnly = false; }
+    inline void visitStandaloneCall(const Statement& /*statement*/) override { readOnly = false; }
+    inline void visitCreateMacro(const Statement& /*statement*/) override { readOnly = false; }
+    inline void visitCommentOn(const Statement& /*statement*/) override { readOnly = false; }
+
+    inline void visitUpdatingClause(const UpdatingClause* /*updatingClause*/) override {
+        readOnly = false;
+    }
 
 private:
     bool readOnly;

src/include/processor/operator/order_by/top_k.h

@@ -146,17 +146,17 @@ class TopK final : public Sink {
           info(std::move(info)), sharedState{std::move(sharedState)}, skipNumber{skipNumber},
           limitNumber{limitNumber} {}
 
-    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* context);
+    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* context) override;
 
-    inline void initGlobalStateInternal(ExecutionContext* context) {
+    inline void initGlobalStateInternal(ExecutionContext* context) override {
         sharedState->init(*info, context->memoryManager, skipNumber, limitNumber);
     }
 
-    void executeInternal(ExecutionContext* context);
+    void executeInternal(ExecutionContext* context) override;
 
-    void finalize(ExecutionContext* /*context*/) { sharedState->finalize(); }
+    void finalize(ExecutionContext* /*context*/) override { sharedState->finalize(); }
 
-    std::unique_ptr<PhysicalOperator> clone() {
+    std::unique_ptr<PhysicalOperator> clone() override {
         return std::make_unique<TopK>(resultSetDescriptor->copy(), info->copy(), sharedState,
             skipNumber, limitNumber, children[0]->clone(), id, paramsString);
     }

src/include/processor/operator/persistent/reader/parquet/callback_column_reader.h

@@ -27,7 +27,8 @@ class CallbackColumnReader
               reader, std::move(type_p), schema_p, file_idx_p, max_define_p, max_repeat_p) {}
 
 protected:
-    void dictionary(std::shared_ptr<ResizeableBuffer> dictionaryData, uint64_t numEntries) {
+    void dictionary(
+        std::shared_ptr<ResizeableBuffer> dictionaryData, uint64_t numEntries) override {
         BaseType::allocateDict(numEntries * sizeof(KU_PHYSICAL_TYPE));
         auto dictPtr = (KU_PHYSICAL_TYPE*)this->dict->ptr;
         for (auto i = 0u; i < numEntries; i++) {

src/include/processor/operator/scan/scan_rel_table.h

@@ -32,7 +32,7 @@ class ScanRelTable : public ScanTable {
         scanState = std::make_unique<storage::RelDataReadState>(
             this->info->table->getTableDataFormat(this->info->direction));
     }
-    virtual ~ScanRelTable() = default;
+    ~ScanRelTable() override = default;
 
 protected:
     ScanRelTable(PhysicalOperatorType operatorType, std::unique_ptr<ScanRelTableInfo> info,

src/include/processor/operator/scan/scan_table.h

@@ -13,7 +13,7 @@ class ScanTable : public PhysicalOperator {
         : PhysicalOperator{operatorType, std::move(child), id, paramString},
           inVectorPos{inVectorPos}, outVectorsPos{std::move(outVectorsPos)} {}
 
-    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* executionContext);
+    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* executionContext) override;
 
 protected:
     DataPos inVectorPos;

src/include/storage/local_storage/local_node_table.h

@@ -58,7 +58,7 @@ class LocalNodeTableData final : public LocalTableData {
     void delete_(common::ValueVector* nodeIDVector);
 
 private:
-    LocalNodeGroup* getOrCreateLocalNodeGroup(common::ValueVector* nodeIDVector);
+    LocalNodeGroup* getOrCreateLocalNodeGroup(common::ValueVector* nodeIDVector) override;
 };
 
 } // namespace storage

src/include/storage/local_storage/local_rel_table.h

@@ -146,7 +146,7 @@ class LocalRelTableData final : public LocalTableData {
         common::ValueVector* relIDVector);
 
 private:
-    LocalNodeGroup* getOrCreateLocalNodeGroup(common::ValueVector* nodeIDVector);
+    LocalNodeGroup* getOrCreateLocalNodeGroup(common::ValueVector* nodeIDVector) override;
 };
 
 } // namespace storage

src/include/storage/store/column.h

@@ -187,21 +187,21 @@ class InternalIDColumn : public Column {
         transaction::Transaction* transaction, RWPropertyStats stats);
 
     inline void scan(transaction::Transaction* transaction, common::ValueVector* nodeIDVector,
-        common::ValueVector* resultVector) {
+        common::ValueVector* resultVector) override {
         Column::scan(transaction, nodeIDVector, resultVector);
         populateCommonTableID(resultVector);
     }
 
     inline void scan(transaction::Transaction* transaction, common::node_group_idx_t nodeGroupIdx,
         common::offset_t startOffsetInGroup, common::offset_t endOffsetInGroup,
-        common::ValueVector* resultVector, uint64_t offsetInVector) {
+        common::ValueVector* resultVector, uint64_t offsetInVector) override {
         Column::scan(transaction, nodeGroupIdx, startOffsetInGroup, endOffsetInGroup, resultVector,
             offsetInVector);
         populateCommonTableID(resultVector);
     }
 
     inline void lookup(transaction::Transaction* transaction, common::ValueVector* nodeIDVector,
-        common::ValueVector* resultVector) {
+        common::ValueVector* resultVector) override {
         Column::lookup(transaction, nodeIDVector, resultVector);
         populateCommonTableID(resultVector);
     }

src/include/storage/store/node_group.h

@@ -64,9 +64,8 @@ class CSRNodeGroup : public NodeGroup {
 
     inline ColumnChunk* getCSROffsetChunk() { return csrOffsetChunk.get(); }
 
-    virtual inline void writeToColumnChunk(common::vector_idx_t chunkIdx,
-        common::vector_idx_t vectorIdx, common::DataChunk* dataChunk,
-        common::ValueVector* offsetVector) override {
+    inline void writeToColumnChunk(common::vector_idx_t chunkIdx, common::vector_idx_t vectorIdx,
+        common::DataChunk* dataChunk, common::ValueVector* offsetVector) override {
         chunks[chunkIdx]->write(
             dataChunk->getValueVector(vectorIdx).get(), offsetVector, true /* isCSR */);
     }

src/include/storage/store/node_table_data.h

@@ -20,9 +20,11 @@ class NodeTableData final : public TableData {
         readState->columnIDs = std::move(columnIDs);
     }
     void scan(transaction::Transaction* transaction, TableReadState& readState,
-        common::ValueVector* nodeIDVector, const std::vector<common::ValueVector*>& outputVectors);
+        common::ValueVector* nodeIDVector,
+        const std::vector<common::ValueVector*>& outputVectors) override;
     void lookup(transaction::Transaction* transaction, TableReadState& readState,
-        common::ValueVector* nodeIDVector, const std::vector<common::ValueVector*>& outputVectors);
+        common::ValueVector* nodeIDVector,
+        const std::vector<common::ValueVector*>& outputVectors) override;
 
     // These two interfaces are node table specific, as rel table requires also relIDVector.
     void insert(transaction::Transaction* transaction, common::ValueVector* nodeIDVector,
@@ -31,10 +33,10 @@ class NodeTableData final : public TableData {
         common::ValueVector* nodeIDVector, common::ValueVector* propertyVector);
     void delete_(transaction::Transaction* transaction, common::ValueVector* nodeIDVector);
 
-    void append(NodeGroup* nodeGroup);
+    void append(NodeGroup* nodeGroup) override;
 
     void prepareLocalTableToCommit(
-        transaction::Transaction* transaction, LocalTableData* localTable);
+        transaction::Transaction* transaction, LocalTableData* localTable) override;
 };
 
 } // namespace storage

src/include/storage/store/rel_table_data.h

@@ -52,15 +52,15 @@ class RelTableData final : public TableData {
         RelDataReadState* readState);
     inline void scan(transaction::Transaction* transaction, TableReadState& readState,
         common::ValueVector* inNodeIDVector,
-        const std::vector<common::ValueVector*>& outputVectors) {
+        const std::vector<common::ValueVector*>& outputVectors) override {
         auto& relReadState = common::ku_dynamic_cast<TableReadState&, RelDataReadState&>(readState);
         dataFormat == common::ColumnDataFormat::REGULAR ?
             scanRegularColumns(transaction, relReadState, inNodeIDVector, outputVectors) :
             scanCSRColumns(transaction, relReadState, inNodeIDVector, outputVectors);
     }
     void lookup(transaction::Transaction* transaction, TableReadState& readState,
         common::ValueVector* inNodeIDVector,
-        const std::vector<common::ValueVector*>& outputVectors);
+        const std::vector<common::ValueVector*>& outputVectors) override;
 
     void insert(transaction::Transaction* transaction, common::ValueVector* srcNodeIDVector,
         common::ValueVector* dstNodeIDVector,
@@ -75,16 +75,16 @@ class RelTableData final : public TableData {
         common::ValueVector* dstNodeIDVector, common::ValueVector* relIDVector);
     bool checkIfNodeHasRels(
         transaction::Transaction* transaction, common::ValueVector* srcNodeIDVector);
-    void append(NodeGroup* nodeGroup);
+    void append(NodeGroup* nodeGroup) override;
     void resizeColumns(common::node_group_idx_t nodeGroupIdx);
 
     inline Column* getAdjColumn() const { return adjColumn.get(); }
     inline common::ColumnDataFormat getDataFormat() const { return dataFormat; }
 
     void prepareLocalTableToCommit(
-        transaction::Transaction* transaction, LocalTableData* localTable);
-    void checkpointInMemory();
-    void rollbackInMemory();
+        transaction::Transaction* transaction, LocalTableData* localTable) override;
+    void checkpointInMemory() override;
+    void rollbackInMemory() override;
 
 private:
     LocalRelNG* getLocalNodeGroup(

src/storage/store/column_chunk.cpp

@@ -494,13 +494,13 @@ class InternalIDColumnChunk final : public ColumnChunk {
     InternalIDColumnChunk(uint64_t capacity)
         : ColumnChunk(LogicalType::INT64(), capacity, false /* enableCompression */) {}
 
-    void append(ValueVector* vector) {
+    void append(ValueVector* vector) override {
         KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::INTERNAL_ID);
         copyVectorToBuffer(vector, numValues);
         numValues += vector->state->selVector->selectedSize;
     }
 
-    void copyVectorToBuffer(ValueVector* vector, offset_t startPosInChunk) {
+    void copyVectorToBuffer(ValueVector* vector, offset_t startPosInChunk) override {
         auto relIDsInVector = (internalID_t*)vector->getData();
         for (auto i = 0u; i < vector->state->selVector->selectedSize; i++) {
             auto pos = vector->state->selVector->selectedPositions[i];

tools/nodejs_api/src_cpp/include/node_connection.h

@@ -17,7 +17,7 @@ class NodeConnection : public Napi::ObjectWrap<NodeConnection> {
 public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
     NodeConnection(const Napi::CallbackInfo& info);
-    ~NodeConnection() = default;
+    ~NodeConnection() override = default;
 
 private:
     Napi::Value InitAsync(const Napi::CallbackInfo& info);
@@ -36,7 +36,7 @@ class ConnectionInitAsyncWorker : public Napi::AsyncWorker {
     ConnectionInitAsyncWorker(Napi::Function& callback, NodeConnection* nodeConnection)
         : Napi::AsyncWorker(callback), nodeConnection(nodeConnection) {}
 
-    ~ConnectionInitAsyncWorker() = default;
+    ~ConnectionInitAsyncWorker() override = default;
 
     inline void Execute() override {
         try {
@@ -66,7 +66,7 @@ class ConnectionExecuteAsyncWorker : public Napi::AsyncWorker {
         std::unordered_map<std::string, std::unique_ptr<Value>> params)
         : Napi::AsyncWorker(callback), preparedStatement(preparedStatement),
           nodeQueryResult(nodeQueryResult), connection(connection), params(std::move(params)) {}
-    ~ConnectionExecuteAsyncWorker() = default;
+    ~ConnectionExecuteAsyncWorker() override = default;
 
     inline void Execute() override {
         try {

tools/nodejs_api/src_cpp/include/node_database.h

@@ -14,7 +14,7 @@ class NodeDatabase : public Napi::ObjectWrap<NodeDatabase> {
 public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
     NodeDatabase(const Napi::CallbackInfo& info);
-    ~NodeDatabase() = default;
+    ~NodeDatabase() override = default;
 
 private:
     Napi::Value InitAsync(const Napi::CallbackInfo& info);
@@ -34,7 +34,7 @@ class DatabaseInitAsyncWorker : public Napi::AsyncWorker {
     DatabaseInitAsyncWorker(Napi::Function& callback, NodeDatabase* nodeDatabase)
         : AsyncWorker(callback), nodeDatabase(nodeDatabase) {}
 
-    ~DatabaseInitAsyncWorker() = default;
+    ~DatabaseInitAsyncWorker() override = default;
 
     inline void Execute() override {
         try {

tools/nodejs_api/src_cpp/include/node_prepared_statement.h

@@ -16,7 +16,7 @@ class NodePreparedStatement : public Napi::ObjectWrap<NodePreparedStatement> {
 public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
     NodePreparedStatement(const Napi::CallbackInfo& info);
-    ~NodePreparedStatement() = default;
+    ~NodePreparedStatement() override = default;
 
 private:
     Napi::Value InitAsync(const Napi::CallbackInfo& info);
@@ -37,7 +37,7 @@ class PreparedStatementInitAsyncWorker : public Napi::AsyncWorker {
         Napi::Function& callback, NodePreparedStatement* nodePreparedStatement)
         : AsyncWorker(callback), nodePreparedStatement(nodePreparedStatement) {}
 
-    ~PreparedStatementInitAsyncWorker() = default;
+    ~PreparedStatementInitAsyncWorker() override = default;
 
     inline void Execute() override {
         try {

tools/nodejs_api/src_cpp/include/node_query_result.h

@@ -18,7 +18,7 @@ class NodeQueryResult : public Napi::ObjectWrap<NodeQueryResult> {
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
     NodeQueryResult(const Napi::CallbackInfo& info);
     void SetQueryResult(std::shared_ptr<QueryResult>& queryResult);
-    ~NodeQueryResult() = default;
+    ~NodeQueryResult() override = default;
 
 private:
     void ResetIterator(const Napi::CallbackInfo& info);
@@ -40,7 +40,7 @@ class NodeQueryResultGetColumnMetadataAsyncWorker : public Napi::AsyncWorker {
         Napi::Function& callback, NodeQueryResult* nodeQueryResult, GetColumnMetadataType type)
         : AsyncWorker(callback), nodeQueryResult(nodeQueryResult), type(type) {}
 
-    ~NodeQueryResultGetColumnMetadataAsyncWorker() = default;
+    ~NodeQueryResultGetColumnMetadataAsyncWorker() override = default;
 
     inline void Execute() override {
         try {
@@ -78,7 +78,7 @@ class NodeQueryResultGetNextAsyncWorker : public Napi::AsyncWorker {
     NodeQueryResultGetNextAsyncWorker(Napi::Function& callback, NodeQueryResult* nodeQueryResult)
         : AsyncWorker(callback), nodeQueryResult(nodeQueryResult) {}
 
-    ~NodeQueryResultGetNextAsyncWorker() = default;
+    ~NodeQueryResultGetNextAsyncWorker() override = default;
 
     inline void Execute() override {
         try {