🍫 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 re
 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 make do incremental lint.

[jbudorick, 2016/03/31 20:05:26]

s/make// ?

[agrieve, 2016/04/01 00:45:06]

Done.

   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).

[jbudorick, 2016/03/31 20:05:26]

this naming is now less than stellar, with jar_path going to --classpath and
classpath going to --libraries, but I guess that's more of an issue with lint's
bad command line arguments.

[agrieve, 2016/04/01 00:45:06]

Agree. Took me many minutes of reading through its source to figure out what the
difference was between --classpath and --libraries

+      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', help='Classpath for the target')
   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 = None
+    if args.classpath:
+      classpath = build_utils.ParseGypList(args.classpath)
+      # Faster to use .interface.jar.
+      classpath = [re.sub(r'\.jar$', '.interface.jar', p) for p in classpath]

[jbudorick, 2016/03/31 20:05:26]

Do we know that a corresponding .interface.jar class will always exist? What
about having the build system pass the .interface.jar if it wants to use that?
I'd prefer not having the script automagically use something other than what
gets passed.

[agrieve, 2016/04/01 00:45:06]

Done, but had to rebase onto: https://codereview.chromium.org/1846113002/ (also
for your review :P)

+      input_paths.extend(sources)
 
     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)
 
 
 if __name__ == '__main__':
   sys.exit(main())