grpc/tools/distrib/add-iwyu.py

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