| #!/usr/bin/env python |
| # |
| # Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file |
| # for details. All rights reserved. Use of this source code is governed by a |
| # BSD-style license that can be found in the LICENSE file. |
| |
| # Simple tool for verifying that sources from one layer do not reference |
| # sources from another layer. |
| # |
| # Currently it only checks that core runtime headers RUNTIME_LAYER_HEADERS |
| # are not included into any sources listed in SHOULD_NOT_DEPEND_ON_RUNTIME. |
| |
| import glob |
| import os |
| import re |
| import sys |
| |
| INCLUDE_DIRECTIVE_RE = re.compile(r'^#include "(.*)"') |
| |
| RUNTIME_LAYER_HEADERS = [ |
| 'runtime/vm/isolate.h', |
| 'runtime/vm/object.h', |
| 'runtime/vm/raw_object.h', |
| 'runtime/vm/thread.h', |
| ] |
| |
| SHOULD_NOT_DEPEND_ON_RUNTIME = [ |
| 'runtime/vm/allocation.h', |
| 'runtime/vm/growable_array.h', |
| ] |
| |
| |
| class LayeringChecker(object): |
| |
| def __init__(self, root): |
| self.root = root |
| self.worklist = set() |
| # Mapping from header to a set of files it is included into. |
| self.included_into = dict() |
| # Set of files that were parsed to avoid double parsing. |
| self.loaded = set() |
| # Mapping from headers to their layer. |
| self.file_layers = {file: 'runtime' for file in RUNTIME_LAYER_HEADERS} |
| |
| def Check(self): |
| self.AddAllSourcesToWorklist(os.path.join(self.root, 'runtime/vm')) |
| self.BuildIncludesGraph() |
| errors = self.PropagateLayers() |
| errors += self.CheckNotInRuntime(SHOULD_NOT_DEPEND_ON_RUNTIME) |
| return errors |
| |
| def CheckNotInRuntime(self, files): |
| """Check that given files do not depend on runtime layer.""" |
| errors = [] |
| for file in files: |
| if not os.path.exists(os.path.join(self.root, file)): |
| errors.append('File %s does not exist.' % (file)) |
| if self.file_layers.get(file) is not None: |
| errors.append( |
| 'LAYERING ERROR: %s includes object.h or raw_object.h' % |
| (file)) |
| return errors |
| |
| def BuildIncludesGraph(self): |
| while self.worklist: |
| file = self.worklist.pop() |
| deps = self.ExtractIncludes(file) |
| self.loaded.add(file) |
| for d in deps: |
| if d not in self.included_into: |
| self.included_into[d] = set() |
| self.included_into[d].add(file) |
| if d not in self.loaded: |
| self.worklist.add(d) |
| |
| def PropagateLayers(self): |
| """Propagate layering information through include graph. |
| |
| If A is in layer L and A is included into B then B is in layer L. |
| """ |
| errors = [] |
| self.worklist = set(self.file_layers.keys()) |
| while self.worklist: |
| file = self.worklist.pop() |
| if file not in self.included_into: |
| continue |
| file_layer = self.file_layers[file] |
| for tgt in self.included_into[file]: |
| if tgt in self.file_layers: |
| if self.file_layers[tgt] != file_layer: |
| errors.add( |
| 'Layer mismatch: %s (%s) is included into %s (%s)' % |
| (file, file_layer, tgt, self.file_layers[tgt])) |
| self.file_layers[tgt] = file_layer |
| self.worklist.add(tgt) |
| return errors |
| |
| def AddAllSourcesToWorklist(self, dir): |
| """Add all *.cc and *.h files from dir recursively into worklist.""" |
| for file in os.listdir(dir): |
| path = os.path.join(dir, file) |
| if os.path.isdir(path): |
| self.AddAllSourcesToWorklist(path) |
| elif path.endswith('.cc') or path.endswith('.h'): |
| self.worklist.add(os.path.relpath(path, self.root)) |
| |
| def ExtractIncludes(self, file): |
| """Extract the list of includes from the given file.""" |
| deps = set() |
| with open(os.path.join(self.root, file)) as file: |
| for line in file: |
| if line.startswith('namespace dart {'): |
| break |
| |
| m = INCLUDE_DIRECTIVE_RE.match(line) |
| if m is not None: |
| header = os.path.join('runtime', m.group(1)) |
| if os.path.isfile(os.path.join(self.root, header)): |
| deps.add(header) |
| return deps |
| |
| |
| def DoCheck(sdk_root): |
| """Run layering check at the given root folder.""" |
| return LayeringChecker(sdk_root).Check() |
| |
| |
| if __name__ == '__main__': |
| errors = DoCheck('.') |
| print '\n'.join(errors) |
| if errors: |
| sys.exit(-1) |