Be a bit more explicit with internal and external linkage.

verible/common/analysis/matcher/inner-match-handlers.cc

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "verible/common/analysis/matcher/inner-match-handlers.h"
+
 #include <vector>
 
 #include "verible/common/analysis/matcher/bound-symbol-manager.h"

verible/common/formatting/align.cc

@@ -132,7 +132,8 @@ struct AlignmentCell {
 using AlignmentRow = VectorTree<AlignmentCell>;
 using AlignmentMatrix = std::vector<AlignmentRow>;
 
-std::ostream &operator<<(std::ostream &stream, const AlignmentCell &cell) {
+static std::ostream &operator<<(std::ostream &stream,
+                                const AlignmentCell &cell) {
   if (!cell.tokens.empty()) {
     // See UnwrappedLine::AsCode for similar printing.
     stream << absl::StrJoin(cell.tokens, " ",
@@ -480,8 +481,8 @@ static std::pair<std::string, char> GetColumnDataCellLabel(
   return {label.str(), node.Value().properties.flush_left ? '<' : '>'};
 }
 
-std::ostream &operator<<(std::ostream &stream,
-                         const VectorTree<AggregateColumnData> &tree) {
+static std::ostream &operator<<(std::ostream &stream,
+                                const VectorTree<AggregateColumnData> &tree) {
   ColumnsTreeFormatter<AggregateColumnData>(
       stream, tree, GetColumnDataCellLabel<AggregateColumnData>);
   return stream;
@@ -493,8 +494,8 @@ std::ostream &operator<<(std::ostream &stream, const ColumnPositionTree &tree) {
   return stream;
 }
 
-std::ostream &operator<<(std::ostream &stream,
-                         const VectorTree<AlignmentCell> &tree) {
+static std::ostream &operator<<(std::ostream &stream,
+                                const VectorTree<AlignmentCell> &tree) {
   ColumnsTreeFormatter<AlignmentCell>(
       stream, tree,
       [](const VectorTree<AlignmentCell> &node)
@@ -515,8 +516,8 @@ std::ostream &operator<<(std::ostream &stream,
   return stream;
 }
 
-std::ostream &operator<<(std::ostream &stream,
-                         const VectorTree<AlignedColumnConfiguration> &tree) {
+static std::ostream &operator<<(
+    std::ostream &stream, const VectorTree<AlignedColumnConfiguration> &tree) {
   ColumnsTreeFormatter<AlignedColumnConfiguration>(
       stream, tree, [](const VectorTree<AlignedColumnConfiguration> &node) {
         const auto &cell = node.Value();

verible/common/lsp/dummy-ls.cc

@@ -44,7 +44,7 @@ using verible::lsp::JsonRpcDispatcher;
 using verible::lsp::MessageStreamSplitter;
 
 // The "initialize" method requests server capabilities.
-InitializeResult InitializeServer(const nlohmann::json &params) {
+static InitializeResult InitializeServer(const nlohmann::json &params) {
   // Ignore passed client capabilities from params right now,
   // just announce what we do.
   InitializeResult result;

verible/common/lsp/jcxxgen.cc

@@ -37,6 +37,7 @@ ABSL_FLAG(std::string, json_header, "\"nlohmann/json.hpp\"",
           "Include path to json.hpp including brackets <> or quotes \"\" "
           "around.");
 
+namespace {
 // Interface. Currently private, but could be moved to a header if needed.
 struct Location {
   const char *filename;
@@ -89,13 +90,11 @@ struct ObjectType {
 
 using ObjectTypeVector = std::vector<ObjectType *>;
 
-static bool contains(const std::string &s, char c) {
-  return absl::StrContains(s, c);
-}
+bool contains(const std::string &s, char c) { return absl::StrContains(s, c); }
 
 // Returns if successful.
-static bool ParseObjectTypesFromFile(const std::string &filename,
-                                     ObjectTypeVector *parsed_out) {
+bool ParseObjectTypesFromFile(const std::string &filename,
+                              ObjectTypeVector *parsed_out) {
   static const RE2 emptyline_or_comment_re("^[ \t]*(#.*)?");
   static const RE2 toplevel_object_re("^([a-zA-Z0-9_]+):");
 
@@ -150,7 +149,7 @@ static bool ParseObjectTypesFromFile(const std::string &filename,
 }
 
 // Validate types and return if successful.
-static bool ValidateTypes(ObjectTypeVector *object_types) {
+bool ValidateTypes(ObjectTypeVector *object_types) {
   absl::flat_hash_map<std::string, ObjectType *> typeByName;
 
   for (auto &obj : *object_types) {
@@ -357,6 +356,7 @@ void GenerateCode(const std::string &filename,
     fprintf(out, "}  // %s\n", gen_namespace.c_str());
   }
 }
+}  // namespace
 
 int main(int argc, char *argv[]) {
   const auto usage =
@@ -386,4 +386,5 @@ int main(int argc, char *argv[]) {
 
   GenerateCode(schema_filename, absl::GetFlag(FLAGS_json_header),
                absl::GetFlag(FLAGS_class_namespace), *objects, out);
+  fclose(out);
 }

verible/common/lsp/lsp-file-utils_test.cc

@@ -23,15 +23,15 @@
 namespace verible {
 namespace lsp {
 
-std::string PathPrefix(const std::string &path) {
+static std::string PathPrefix(const std::string &path) {
 #ifdef _WIN32
   return absl::StrCat("y:/", path);
 #else
   return absl::StrCat("/", path);
 #endif
 }
 
-std::string URIPrefix(const std::string &path) {
+static std::string URIPrefix(const std::string &path) {
 #ifdef _WIN32
   return absl::StrCat("file:///y%3a/", path);
 #else

verible/common/strings/diff_test.cc

@@ -18,7 +18,6 @@
 #include <initializer_list>
 #include <ostream>
 #include <sstream>
-#include <string>
 #include <string_view>
 #include <vector>
 
@@ -29,7 +28,7 @@
 
 namespace diff {
 // Print functions copied from external_libs/editscript_test.cc
-std::ostream &operator<<(std::ostream &out, Operation operation) {
+static std::ostream &operator<<(std::ostream &out, Operation operation) {
   switch (operation) {
     case Operation::EQUALS:
       return (out << "EQUALS");
@@ -41,22 +40,11 @@ std::ostream &operator<<(std::ostream &out, Operation operation) {
   return out;
 }
 
-std::ostream &operator<<(std::ostream &out, const diff::Edit &edit) {
+static std::ostream &operator<<(std::ostream &out, const diff::Edit &edit) {
   out << "{" << edit.operation << ",[" << edit.start << "," << edit.end << ")}";
   return out;
 }
 
-std::ostream &operator<<(std::ostream &out, const Edits &edits) {
-  out << "Edits{";
-  std::string outer_delim;
-  for (auto &edit : edits) {
-    out << outer_delim << edit;
-    outer_delim = ",";
-  }
-  out << "};";
-  return out;
-}
-
 }  // namespace diff
 
 namespace verible {

verible/common/text/text-structure.cc

@@ -78,7 +78,7 @@ static bool TokenLocationLess(const TokenInfo &token,
 
 // Makes an iterator-writable copy of items_view without using const_cast.
 template <class V>
-std::vector<typename V::iterator> CopyWriteableIterators(
+static std::vector<typename V::iterator> CopyWriteableIterators(
     V &items, const std::vector<typename V::const_iterator> &items_view) {
   // precondition: items_view's iterators all point into items array.
   // postcondition: results's iterators point to the same items as items_view.

verible/common/text/text-structure_test.cc

@@ -72,15 +72,15 @@ TEST(FilterTokensTest, EmptyTokens) {
 }
 
 // Create a one-token token stream and syntax tree.
-void OneTokenTextStructureView(TextStructureView *view) {
+static void OneTokenTextStructureView(TextStructureView *view) {
   TokenInfo token(1, view->Contents());
   view->MutableTokenStream().push_back(token);
   view->MutableTokenStreamView().push_back(view->TokenStream().begin());
   view->MutableSyntaxTree() = Leaf(token);
 }
 
 // Create a two-token token stream, no syntax tree.
-void MultiTokenTextStructureViewNoTree(TextStructureView *view) {
+static void MultiTokenTextStructureViewNoTree(TextStructureView *view) {
   const auto contents = view->Contents();
   CHECK_GE(contents.length(), 5);
   auto &stream = view->MutableTokenStream();
@@ -467,7 +467,7 @@ TEST_F(TextStructureViewPublicTest, ExpandSubtreesEmpty) {
 }
 
 // Splits a single token into a syntax tree node with two leaves.
-void FakeParseToken(TextStructureView *data, int offset, int node_tag) {
+static void FakeParseToken(TextStructureView *data, int offset, int node_tag) {
   TokenSequence &tokens = data->MutableTokenStream();
   tokens.push_back(TokenInfo(11, data->Contents().substr(0, offset)));
   tokens.push_back(TokenInfo(12, data->Contents().substr(offset)));

verible/verilog/CST/module.cc

@@ -51,7 +51,7 @@ std::vector<verible::TreeSearchMatch> FindAllProgramDeclarations(
   return SearchSyntaxTree(root, NodekProgramDeclaration());
 }
 
-bool IsModuleOrInterfaceOrProgramDeclaration(
+static bool IsModuleOrInterfaceOrProgramDeclaration(
     const SyntaxTreeNode &declaration) {
   return declaration.MatchesTagAnyOf({NodeEnum::kModuleDeclaration,
                                       NodeEnum::kInterfaceDeclaration,

verible/verilog/CST/statement.cc

@@ -129,7 +129,7 @@ const SyntaxTreeNode *GetAssertionStatementAssertClause(
                           NodeEnum::kAssertionClause);
 }
 
-const SyntaxTreeNode *GetAssertionClauseStatementBody(
+static const SyntaxTreeNode *GetAssertionClauseStatementBody(
     const Symbol &assertion_clause) {
   const auto *body_node = GetGenericStatementBody(MatchNodeEnumOrNull(
       SymbolCastToNode(assertion_clause), NodeEnum::kAssertionClause));
@@ -154,7 +154,7 @@ const SyntaxTreeNode *GetAssumeStatementAssumeClause(
                           NodeEnum::kAssumeClause);
 }
 
-const SyntaxTreeNode *GetAssumeClauseStatementBody(
+static const SyntaxTreeNode *GetAssumeClauseStatementBody(
     const Symbol &assume_clause) {
   const auto *body_node = GetGenericStatementBody(MatchNodeEnumOrNull(
       SymbolCastToNode(assume_clause), NodeEnum::kAssumeClause));
@@ -197,7 +197,7 @@ const SyntaxTreeNode *GetAssertPropertyStatementAssertClause(
                           NodeEnum::kAssertPropertyClause);
 }
 
-const SyntaxTreeNode *GetAssertPropertyStatementBody(
+static const SyntaxTreeNode *GetAssertPropertyStatementBody(
     const Symbol &assert_clause) {
   const auto *body_node = GetGenericStatementBody(MatchNodeEnumOrNull(
       SymbolCastToNode(assert_clause), NodeEnum::kAssertPropertyClause));
@@ -225,7 +225,7 @@ const SyntaxTreeNode *GetAssumePropertyStatementAssumeClause(
                           NodeEnum::kAssumePropertyClause);
 }
 
-const SyntaxTreeNode *GetAssumePropertyStatementBody(
+static const SyntaxTreeNode *GetAssumePropertyStatementBody(
     const Symbol &assume_clause) {
   const auto *body_node = GetGenericStatementBody(MatchNodeEnumOrNull(
       SymbolCastToNode(assume_clause), NodeEnum::kAssumePropertyClause));
@@ -253,7 +253,7 @@ const SyntaxTreeNode *GetExpectPropertyStatementExpectClause(
                           NodeEnum::kExpectPropertyClause);
 }
 
-const SyntaxTreeNode *GetExpectPropertyStatementBody(
+static const SyntaxTreeNode *GetExpectPropertyStatementBody(
     const Symbol &expect_clause) {
   const auto *body_node = GetGenericStatementBody(MatchNodeEnumOrNull(
       SymbolCastToNode(expect_clause), NodeEnum::kExpectPropertyClause));
@@ -274,7 +274,7 @@ const SyntaxTreeNode *GetExpectPropertyStatementElseClause(
                              NodeEnum::kElseClause);
 }
 
-const SyntaxTreeNode *GetCoverPropertyStatementBody(
+static const SyntaxTreeNode *GetCoverPropertyStatementBody(
     const Symbol &cover_property) {
   const auto *body_node = GetGenericStatementBody(MatchNodeEnumOrNull(
       SymbolCastToNode(cover_property), NodeEnum::kCoverPropertyStatement));
@@ -283,7 +283,7 @@ const SyntaxTreeNode *GetCoverPropertyStatementBody(
       GetSubtreeAsSymbol(*body_node, NodeEnum::kCoverPropertyBody, 0));
 }
 
-const SyntaxTreeNode *GetCoverSequenceStatementBody(
+static const SyntaxTreeNode *GetCoverSequenceStatementBody(
     const Symbol &cover_sequence) {
   const auto *body_node = GetGenericStatementBody(MatchNodeEnumOrNull(
       SymbolCastToNode(cover_sequence), NodeEnum::kCoverSequenceStatement));

verible/verilog/CST/type.cc

@@ -350,7 +350,7 @@ const verible::SyntaxTreeLeaf *GetSymbolIdentifierFromEnumName(
   return verible::GetSubtreeAsLeaf(enum_name, NodeEnum::kEnumName, 0);
 }
 
-const verible::SyntaxTreeLeaf *GetTypeIdentifierFromInterfaceType(
+static const verible::SyntaxTreeLeaf *GetTypeIdentifierFromInterfaceType(
     const verible::Symbol &interface_type) {
   return verible::GetSubtreeAsLeaf(interface_type, NodeEnum::kInterfaceType, 2);
 }

verible/verilog/analysis/verilog-linter-configuration.cc

@@ -412,7 +412,7 @@ static const verible::EnumNameMap<RuleSet> &RuleSetEnumStringMap() {
   return kRuleSetEnumStringMap;
 }
 
-std::ostream &operator<<(std::ostream &stream, RuleSet rules) {
+static std::ostream &operator<<(std::ostream &stream, RuleSet rules) {
   return RuleSetEnumStringMap().Unparse(rules, stream);
 }
 

verible/verilog/formatting/align.cc

@@ -234,7 +234,7 @@ class VerilogColumnSchemaScanner : public ColumnSchemaScanner {
 };
 
 template <class ScannerType>
-std::function<verible::AlignmentCellScannerFunction(const FormatStyle &)>
+static std::function<verible::AlignmentCellScannerFunction(const FormatStyle &)>
 UnstyledAlignmentCellScannerGenerator() {
   return [](const FormatStyle &vstyle) {
     return AlignmentCellScannerGenerator<ScannerType>(
@@ -243,9 +243,10 @@ UnstyledAlignmentCellScannerGenerator() {
 }
 
 template <class ScannerType>
-std::function<verible::AlignmentCellScannerFunction(const FormatStyle &)>
-UnstyledAlignmentCellScannerGenerator(
-    const verible::NonTreeTokensScannerFunction &non_tree_column_scanner) {
+std::function<verible::AlignmentCellScannerFunction(
+    const FormatStyle
+        &)> static UnstyledAlignmentCellScannerGenerator(const verible::NonTreeTokensScannerFunction
+                                                             &non_tree_column_scanner) {
   return [non_tree_column_scanner](const FormatStyle &vstyle) {
     return AlignmentCellScannerGenerator<ScannerType>(
         [vstyle] { return ScannerType(vstyle); }, non_tree_column_scanner);
@@ -1292,8 +1293,8 @@ struct AlignmentGroupHandlers {
 // Returns the referenced member by value.
 // TODO(fangism): move this to an STL-style util/functional library
 template <typename MemberType, typename StructType>
-std::function<MemberType(const StructType &)> function_from_pointer_to_member(
-    MemberType StructType::*member) {
+static std::function<MemberType(const StructType &)>
+function_from_pointer_to_member(MemberType StructType::*member) {
   return [member](const StructType &obj) { return obj.*member; };
 }
 

verible/verilog/formatting/formatter.cc

@@ -115,9 +115,10 @@ class Formatter {
 };
 
 // TODO(b/148482625): make this public/re-usable for general content comparison.
-Status VerifyFormatting(const verible::TextStructureView &text_structure,
-                        std::string_view formatted_output,
-                        std::string_view filename) {
+// Not declared in any header, but also used in formatter_test
+extern Status VerifyFormatting(const verible::TextStructureView &text_structure,
+                               std::string_view formatted_output,
+                               std::string_view filename) {
   // Verify that the formatted output creates the same lexical
   // stream (filtered) as the original.  If any tokens were lost, fall back to
   // printing the original source unformatted.

verible/verilog/formatting/formatter_test.cc

@@ -53,9 +53,9 @@ namespace verilog {
 namespace formatter {
 
 // private, extern function in formatter.cc, directly tested here.
-absl::Status VerifyFormatting(const verible::TextStructureView &text_structure,
-                              std::string_view formatted_output,
-                              std::string_view filename);
+extern absl::Status VerifyFormatting(
+    const verible::TextStructureView &text_structure,
+    std::string_view formatted_output, std::string_view filename);
 
 namespace {
 

verible/verilog/formatting/token-annotator.cc

@@ -922,11 +922,11 @@ static WithReason<SpacingOptions> BreakDecisionBetween(
 // Extern linkage for sake of direct testing, though not exposed in public
 // headers.
 // TODO(fangism): could move this to a -internal.h header.
-void AnnotateFormatToken(const FormatStyle &style,
-                         const PreFormatToken &prev_token,
-                         PreFormatToken *curr_token,
-                         const SyntaxTreeContext &prev_context,
-                         const SyntaxTreeContext &curr_context) {
+extern void AnnotateFormatToken(const FormatStyle &style,
+                                const PreFormatToken &prev_token,
+                                PreFormatToken *curr_token,
+                                const SyntaxTreeContext &prev_context,
+                                const SyntaxTreeContext &curr_context) {
   const auto p = SpacesRequiredBetween(style, prev_token, *curr_token,
                                        prev_context, curr_context);
   curr_token->before.spaces_required = p.spaces_required;