mirror of https://github.com/grpc/grpc.git
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
130 lines
5.0 KiB
130 lines
5.0 KiB
#!/usr/bin/env python3 |
|
|
|
# Copyright 2021 gRPC authors. |
|
# |
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
|
# you may not use this file except in compliance with the License. |
|
# You may obtain a copy of the License at |
|
# |
|
# http://www.apache.org/licenses/LICENSE-2.0 |
|
# |
|
# Unless required by applicable law or agreed to in writing, software |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
# See the License for the specific language governing permissions and |
|
# limitations under the License. |
|
|
|
import collections |
|
import os |
|
|
|
|
|
def to_inc(filename): |
|
"""Given filename, synthesize what should go in an include statement to get that file""" |
|
if filename.startswith("include/"): |
|
return "<%s>" % filename[len("include/") :] |
|
return '"%s"' % filename |
|
|
|
|
|
def set_pragmas(filename, pragmas): |
|
"""Set the file-level IWYU pragma in filename""" |
|
lines = [] |
|
saw_first_define = False |
|
for line in open(filename).read().splitlines(): |
|
if line.startswith("// IWYU pragma: "): |
|
continue |
|
lines.append(line) |
|
if not saw_first_define and line.startswith("#define "): |
|
saw_first_define = True |
|
lines.append("") |
|
for pragma in pragmas: |
|
lines.append("// IWYU pragma: %s" % pragma) |
|
lines.append("") |
|
open(filename, "w").write("\n".join(lines) + "\n") |
|
|
|
|
|
def set_exports(pub, cg): |
|
"""In file pub, mark the include for cg with IWYU pragma: export""" |
|
lines = [] |
|
for line in open(pub).read().splitlines(): |
|
if line.startswith("#include %s" % to_inc(cg)): |
|
lines.append("#include %s // IWYU pragma: export" % to_inc(cg)) |
|
else: |
|
lines.append(line) |
|
open(pub, "w").write("\n".join(lines) + "\n") |
|
|
|
|
|
CG_ROOTS_GRPC = ( |
|
(r"sync", "grpc/support/sync.h", False), |
|
(r"atm", "grpc/support/atm.h", False), |
|
(r"grpc_types", "grpc/grpc.h", True), |
|
(r"gpr_types", "grpc/grpc.h", True), |
|
(r"compression_types", "grpc/compression.h", True), |
|
(r"connectivity_state", "grpc/grpc.h", True), |
|
) |
|
|
|
CG_ROOTS_GRPCPP = [ |
|
(r"status_code_enum", "grpcpp/support/status.h", False), |
|
] |
|
|
|
|
|
def fix_tree(tree, cg_roots): |
|
"""Fix one include tree""" |
|
# Map of filename --> paths including that filename |
|
reverse_map = collections.defaultdict(list) |
|
# The same, but for things with '/impl/codegen' in their names |
|
cg_reverse_map = collections.defaultdict(list) |
|
for root, dirs, files in os.walk(tree): |
|
root_map = cg_reverse_map if "/impl/codegen" in root else reverse_map |
|
for filename in files: |
|
root_map[filename].append(root) |
|
# For each thing in '/impl/codegen' figure out what exports it |
|
for filename, paths in cg_reverse_map.items(): |
|
print("****", filename) |
|
# Exclude non-headers |
|
if not filename.endswith(".h"): |
|
continue |
|
pragmas = [] |
|
# Check for our 'special' headers: if we see one of these, we just |
|
# hardcode where they go to because there's some complicated rules. |
|
for root, target, friend in cg_roots: |
|
print(root, target, friend) |
|
if filename.startswith(root): |
|
pragmas = ["private, include <%s>" % target] |
|
if friend: |
|
pragmas.append('friend "src/.*"') |
|
if len(paths) == 1: |
|
path = paths[0] |
|
if filename.startswith(root + "."): |
|
set_exports("include/" + target, path + "/" + filename) |
|
if filename.startswith(root + "_"): |
|
set_exports( |
|
path + "/" + root + ".h", path + "/" + filename |
|
) |
|
# If the path for a file in /impl/codegen is ambiguous, just don't bother |
|
if not pragmas and len(paths) == 1: |
|
path = paths[0] |
|
# Check if we have an exporting candidate |
|
if filename in reverse_map: |
|
proper = reverse_map[filename] |
|
# And that it too is unambiguous |
|
if len(proper) == 1: |
|
# Build the two relevant pathnames |
|
cg = path + "/" + filename |
|
pub = proper[0] + "/" + filename |
|
# And see if the public file actually includes the /impl/codegen file |
|
if ("#include %s" % to_inc(cg)) in open(pub).read(): |
|
# Finally, if it does, we'll set that pragma |
|
pragmas = ["private, include %s" % to_inc(pub)] |
|
# And mark the export |
|
set_exports(pub, cg) |
|
# If we can't find a good alternative include to point people to, |
|
# mark things private anyway... we don't want to recommend people include |
|
# from impl/codegen |
|
if not pragmas: |
|
pragmas = ["private"] |
|
for path in paths: |
|
set_pragmas(path + "/" + filename, pragmas) |
|
|
|
|
|
fix_tree("include/grpc", CG_ROOTS_GRPC) |
|
fix_tree("include/grpcpp", CG_ROOTS_GRPCPP)
|
|
|