[Cleanup] Remove some default parameter (#3584)

Jarod42 · web-flow · commit d7f8c4b26dbe · 2025-03-18T10:13:27.000+01:00
* [cleanup] Remove default parameter of `FunctionFromFileLine`

* [cleanup] Remove default parameter of `DirTraverser`

* [cleanup] Remove default parameter of `TagsManager::GetClasses`

* [cleanup] Remove default parameter of `GetTagsByScopeAndKind` and remove extra overload

* [cleanup] Remove default parameter of `TagsByScope`

* [cleanup] Remove default parameter of `CxxVariable::ToString`

* [cleanup] Remove default parameter `forceDelay` of `clEditor::SetEnsureCaretIsVisible`
diff --git a/CodeLite/Cxx/CxxCodeCompletion.cpp b/CodeLite/Cxx/CxxCodeCompletion.cpp
@@ -1003,7 +1003,7 @@ std::vector<TagEntryPtr> CxxCodeCompletion::get_children_of_scope(TagEntryPtr pa
             scope = tag->GetScope();
         }
         std::vector<TagEntryPtr> parent_tags;
-        m_lookup->GetTagsByScopeAndKind(scope, to_wx_array_string(kinds), filter, parent_tags, true);
+        m_lookup->GetTagsByScopeAndKind(scope, to_wx_array_string(kinds), filter, parent_tags);
         tags.reserve(tags.size() + parent_tags.size());
         tags.insert(tags.end(), parent_tags.begin(), parent_tags.end());
     }
diff --git a/CodeLite/Cxx/CxxVariable.cpp b/CodeLite/Cxx/CxxVariable.cpp
@@ -28,10 +28,8 @@ wxString CxxVariable::GetTypeAsCxxString(const wxStringTable_t& table) const
     return PackType(m_type, m_standard, true, table);
 }
 
-wxString CxxVariable::ToString(size_t flags, const wxStringTable_t& table) const
+wxString CxxVariable::ToString(size_t flags) const
 {
-    wxUnusedVar(table);
-
     wxString str;
     str << GetTypeAsString({});
 
diff --git a/CodeLite/Cxx/CxxVariable.h b/CodeLite/Cxx/CxxVariable.h
@@ -51,8 +51,6 @@ class WXDLLIMPEXP_CL CxxVariable
         // Include the default value
         kToString_DefaultValue = (1 << 1),
         kToString_Default = kToString_Name,
-        // Revert back type->macro (e.g. wxWindowMSW -> wxWindow)
-        kToString_ReverseMacros = (1 << 2),
     };
 
 protected:
@@ -114,11 +112,8 @@ class WXDLLIMPEXP_CL CxxVariable
     /**
      * @brief return a string representation for this variable
      * @param flags see values in eFlags
-     * @param table macros table - reversed. i.e. the actual type is the key and the value is the macro name
-     * this table is used when the flag kToString_ReverseMacros is passed
      */
-    wxString ToString(size_t flags = CxxVariable::kToString_Default,
-                      const wxStringTable_t& table = wxStringTable_t()) const;
+    wxString ToString(size_t flags = CxxVariable::kToString_Default) const;
 
     void SetDefaultValue(const wxString& defaultValue) { this->m_defaultValue = defaultValue; }
     const wxString& GetDefaultValue() const { return m_defaultValue; }
diff --git a/CodeLite/ctags_manager.cpp b/CodeLite/ctags_manager.cpp
@@ -367,7 +367,7 @@ void TagsManager::GetFiles(const wxString& partialName, std::vector<wxFileName>&
     }
 }
 
