diff options
| -rw-r--r-- | tools/apilint/deprecated_at_birth.py | 313 |
1 files changed, 313 insertions, 0 deletions
diff --git a/tools/apilint/deprecated_at_birth.py b/tools/apilint/deprecated_at_birth.py new file mode 100644 index 000000000000..297d9c3bcca0 --- /dev/null +++ b/tools/apilint/deprecated_at_birth.py @@ -0,0 +1,313 @@ +#!/usr/bin/env python + +# Copyright (C) 2021 The Android Open Source Project +# +# 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. + +""" +Usage: deprecated_at_birth.py path/to/next/ path/to/previous/ +Usage: deprecated_at_birth.py prebuilts/sdk/31/public/api/ prebuilts/sdk/30/public/api/ +""" + +import re, sys, os, collections, traceback, argparse + + +BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8) + +def format(fg=None, bg=None, bright=False, bold=False, dim=False, reset=False): + # manually derived from http://en.wikipedia.org/wiki/ANSI_escape_code#Codes + codes = [] + if reset: codes.append("0") + else: + if not fg is None: codes.append("3%d" % (fg)) + if not bg is None: + if not bright: codes.append("4%d" % (bg)) + else: codes.append("10%d" % (bg)) + if bold: codes.append("1") + elif dim: codes.append("2") + else: codes.append("22") + return "\033[%sm" % (";".join(codes)) + + +def ident(raw): + """Strips superficial signature changes, giving us a strong key that + can be used to identify members across API levels.""" + raw = raw.replace(" deprecated ", " ") + raw = raw.replace(" synchronized ", " ") + raw = raw.replace(" final ", " ") + raw = re.sub("<.+?>", "", raw) + raw = re.sub("@[A-Za-z]+ ", "", raw) + raw = re.sub("@[A-Za-z]+\(.+?\) ", "", raw) + if " throws " in raw: + raw = raw[:raw.index(" throws ")] + return raw + + +class Field(): + def __init__(self, clazz, line, raw, blame): + self.clazz = clazz + self.line = line + self.raw = raw.strip(" {;") + self.blame = blame + + raw = raw.split() + self.split = list(raw) + + raw = [ r for r in raw if not r.startswith("@") ] + for r in ["method", "field", "public", "protected", "static", "final", "abstract", "default", "volatile", "transient"]: + while r in raw: raw.remove(r) + + self.typ = raw[0] + self.name = raw[1].strip(";") + if len(raw) >= 4 and raw[2] == "=": + self.value = raw[3].strip(';"') + else: + self.value = None + self.ident = ident(self.raw) + + def __hash__(self): + return hash(self.raw) + + def __repr__(self): + return self.raw + + +class Method(): + def __init__(self, clazz, line, raw, blame): + self.clazz = clazz + self.line = line + self.raw = raw.strip(" {;") + self.blame = blame + + # drop generics for now + raw = re.sub("<.+?>", "", raw) + + raw = re.split("[\s(),;]+", raw) + for r in ["", ";"]: + while r in raw: raw.remove(r) + self.split = list(raw) + + raw = [ r for r in raw if not r.startswith("@") ] + for r in ["method", "field", "public", "protected", "static", "final", "abstract", "default", "volatile", "transient"]: + while r in raw: raw.remove(r) + + self.typ = raw[0] + self.name = raw[1] + self.args = [] + self.throws = [] + target = self.args + for r in raw[2:]: + if r == "throws": target = self.throws + else: target.append(r) + self.ident = ident(self.raw) + + def __hash__(self): + return hash(self.raw) + + def __repr__(self): + return self.raw + + +class Class(): + def __init__(self, pkg, line, raw, blame): + self.pkg = pkg + self.line = line + self.raw = raw.strip(" {;") + self.blame = blame + self.ctors = [] + self.fields = [] + self.methods = [] + + raw = raw.split() + self.split = list(raw) + if "class" in raw: + self.fullname = raw[raw.index("class")+1] + elif "enum" in raw: + self.fullname = raw[raw.index("enum")+1] + elif "interface" in raw: + self.fullname = raw[raw.index("interface")+1] + elif "@interface" in raw: + self.fullname = raw[raw.index("@interface")+1] + else: + raise ValueError("Funky class type %s" % (self.raw)) + + if "extends" in raw: + self.extends = raw[raw.index("extends")+1] + self.extends_path = self.extends.split(".") + else: + self.extends = None + self.extends_path = [] + + self.fullname = self.pkg.name + "." + self.fullname + self.fullname_path = self.fullname.split(".") + + self.name = self.fullname[self.fullname.rindex(".")+1:] + + def __hash__(self): + return hash((self.raw, tuple(self.ctors), tuple(self.fields), tuple(self.methods))) + + def __repr__(self): + return self.raw + + +class Package(): + def __init__(self, line, raw, blame): + self.line = line + self.raw = raw.strip(" {;") + self.blame = blame + + raw = raw.split() + self.name = raw[raw.index("package")+1] + self.name_path = self.name.split(".") + + def __repr__(self): + return self.raw + + +def _parse_stream(f, api={}): + line = 0 + pkg = None + clazz = None + blame = None + + re_blame = re.compile("^([a-z0-9]{7,}) \(<([^>]+)>.+?\) (.+?)$") + for raw in f: + line += 1 + raw = raw.rstrip() + match = re_blame.match(raw) + if match is not None: + blame = match.groups()[0:2] + raw = match.groups()[2] + else: + blame = None + + if raw.startswith("package"): + pkg = Package(line, raw, blame) + elif raw.startswith(" ") and raw.endswith("{"): + clazz = Class(pkg, line, raw, blame) + api[clazz.fullname] = clazz + elif raw.startswith(" ctor"): + clazz.ctors.append(Method(clazz, line, raw, blame)) + elif raw.startswith(" method"): + clazz.methods.append(Method(clazz, line, raw, blame)) + elif raw.startswith(" field"): + clazz.fields.append(Field(clazz, line, raw, blame)) + + return api + + +def _parse_stream_path(path): + api = {} + print "Parsing", path + for f in os.listdir(path): + f = os.path.join(path, f) + if not os.path.isfile(f): continue + if not f.endswith(".txt"): continue + if f.endswith("removed.txt"): continue + print "\t", f + with open(f) as s: + api = _parse_stream(s, api) + print "Parsed", len(api), "APIs" + print + return api + + +class Failure(): + def __init__(self, sig, clazz, detail, error, rule, msg): + self.sig = sig + self.error = error + self.rule = rule + self.msg = msg + + if error: + self.head = "Error %s" % (rule) if rule else "Error" + dump = "%s%s:%s %s" % (format(fg=RED, bg=BLACK, bold=True), self.head, format(reset=True), msg) + else: + self.head = "Warning %s" % (rule) if rule else "Warning" + dump = "%s%s:%s %s" % (format(fg=YELLOW, bg=BLACK, bold=True), self.head, format(reset=True), msg) + + self.line = clazz.line + blame = clazz.blame + if detail is not None: + dump += "\n in " + repr(detail) + self.line = detail.line + blame = detail.blame + dump += "\n in " + repr(clazz) + dump += "\n in " + repr(clazz.pkg) + dump += "\n at line " + repr(self.line) + if blame is not None: + dump += "\n last modified by %s in %s" % (blame[1], blame[0]) + + self.dump = dump + + def __repr__(self): + return self.dump + + +failures = {} + +def _fail(clazz, detail, error, rule, msg): + """Records an API failure to be processed later.""" + global failures + + sig = "%s-%s-%s" % (clazz.fullname, repr(detail), msg) + sig = sig.replace(" deprecated ", " ") + + failures[sig] = Failure(sig, clazz, detail, error, rule, msg) + + +def warn(clazz, detail, rule, msg): + _fail(clazz, detail, False, rule, msg) + +def error(clazz, detail, rule, msg): + _fail(clazz, detail, True, rule, msg) + + +if __name__ == "__main__": + next_path = sys.argv[1] + prev_path = sys.argv[2] + + next_api = _parse_stream_path(next_path) + prev_api = _parse_stream_path(prev_path) + + # Remove all existing things so we're left with new + for prev_clazz in prev_api.values(): + if prev_clazz.fullname not in next_api: continue + cur_clazz = next_api[prev_clazz.fullname] + + sigs = { i.ident: i for i in prev_clazz.ctors } + cur_clazz.ctors = [ i for i in cur_clazz.ctors if i.ident not in sigs ] + sigs = { i.ident: i for i in prev_clazz.methods } + cur_clazz.methods = [ i for i in cur_clazz.methods if i.ident not in sigs ] + sigs = { i.ident: i for i in prev_clazz.fields } + cur_clazz.fields = [ i for i in cur_clazz.fields if i.ident not in sigs ] + + # Forget about class entirely when nothing new + if len(cur_clazz.ctors) == 0 and len(cur_clazz.methods) == 0 and len(cur_clazz.fields) == 0: + del next_api[prev_clazz.fullname] + + for clazz in next_api.values(): + if "@Deprecated " in clazz.raw and not clazz.fullname in prev_api: + error(clazz, None, None, "Found API deprecation at birth") + + if "@Deprecated " in clazz.raw: continue + + for i in clazz.ctors + clazz.methods + clazz.fields: + if "@Deprecated " in i.raw: + error(clazz, i, None, "Found API deprecation at birth " + i.ident) + + print "%s Deprecated at birth %s\n" % ((format(fg=WHITE, bg=BLUE, bold=True), + format(reset=True))) + for f in sorted(failures): + print failures[f] + print |