Properly set up classpath for Android Lint (and fix its stderr filter)

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, classpath=None,
+                cache_dir, sdk_version, 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():
     if not config_path or not processed_config_path:
@@ skipping 84 matching lines @@
       src_dir = None
       for d in src_dirs:
         if not os.path.exists(PathInDir(d, src)):
           src_dir = d
           break
       if not src_dir:
         src_dir = NewSourceDir()
         cmd.extend(['--sources', _RelativizePath(src_dir)])
       os.symlink(os.path.abspath(src), PathInDir(src_dir, src))
 
+    project_dir = NewSourceDir()
+    # Create dummy project.properies file in a temporary "project" directory.
+    # It is the only way to add Android SDK to the Lint's classpath. Proper
+    # classpath is necessary for most source-level checks.
+    with open(os.path.join(project_dir, 'project.properties'), 'w') as propfile:
+      print >> propfile, 'target=android-{}'.format(sdk_version)
+
     # Put the manifest in a temporary directory in order to avoid lint detecting
     # sibling res/ and src/ directories (which should be pass explicitly if they
     # are to be included).
     if manifest_path:
-      src_dir = NewSourceDir()
       os.symlink(os.path.abspath(manifest_path),
-                 PathInDir(src_dir, manifest_path))
-      cmd.append(src_dir)
+                 PathInDir(project_dir, manifest_path))
+    cmd.append(project_dir)
 
     if os.path.exists(result_path):
       os.remove(result_path)
 
     env = {}
     stderr_filter = None
     if cache_dir:
+      env['_JAVA_OPTIONS'] = '-Duser.home=%s' % _RelativizePath(cache_dir)
       # When _JAVA_OPTIONS is set, java prints to stderr:
       # Picked up _JAVA_OPTIONS: ...
-      env['_JAVA_OPTIONS'] = '-Duser.home=%s' % _RelativizePath(cache_dir)
-      stderr_filter = lambda l: '' if '_JAVA_OPTIONS' in l else l
+      #
+      # We drop this line from the output.
+      stderr_filter = lambda l: re.sub(
+          r'^.*_JAVA_OPTIONS.*\n', '', l, flags=re.MULTILINE)

[agrieve, 2016/04/08 13:40:29]

nit: I don't think you need MULTILINE unless you use ^ or $. (which might be
worth adding)

[mlopatkin, 2016/04/08 16:55:16]

My intention was to replace all lines that contain '_JAVA_OPTIONS' to nothing
(including end-of-line symbol); I was using MULTILINE to make ^ match any line,
not only the first line, but it turns out that ^ isn't necessary at all: first
'.*' matches from the beginning of the line to the first  '_JAVA_OPTIONS'.

[agrieve, 2016/04/08 17:26:50]

oh garbage. Sorry about that. I just didn't see the ^ the first time around. 

 
     try:
       build_utils.CheckOutput(cmd, cwd=_SRC_ROOT, env=env or None,
                               stderr_filter=stderr_filter)
     except build_utils.CalledProcessError:
       # There is a problem with lint usage
       if not os.path.exists(result_path):
         raise
 
       # Sometimes produces empty (almost) files:
@@ skipping 57 matching lines @@
                       help='Path to lint executable.')
   parser.add_argument('--product-dir', required=True,
                       help='Path to product dir.')
   parser.add_argument('--result-path', required=True,
                       help='Path to XML lint result file.')
   parser.add_argument('--cache-dir', required=True,
                       help='Path to the directory in which the android cache '
                            'directory tree should be stored.')
   parser.add_argument('--platform-xml-path', required=True,
                       help='Path to api-platforms.xml')
+  parser.add_argument('--android-sdk-version', required=True,
+                      help='Version (API level) of the Android SDK used for '
+                           'building.')
   parser.add_argument('--create-cache', action='store_true',
                       help='Mark the lint cache file as an output rather than '
                       'an input.')
   parser.add_argument('--can-fail-build', action='store_true',
                       help='If set, script will exit with nonzero exit status'
                            ' if lint errors are present')
   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.')
@@ skipping 43 matching lines @@
       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 = []
+    input_strings = [ args.android_sdk_version ]
     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,
+                                    args.android_sdk_version,
                                     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,
         depfile_deps=classpath)
 
 
 if __name__ == '__main__':
   sys.exit(main())