-TagEntryPtr TagsManager::FunctionFromFileLine(const wxFileName& fileName, int lineno, bool nextFunction /*false*/)
+TagEntryPtr TagsManager::FunctionFromFileLine(const wxFileName& fileName, int lineno)
 {
     if(!GetDatabase()) {
         return NULL;
@@ -377,22 +377,12 @@ TagEntryPtr TagsManager::FunctionFromFileLine(const wxFileName& fileName, int li
         CacheFile(fileName.GetFullPath());
     }
 
-    TagEntryPtr foo = NULL;
-    for(size_t i = 0; i < m_cachedFileFunctionsTags.size(); i++) {
-        TagEntryPtr t = m_cachedFileFunctionsTags.at(i);
-
-        if(nextFunction && t->GetLine() > lineno) {
-            // keep the last non matched method
-            foo = t;
-        } else if(t->GetLine() <= lineno) {
-            if(nextFunction) {
-                return foo;
-            } else {
-                return t;
-            }
+    for (TagEntryPtr t : m_cachedFileFunctionsTags) {
+        if (t->GetLine() <= lineno) {
+            return t;
         }
     }
-    return foo;
+    return nullptr;
 }
 
 wxString TagsManager::FormatFunction(TagEntryPtr tag, size_t flags, const wxString& scope)
@@ -497,18 +487,15 @@ Language* TagsManager::GetLanguage()
     }
 }
 
-void TagsManager::GetClasses(std::vector<TagEntryPtr>& tags, bool onlyWorkspace)
+void TagsManager::GetClasses(std::vector<TagEntryPtr>& tags)
 {
     const wxArrayString kind = StdToWX::ToArrayString({ wxT("class"), wxT("struct"), wxT("union") });
 
     GetDatabase()->GetTagsByKind(kind, wxT("name"), ITagsStorage::OrderAsc, tags);
 }
 
-void TagsManager::TagsByScope(const wxString& scopeName, const wxArrayString& kind, std::vector<TagEntryPtr>& tags,
-                              bool include_anon)
+void TagsManager::TagsByScope(const wxString& scopeName, const wxArrayString& kind, std::vector<TagEntryPtr>& tags)
 {
-    wxUnusedVar(include_anon);
-
     wxArrayString scopes;
     GetScopesByScopeName(scopeName, scopes);
     // make enough room for max of 500 elements in the vector
@@ -549,7 +536,7 @@ wxString TagsManager::NormalizeFunctionSig(const wxString& sig, size_t flags,
             toStringFlags |= CxxVariable::kToString_DefaultValue;
         }
 
-        str_output << var->ToString(toStringFlags, {});
+        str_output << var->ToString(toStringFlags);
         // keep the length of this argument
         if(paramLen) {
             paramLen->push_back({ start_offset, str_output.length() - start_offset });
diff --git a/CodeLite/ctags_manager.h b/CodeLite/ctags_manager.h
@@ -227,11 +227,8 @@ class WXDLLIMPEXP_CL TagsManager : public wxEvtHandler
      * @param scopeName the scope to search
      * @param kind list of tags kind to return
      * @param tags [output] the result vector
-     * @param inherits set to true if you want inherited members as well members
-     * @param include_anon included anonymous members (of Unions/structs/enums)
      */
-    void TagsByScope(const wxString& scopeName, const wxArrayString& kind, std::vector<TagEntryPtr>& tags,
-                     bool include_anon = false);
+    void TagsByScope(const wxString& scopeName, const wxArrayString& kind, std::vector<TagEntryPtr>& tags);
 
     /**
      * @brief get the scope name. CodeLite assumes that the caret is placed at the end of the 'scope'
@@ -261,7 +258,7 @@ class WXDLLIMPEXP_CL TagsManager : public wxEvtHandler
      * @param lineno the line number
      * @return pointer to the tage which matches the line number & files
      */
-    TagEntryPtr FunctionFromFileLine(const wxFileName& fileName, int lineno, bool nextFunction = false);
+    TagEntryPtr FunctionFromFileLine(const wxFileName& fileName, int lineno);
 
     /**
      * @brief
@@ -279,11 +276,8 @@ class WXDLLIMPEXP_CL TagsManager : public wxEvtHandler
     /**
      * @brief return list of all classes.
      * @param tags [output] vector of tags for the classes
-     * @param onlyWorkspace set to true if you wish to accept only classes belongs to the workspace, false if you would
-     * like to receive
-     * classes from the external database as well
      */
-    void GetClasses(std::vector<TagEntryPtr>& tags, bool onlyWorkspace = true);
+    void GetClasses(std::vector<TagEntryPtr>& tags);
 
     /**
      * @brief return list of tags by their partial names
diff --git a/CodeLite/database/istorage.h b/CodeLite/database/istorage.h
@@ -160,23 +160,14 @@ class ITagsStorage
      */
     virtual void GetTagsByFileAndLine(const wxString& file, int line, std::vector<TagEntryPtr>& tags) = 0;
 
-    /**
-     * @brief return list by kind and scope
-     * @param scope
-     * @param kinds
-     * @param tags [output]
-     */
-    virtual void GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds,
-                                       std::vector<TagEntryPtr>& tags, bool applyLimit = true) = 0;
-
     /**
      * @brief return list by kind and scope while using a filter
      * @param scope
      * @param kinds
      * @param tags [output]
      */
     virtual void GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds, const wxString& filter,
-                                       std::vector<TagEntryPtr>& tags, bool applyLimit = true) = 0;
+                                       std::vector<TagEntryPtr>& tags) = 0;
 
     /**
      * @brief get list of tags by kind and file
diff --git a/CodeLite/database/tags_storage_sqlite3.cpp b/CodeLite/database/tags_storage_sqlite3.cpp
@@ -690,12 +690,6 @@ void TagsStorageSQLite::GetTagsByFileAndLine(const wxString& file, int line, std
     DoFetchTags(sql, tags);
 }
 
-void TagsStorageSQLite::GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds,
-                                              std::vector<TagEntryPtr>& tags, bool applyLimit)
-{
-    GetTagsByScopeAndKind(scope, kinds, wxEmptyString, tags, applyLimit);
-}
-
 void TagsStorageSQLite::GetTagsByKindAndFile(const wxArrayString& kind, const wxString& fileName,
                                              const wxString& orderingColumn, int order, std::vector<TagEntryPtr>& tags)
 {
@@ -948,7 +942,7 @@ void TagsStorageSQLite::GetTagsByScopeAndName(const wxArrayString& scope, const
 }
 
 void TagsStorageSQLite::GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds, const wxString& filter,
-                                              std::vector<TagEntryPtr>& tags, bool applyLimit)
+                                              std::vector<TagEntryPtr>& tags)
 {
     if(kinds.empty()) {
         return;
@@ -973,9 +967,7 @@ void TagsStorageSQLite::GetTagsByScopeAndKind(const wxString& scope, const wxArr
         sql << kinds_buffer;
     }
 
-    if(applyLimit) {
-        sql << " LIMIT " << GetSingleSearchLimit();
-    }
+    sql << " LIMIT " << GetSingleSearchLimit();
     DoFetchTags(sql, tags);
 }
 
diff --git a/CodeLite/database/tags_storage_sqlite3.h b/CodeLite/database/tags_storage_sqlite3.h
@@ -403,16 +403,13 @@ class WXDLLIMPEXP_CL TagsStorageSQLite : public ITagsStorage
      * @brief return list by kind and scope
      * @param scope
      * @param kinds
+     * @param filter "starts_with" filter
      * @param tags [output]
      */
