🍫 Enable support-annotations lint checks

build/android/gyp/lint.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Runs Android's lint tool."""
 
 
 import argparse
 import os
 import sys
 import traceback
 from xml.dom import minidom
 
 from util import build_utils
 
 
 _SRC_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__),
                                          '..', '..', '..'))
 
 
 def _OnStaleMd5(changes, lint_path, config_path, processed_config_path,
                 manifest_path, result_path, product_dir, sources, jar_path,
-                cache_dir, resource_dir=None, can_fail_build=False,
-                silent=False):
+                cache_dir, resource_dir=None, classpath=None,
+                can_fail_build=False, silent=False):
 
   def _RelativizePath(path):
     """Returns relative path to top-level src dir.
 
     Args:
       path: A path relative to cwd.
     """
     return os.path.relpath(os.path.abspath(path), _SRC_ROOT)
 
   def _ProcessConfigFile():
@@ skipping 35 matching lines @@
           error = '%s %s: %s [warning]' % (path, message, issue_id)
         print >> sys.stderr, error.encode('utf-8')
         for attr in ['errorLine1', 'errorLine2']:
           error_line = issue.getAttribute(attr)
           if error_line:
             print >> sys.stderr, error_line.encode('utf-8')
     return len(issues)
 
   # Need to include all sources when a resource_dir is set so that resources are
   # not marked as unused.
+  # TODO(agrieve): Figure out how IDEs do incremental linting.
   if not resource_dir and changes.AddedOrModifiedOnly():
     changed_paths = set(changes.IterChangedPaths())
     sources = [s for s in sources if s in changed_paths]
 
   with build_utils.TempDir() as temp_dir:
     _ProcessConfigFile()
 
     cmd = [
         _RelativizePath(lint_path), '-Werror', '--exitcode', '--showall',
         '--xml', _RelativizePath(result_path),
     ]
     if jar_path:
+      # --classpath is just for .class files for this one target.
       cmd.extend(['--classpath', _RelativizePath(jar_path)])
     if processed_config_path:
       cmd.extend(['--config', _RelativizePath(processed_config_path)])
     if resource_dir:
       cmd.extend(['--resources', _RelativizePath(resource_dir)])
+    if classpath:
+      # --libraries is the classpath (excluding active target).
+      cp = ':'.join(_RelativizePath(p) for p in classpath)
+      cmd.extend(['--libraries', cp])
 
     # There may be multiple source files with the same basename (but in
     # different directories). It is difficult to determine what part of the path
     # corresponds to the java package, and so instead just link the source files
     # into temporary directories (creating a new one whenever there is a name
     # conflict).
     src_dirs = []
     def NewSourceDir():
       new_dir = os.path.join(temp_dir, str(len(src_dirs)))
       os.mkdir(new_dir)
@@ skipping 119 matching lines @@
   parser.add_argument('--config-path',
                       help='Path to lint suppressions file.')
   parser.add_argument('--enable', action='store_true',
                       help='Run lint instead of just touching stamp.')
   parser.add_argument('--jar-path',
                       help='Jar file containing class files.')
   parser.add_argument('--java-files',
                       help='Paths to java files.')
   parser.add_argument('--manifest-path',
                       help='Path to AndroidManifest.xml')
+  parser.add_argument('--classpath', default=[], action='append',
+                      help='GYP-list of classpath .jar files')
   parser.add_argument('--processed-config-path',
                       help='Path to processed lint suppressions file.')
   parser.add_argument('--resource-dir',
                       help='Path to resource dir.')
   parser.add_argument('--silent', action='store_true',
                       help='If set, script will not log anything.')
   parser.add_argument('--src-dirs',
                       help='Directories containing java files.')
   parser.add_argument('--stamp',
                       help='Path to touch on success.')
 
-  args = parser.parse_args()
+  args = parser.parse_args(build_utils.ExpandFileArgs(sys.argv[1:]))
 
   if args.enable:
     sources = []
     if args.src_dirs:
       src_dirs = build_utils.ParseGypList(args.src_dirs)
       sources = build_utils.FindInDirectories(src_dirs, '*.java')
     elif args.java_files:
       sources = build_utils.ParseGypList(args.java_files)
 
     if args.config_path and not args.processed_config_path:
       parser.error('--config-path specified without --processed-config-path')
     elif args.processed_config_path and not args.config_path:
       parser.error('--processed-config-path specified without --config-path')
 
     input_paths = [
         args.lint_path,
         args.platform_xml_path,
     ]
     if args.config_path:
       input_paths.append(args.config_path)
     if args.jar_path:
       input_paths.append(args.jar_path)
     if args.manifest_path:
       input_paths.append(args.manifest_path)
     if args.resource_dir:
       input_paths.extend(build_utils.FindInDirectory(args.resource_dir, '*'))
     if sources:
       input_paths.extend(sources)
+    classpath = []
+    for gyp_list in args.classpath:
+      classpath.extend(build_utils.ParseGypList(gyp_list))
+    input_paths.extend(classpath)
 
     input_strings = []
     if args.processed_config_path:
       input_strings.append(args.processed_config_path)
 
     output_paths = [ args.result_path ]
 
     build_utils.CallAndWriteDepfileIfStale(
         lambda changes: _OnStaleMd5(changes, args.lint_path,
                                     args.config_path,
                                     args.processed_config_path,
                                     args.manifest_path, args.result_path,
                                     args.product_dir, sources,
                                     args.jar_path,
                                     args.cache_dir,
                                     resource_dir=args.resource_dir,
+                                    classpath=classpath,
                                     can_fail_build=args.can_fail_build,
                                     silent=args.silent),
         args,
         input_paths=input_paths,
         input_strings=input_strings,
         output_paths=output_paths,
-        pass_changes=True)
+        pass_changes=True,
+        depfile_deps=classpath)
 
 
 if __name__ == '__main__':
   sys.exit(main())