| #!/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) |