-    virtual void GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds,
-                                       std::vector<TagEntryPtr>& tags, bool applyLimit = true);
-
-    /**
-     * @brief similar to the above, but with filter ("starts_with")
-     */
-    virtual void GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds, const wxString& filter,
-                                       std::vector<TagEntryPtr>& tags, bool applyLimit = true);
+    virtual void GetTagsByScopeAndKind(const wxString& scope,
+                                       const wxArrayString& kinds,
+                                       const wxString& filter,
+                                       std::vector<TagEntryPtr>& tags);
 
     /**
      * @see ITagsStorage::GetTagsByName
diff --git a/CodeLite/dirtraverser.cpp b/CodeLite/dirtraverser.cpp
@@ -29,10 +29,9 @@
 #include <wx/log.h>
 #include <wx/tokenzr.h>
 
-DirTraverser::DirTraverser(const wxString &filespec, bool includeExtLessFiles)
+DirTraverser::DirTraverser(const wxString &filespec)
     : wxDirTraverser()
     , m_filespec(filespec)
-    , m_extlessFiles(includeExtLessFiles)
 {
     m_specArray = wxStringTokenize(filespec, wxT(";"), wxTOKEN_STRTOK);
 }
@@ -41,18 +40,10 @@ wxDirTraverseResult DirTraverser::OnFile(const wxString& filename)
 {
     // add the file to our array
     wxFileName fn(filename);
-    
-    if(FileUtils::WildMatch(m_filespec, fn)) {
-        m_files.Add(filename);
-        return wxDIR_CONTINUE;
-    }
 
-    // if we reached this point, no pattern was suitable for our file
-    // test for extensionless file flag
-    if (fn.GetExt().IsEmpty() && m_extlessFiles) {
+    if (FileUtils::WildMatch(m_filespec, fn)) {
         m_files.Add(filename);
     }
-
     return wxDIR_CONTINUE;
 }
 
diff --git a/CodeLite/dirtraverser.h b/CodeLite/dirtraverser.h
@@ -47,15 +47,14 @@ class WXDLLIMPEXP_CL DirTraverser : public wxDirTraverser
     wxString m_filespec;
     wxArrayString m_specArray;
 
-    bool m_extlessFiles;
     wxArrayString m_excludeDirs;
 
 public:
 
     /**
      * Construct a DirTraverser with a given file spec
      */
-    DirTraverser(const wxString &filespec, bool includExtLessFiles = false);
+    DirTraverser(const wxString &filespec);
     virtual ~DirTraverser();
 
     /**
diff --git a/LiteEditor/cl_editor.cpp b/LiteEditor/cl_editor.cpp
@@ -1409,9 +1409,8 @@ void clEditor::OnCharAdded(wxStyledTextEvent& event)
     event.Skip();
 }
 
-void clEditor::SetEnsureCaretIsVisible(int pos, bool preserveSelection /*=true*/, bool forceDelay /*=false*/)
+void clEditor::SetEnsureCaretIsVisible(int pos, bool preserveSelection /*=true*/)
 {
-    wxUnusedVar(forceDelay);
     DoEnsureCaretIsVisible(pos, preserveSelection);
 }
 
diff --git a/LiteEditor/cl_editor.h b/LiteEditor/cl_editor.h
@@ -434,14 +434,13 @@ class clEditor : public wxStyledTextCtrl, public IEditor
     ContextBasePtr GetContext() const { return m_context; }
 
     /**
-     * If word-wrap isn't on, and forceDelay is false, this calls DoEnsureCaretIsVisible() immediately. Otherwise it
+     * If word-wrap isn't on, this calls DoEnsureCaretIsVisible() immediately. Otherwise it
      * stores a position for OnScnPainted() to ensure-is-visible in the next scintilla paint event
      * This doesn't happen until scintilla painting is complete, so it isn't ruined by e.g. word-wrap
      * @param position the position to ensure is visible
      * @param preserveSelection preserve any selection
-     * @param forceDelay wait for the next paint event even if word-wrap is off
      */
-    void SetEnsureCaretIsVisible(int pos, bool preserveSelection = true, bool forceDelay = false);
+    void SetEnsureCaretIsVisible(int pos, bool preserveSelection = true);
 
     /**
      * Does the necessary things to ensure that the destination line of a GoTo is visible

Original file line number	Diff line number	Diff line change
`@@ -1003,7 +1003,7 @@ std::vector<TagEntryPtr> CxxCodeCompletion::get_children_of_scope(TagEntryPtr pa`
`1003`	`1003`	`scope = tag->GetScope();`
`1004`	`1004`	`}`
`1005`	`1005`	`std::vector<TagEntryPtr> parent_tags;`
`1006`		`- m_lookup->GetTagsByScopeAndKind(scope, to_wx_array_string(kinds), filter, parent_tags, true);`
	`1006`	`+ m_lookup->GetTagsByScopeAndKind(scope, to_wx_array_string(kinds), filter, parent_tags);`
`1007`	`1007`	`tags.reserve(tags.size() + parent_tags.size());`
`1008`	`1008`	`tags.insert(tags.end(), parent_tags.begin(), parent_tags.end());`
`1009`	`1009`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,10 +28,8 @@ wxString CxxVariable::GetTypeAsCxxString(const wxStringTable_t& table) const`
`28`	`28`	`return PackType(m_type, m_standard, true, table);`
`29`	`29`	`}`
`30`	`30`
`31`		`-wxString CxxVariable::ToString(size_t flags, const wxStringTable_t& table) const`
	`31`	`+wxString CxxVariable::ToString(size_t flags) const`
`32`	`32`	`{`
`33`		`- wxUnusedVar(table);`
`34`		`-`
`35`	`33`	`wxString str;`
`36`	`34`	`str << GetTypeAsString({});`
`37`	`35`
Original file line number	Diff line number	Diff line change
`@@ -367,7 +367,7 @@ void TagsManager::GetFiles(const wxString& partialName, std::vector<wxFileName>&`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`
`370`		`-TagEntryPtr TagsManager::FunctionFromFileLine(const wxFileName& fileName, int lineno, bool nextFunction /false/)`
	`370`	`+TagEntryPtr TagsManager::FunctionFromFileLine(const wxFileName& fileName, int lineno)`
`371`	`371`	`{`
`372`	`372`	`if(!GetDatabase()) {`
`373`	`373`	`return NULL;`
`@@ -377,22 +377,12 @@ TagEntryPtr TagsManager::FunctionFromFileLine(const wxFileName& fileName, int li`
`377`	`377`	`CacheFile(fileName.GetFullPath());`
`378`	`378`	`}`
`379`	`379`
`380`		`- TagEntryPtr foo = NULL;`
`381`		`- for(size_t i = 0; i < m_cachedFileFunctionsTags.size(); i++) {`
`382`		`- TagEntryPtr t = m_cachedFileFunctionsTags.at(i);`
`383`		`-`
`384`		`- if(nextFunction && t->GetLine() > lineno) {`
`385`		`- // keep the last non matched method`
`386`		`- foo = t;`
`387`		`- } else if(t->GetLine() <= lineno) {`
`388`		`- if(nextFunction) {`
`389`		`- return foo;`
`390`		`- } else {`
`391`		`- return t;`
`392`		`- }`
	`380`	`+ for (TagEntryPtr t : m_cachedFileFunctionsTags) {`
	`381`	`+ if (t->GetLine() <= lineno) {`
	`382`	`+ return t;`
`393`	`383`	`}`
`394`	`384`	`}`
`395`		`- return foo;`
	`385`	`+ return nullptr;`
`396`	`386`	`}`
`397`	`387`
`398`	`388`	`wxString TagsManager::FormatFunction(TagEntryPtr tag, size_t flags, const wxString& scope)`
`@@ -497,18 +487,15 @@ Language* TagsManager::GetLanguage()`
`497`	`487`	`}`
`498`	`488`	`}`
`499`	`489`
`500`		`-void TagsManager::GetClasses(std::vector<TagEntryPtr>& tags, bool onlyWorkspace)`
	`490`	`+void TagsManager::GetClasses(std::vector<TagEntryPtr>& tags)`
`501`	`491`	`{`
`502`	`492`	`const wxArrayString kind = StdToWX::ToArrayString({ wxT("class"), wxT("struct"), wxT("union") });`
`503`	`493`
`504`	`494`	`GetDatabase()->GetTagsByKind(kind, wxT("name"), ITagsStorage::OrderAsc, tags);`
`505`	`495`	`}`
`506`	`496`
`507`		`-void TagsManager::TagsByScope(const wxString& scopeName, const wxArrayString& kind, std::vector<TagEntryPtr>& tags,`
`508`		`- bool include_anon)`
	`497`	`+void TagsManager::TagsByScope(const wxString& scopeName, const wxArrayString& kind, std::vector<TagEntryPtr>& tags)`
`509`	`498`	`{`
`510`		`- wxUnusedVar(include_anon);`
`511`		`-`
`512`	`499`	`wxArrayString scopes;`
`513`	`500`	`GetScopesByScopeName(scopeName, scopes);`
`514`	`501`	`// make enough room for max of 500 elements in the vector`
`@@ -549,7 +536,7 @@ wxString TagsManager::NormalizeFunctionSig(const wxString& sig, size_t flags,`
`549`	`536`	`toStringFlags \|= CxxVariable::kToString_DefaultValue;`
`550`	`537`	`}`
`551`	`538`
`552`		`- str_output << var->ToString(toStringFlags, {});`
	`539`	`+ str_output << var->ToString(toStringFlags);`
`553`	`540`	`// keep the length of this argument`
`554`	`541`	`if(paramLen) {`
`555`	`542`	`paramLen->push_back({ start_offset, str_output.length() - start_offset });`
Original file line number	Diff line number	Diff line change
`@@ -690,12 +690,6 @@ void TagsStorageSQLite::GetTagsByFileAndLine(const wxString& file, int line, std`
`690`	`690`	`DoFetchTags(sql, tags);`
`691`	`691`	`}`
`692`	`692`
`693`		`-void TagsStorageSQLite::GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds,`
`694`		`- std::vector<TagEntryPtr>& tags, bool applyLimit)`
`695`		`-{`
`696`		`- GetTagsByScopeAndKind(scope, kinds, wxEmptyString, tags, applyLimit);`
`697`		`-}`
`698`		`-`
`699`	`693`	`void TagsStorageSQLite::GetTagsByKindAndFile(const wxArrayString& kind, const wxString& fileName,`
`700`	`694`	`const wxString& orderingColumn, int order, std::vector<TagEntryPtr>& tags)`
`701`	`695`	`{`
`@@ -948,7 +942,7 @@ void TagsStorageSQLite::GetTagsByScopeAndName(const wxArrayString& scope, const`
`948`	`942`	`}`
`949`	`943`
`950`	`944`	`void TagsStorageSQLite::GetTagsByScopeAndKind(const wxString& scope, const wxArrayString& kinds, const wxString& filter,`
`951`		`- std::vector<TagEntryPtr>& tags, bool applyLimit)`
	`945`	`+ std::vector<TagEntryPtr>& tags)`
`952`	`946`	`{`
`953`	`947`	`if(kinds.empty()) {`
`954`	`948`	`return;`
`@@ -973,9 +967,7 @@ void TagsStorageSQLite::GetTagsByScopeAndKind(const wxString& scope, const wxArr`
`973`	`967`	`sql << kinds_buffer;`
`974`	`968`	`}`
`975`	`969`
`976`		`- if(applyLimit) {`
`977`		`- sql << " LIMIT " << GetSingleSearchLimit();`
`978`		`- }`
	`970`	`+ sql << " LIMIT " << GetSingleSearchLimit();`
`979`	`971`	`DoFetchTags(sql, tags);`
`980`	`972`	`}`
`981`	`973`
Original file line number	Diff line number	Diff line change
`@@ -29,10 +29,9 @@`
`29`	`29`	`#include <wx/log.h>`
`30`	`30`	`#include <wx/tokenzr.h>`
`31`	`31`
`32`		`-DirTraverser::DirTraverser(const wxString &filespec, bool includeExtLessFiles)`
	`32`	`+DirTraverser::DirTraverser(const wxString &filespec)`
`33`	`33`	`: wxDirTraverser()`
`34`	`34`	`, m_filespec(filespec)`
`35`		`- , m_extlessFiles(includeExtLessFiles)`
`36`	`35`	`{`
`37`	`36`	`m_specArray = wxStringTokenize(filespec, wxT(";"), wxTOKEN_STRTOK);`
`38`	`37`	`}`
`@@ -41,18 +40,10 @@ wxDirTraverseResult DirTraverser::OnFile(const wxString& filename)`
`41`	`40`	`{`
`42`	`41`	`// add the file to our array`
`43`	`42`	`wxFileName fn(filename);`
`44`		`-`
`45`		`- if(FileUtils::WildMatch(m_filespec, fn)) {`
`46`		`- m_files.Add(filename);`
`47`		`- return wxDIR_CONTINUE;`
`48`		`- }`
`49`	`43`
`50`		`- // if we reached this point, no pattern was suitable for our file`
`51`		`- // test for extensionless file flag`
`52`		`- if (fn.GetExt().IsEmpty() && m_extlessFiles) {`
	`44`	`+ if (FileUtils::WildMatch(m_filespec, fn)) {`
`53`	`45`	`m_files.Add(filename);`
`54`	`46`	`}`
`55`		`-`
`56`	`47`	`return wxDIR_CONTINUE;`
`57`	`48`	`}`
`58`	`49`