Backed out changeset b526011049ee (bug 1406668) for linting failures. r=backout
authorSebastian Hengst <archaeopteryx@coole-files.de>
Thu, 12 Oct 2017 14:41:28 +0200
changeset 385803 5f94b18b43935d86c632e25cbb12bf5f19827ce1
parent 385802 41debb5cecaf0c030d611ac51442939ac46620bf
child 385804 eefd55a8cc0250b1fc871278ad66e4dff853926b
push id32668
push userarchaeopteryx@coole-files.de
push dateThu, 12 Oct 2017 21:56:02 +0000
treeherdermozilla-central@46a75c66bb51 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbackout
bugs1406668
milestone58.0a1
backs outb526011049eed2b052cb5dc93f7fa14a4f970c0b
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changeset b526011049ee (bug 1406668) for linting failures. r=backout
build/moz.configure/android-ndk.configure
build/moz.configure/checks.configure
build/moz.configure/compile-checks.configure
build/moz.configure/compilers-util.configure
build/moz.configure/headers.configure
build/moz.configure/init.configure
build/moz.configure/java.configure
build/moz.configure/keyfiles.configure
build/moz.configure/memory.configure
build/moz.configure/old.configure
build/moz.configure/pkg.configure
build/moz.configure/rust.configure
build/moz.configure/toolchain.configure
build/moz.configure/util.configure
build/moz.configure/windows.configure
tools/lint/flake8.yml
--- a/build/moz.configure/android-ndk.configure
+++ b/build/moz.configure/android-ndk.configure
@@ -6,31 +6,28 @@
 
 
 js_option('--with-android-ndk', nargs=1,
           help='location where the Android NDK can be found')
 
 js_option('--with-android-toolchain', nargs=1,
           help='location of the Android toolchain')
 
-
 @depends(target)
 def min_android_version(target):
     if target.cpu in ['aarch64', 'x86_64', 'mips64']:
         # 64-bit support was added in API 21.
         return '21'
     return '9'
 
-
 js_option('--with-android-version',
           nargs=1,
           help='android platform version',
           default=min_android_version)
 
-
 @depends('--with-android-version', min_android_version, '--help')
 @imports(_from='__builtin__', _import='ValueError')
 def android_version(value, min_version, _):
     if not value:
         # Someone has passed --without-android-version.
         die('--with-android-version cannot be disabled.')
 
     try:
@@ -39,35 +36,31 @@ def android_version(value, min_version, 
         die('--with-android-version expects an integer value')
 
     if version < int(min_version):
         die('--with-android-version must be at least %s (got %s)',
             min_version, value[0])
 
     return version
 
-
 add_old_configure_assignment('android_version', android_version)
 
-
 @depends('--with-android-ndk', build_project, '--help')
 def ndk(value, build_project, help):
     if help:
         return
     if build_project == 'mobile/android' and not value:
         die('You must specify --with-android-ndk=/path/to/ndk when '
             'building mobile/android')
     if value:
         return value[0]
 
-
 set_config('ANDROID_NDK', ndk)
 add_old_configure_assignment('android_ndk', ndk)
 
-
 @depends(ndk)
 @checking('for android ndk version')
 @imports(_from='__builtin__', _import='open')
 def ndk_version(ndk):
     if not ndk:
         # Building 'js/src' for non-Android.
         return
     with open(os.path.join(ndk, 'source.properties'), 'r') as f:
@@ -75,44 +68,39 @@ def ndk_version(ndk):
             if not line.startswith('Pkg.Revision'):
                 continue
             (_, version) = line.split('=')
             if version:
                 return version.strip()
             die('Unexpected Pkg.Revision line in source.properties')
     die('Cannot determine NDK version from source.properties')
 
-
 @depends(ndk_version)
 def ndk_major_version(ndk_version):
     if not ndk_version:
         # Building 'js/src' for non-Android.
         return
     (major, minor, revision) = ndk_version.split('.')
     if major:
         return major
     die('Unexpected NDK version string: ' + ndk_version)
 
-
-set_config('ANDROID_NDK_MAJOR_VERSION', ndk_major_version)
-
+set_config('ANDROID_NDK_MAJOR_VERSION', ndk_major_version);
 
 @depends(ndk_version)
 def ndk_minor_version(ndk_version):
     if not ndk_version:
         # Building 'js/src' for non-Android.
         return
     (major, minor, revision) = ndk_version.split('.')
     if minor:
         return minor
     die('Unexpected NDK version string: ' + ndk_version)
 
-
-set_config('ANDROID_NDK_MINOR_VERSION', ndk_minor_version)
-
+set_config('ANDROID_NDK_MINOR_VERSION', ndk_minor_version);
 
 @depends(target, android_version, ndk, '--help')
 @checking('for android platform directory')
 @imports(_from='os.path', _import='isdir')
 def android_platform(target, android_version, ndk, _):
     if target.os != 'Android':
         return
 
@@ -138,28 +126,25 @@ def android_platform(target, android_ver
                                 'arch-%s' % target_dir_name)
 
     if not isdir(platform_dir):
         die("Android platform directory not found. With the current "
             "configuration, it should be in %s" % platform_dir)
 
     return platform_dir
 
-
 add_old_configure_assignment('android_platform', android_platform)
 
-
 @depends(android_platform)
 def extra_toolchain_flags(platform_dir):
     if not platform_dir:
         return []
     return ['-idirafter',
             os.path.join(platform_dir, 'usr', 'include')]
 
-
 @depends(target, host, ndk, '--with-android-toolchain', '--help')
 @checking('for the Android toolchain directory', lambda x: x or 'not found')
 @imports(_from='os.path', _import='isdir')
 @imports(_from='mozbuild.shellutil', _import='quote')
 def android_toolchain(target, host, ndk, toolchain, _):
     if not ndk:
         return
     if toolchain:
@@ -185,43 +170,38 @@ def android_toolchain(target, host, ndk,
             toolchain = toolchain_format % (ndk, target_base, version,
                                             host.kernel.lower(), 'x86')
             log.debug('Trying %s' % quote(toolchain))
         if isdir(toolchain):
             return toolchain
         die('You have to specify --with-android-toolchain='
             '/path/to/ndk/toolchain.')
 
-
 set_config('ANDROID_TOOLCHAIN', android_toolchain)
 
-
 @depends(target)
 def android_toolchain_prefix_base(target):
     if target.cpu == 'x86':
         # Ideally, the --target should just have the right x86 variant
         # in the first place.
         return 'i686-linux-android'
     return target.toolchain
 
-
 @depends(android_toolchain_prefix_base, android_toolchain)
 def android_toolchain_prefix(prefix_base, toolchain):
     if toolchain:
         return '%s/bin/%s-' % (toolchain, prefix_base)
 
-
 imply_option('--with-toolchain-prefix', android_toolchain_prefix,
              reason='--with-android-ndk')
 
 option(env='STLPORT_CPPFLAGS',
        nargs=1,
        help='Options compiler should pass for standard C++ library')
 
-
 @depends('STLPORT_CPPFLAGS', ndk, '--help')
 @imports(_from='os.path', _import='isdir')
 def stlport_cppflags(value, ndk, _):
     if value and len(value):
         return value
     if not ndk:
         return
 
@@ -246,28 +226,25 @@ def stlport_cppflags(value, ndk, _):
     # Add android/support/include/ for prototyping long double math
     # functions, locale-specific C library functions, multibyte support,
     # etc.
     return "-I%s -I%s -I%s" % (cxx_include,
                                os.path.join(ndk, 'sources', 'android',
                                             'support', 'include'),
                                cxxabi_include)
 
-
 add_old_configure_assignment('stlport_cppflags', stlport_cppflags)
 
-
 @depends(stlport_cppflags, android_platform, android_toolchain,
          android_toolchain_prefix_base, '--help')
 def bindgen_cflags_defaults(stlport_cppflags, android_platform, toolchain,
                             toolchain_prefix, _):
     if not stlport_cppflags:
         return
 
-    gcc_include = os.path.join(
-        toolchain, 'lib', 'gcc', toolchain_prefix, '4.9')
+    gcc_include = os.path.join(toolchain, 'lib', 'gcc', toolchain_prefix, '4.9')
 
     cflags_format = "%s -isystem %s -gcc-toolchain %s -I%s -I%s"
     return cflags_format % (stlport_cppflags,
                             os.path.join(android_platform, 'usr', 'include'),
                             toolchain,
                             os.path.join(gcc_include, 'include'),
                             os.path.join(gcc_include, 'include-fixed'))
--- a/build/moz.configure/checks.configure
+++ b/build/moz.configure/checks.configure
@@ -6,29 +6,26 @@
 
 # Templates implementing some generic checks.
 # ==============================================================
 
 # Declare some exceptions. This is cumbersome, but since we shouldn't need a
 # lot of them, let's stack them all here. When adding a new one, put it in the
 # _declare_exceptions template, and add it to the return statement. Then
 # destructure in the assignment below the function declaration.
-
-
 @template
 @imports(_from='__builtin__', _import='Exception')
 def _declare_exceptions():
     class FatalCheckError(Exception):
         '''An exception to throw from a function decorated with @checking.
         It will result in calling die() with the given message.
         Debugging messages emitted from the decorated function will also be
         printed out.'''
     return (FatalCheckError,)
 
-
 (FatalCheckError,) = _declare_exceptions()
 
 del _declare_exceptions
 
 # Helper to display "checking" messages
 #   @checking('for foo')
 #   def foo():
 #       return 'foo'
@@ -40,18 +37,16 @@ del _declare_exceptions
 #       return ret
 # This can be combined with e.g. @depends:
 #   @depends(some_option)
 #   @checking('for something')
 #   def check(value):
 #       ...
 # An optional callback can be given, that will be used to format the returned
 # value when displaying it.
-
-
 @template
 def checking(what, callback=None):
     def decorator(func):
         def wrapped(*args, **kwargs):
             log.info('checking %s... ', what)
             with log.queue_debug():
                 error, ret = None, None
                 try:
--- a/build/moz.configure/compile-checks.configure
+++ b/build/moz.configure/compile-checks.configure
@@ -63,31 +63,28 @@ def check_header(header, language='C++',
     set_define(header_var, have_header)
     return have_header
 
 # A convenience wrapper for check_header for checking multiple headers.
 # returns an array of the resulting checks in order corresponding to the
 # provided headers.
 # - `headers` are the headers to be checked.
 # - `kwargs` are keyword arguments passed verbatim to check_header.
-
-
 @template
 def check_headers(*headers, **kwargs):
     checks = []
     for header in headers:
         checks.append(check_header(header, **kwargs))
     return checks
 
 
 @dependable
 def warnings_cflags():
     return []
 
-
 @dependable
 def warnings_cxxflags():
     return []
 
 
 # Tests whether GCC or clang support the given warning flag, and if it is,
 # add it to the list of warning flags for the build.
 # - `warning` is the warning flag (e.g. -Wfoo)
@@ -147,13 +144,11 @@ def check_and_add_gcc_warning(warning, c
 
 # Add the given warning to the list of warning flags for the build.
 # - `warning` is the warning flag (e.g. -Wfoo)
 # - `compiler` (optional) is the compiler to add the flag for (c_compiler or
 #   cxx_compiler, from toolchain.configure). When omitted, the warning flag
 #   is added for both compilers.
 # - `when` (optional) is a @depends function or option name conditioning
 #   when the warning flag is wanted.
-
-
 @template
 def add_gcc_warning(warning, compiler=None, when=None):
     check_and_add_gcc_warning(warning, compiler, when, check=False)
--- a/build/moz.configure/compilers-util.configure
+++ b/build/moz.configure/compilers-util.configure
@@ -1,15 +1,14 @@
 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-
 @template
 @imports('textwrap')
 @imports(_from='mozbuild.configure', _import='SandboxDependsFunction')
 def compiler_class(compiler, host_or_target):
     is_target = host_or_target is target
 
     class Compiler(SandboxDependsFunction):
         # Generates a test program and attempts to compile it. In case of
@@ -50,18 +49,17 @@ def compiler_class(compiler, host_or_tar
             @checking_fn
             def func(compiler, flags, extra_flags):
                 flags = flags or []
                 if is_target:
                     flags += extra_flags or []
                 flags.append('-c')
 
                 if try_invoke_compiler(
-                        compiler.wrapper +
-                        [compiler.compiler] + compiler.flags,
-                        compiler.language, source, flags,
-                        onerror=onerror) is not None:
+                    compiler.wrapper + [compiler.compiler] + compiler.flags,
+                    compiler.language, source, flags,
+                    onerror=onerror) is not None:
                     return True
 
             return func
 
     compiler.__class__ = Compiler
     return compiler
--- a/build/moz.configure/headers.configure
+++ b/build/moz.configure/headers.configure
@@ -67,32 +67,27 @@ check_headers(
 # TODO: Move these checks to file specific to --enable-project=js.
 have_perf_event_h = check_header('linux/perf_event.h',
                                  when=building_linux)
 
 js_option('--with-linux-headers',
           help='location where the Linux kernel headers can be found',
           nargs=1)
 
-passed_linux_header_flags = depends_if(
-    '--with-linux-headers')(lambda v: ['-I%s' % v[0]])
-
+passed_linux_header_flags = depends_if('--with-linux-headers')(lambda v: ['-I%s' % v[0]])
 
 @depends(try_compile(includes=['asm/unistd.h'],
                      body='return sizeof(__NR_perf_event_open);',
                      flags=passed_linux_header_flags,
                      check_msg='for perf_event_open system call'),
          when=have_perf_event_h)
 def have_perf_event_open(have_perf_event_open):
     if have_perf_event_open:
         return True
 
-
 set_config('HAVE_LINUX_PERF_EVENT_H', have_perf_event_open)
 
-
 @depends(passed_linux_header_flags, have_perf_event_open)
 def linux_headers_includes(passed_linux_header_flags, have_perf_event_open):
     if have_perf_event_open and passed_linux_header_flags:
         return passed_linux_header_flags[0]
 
-
 set_config('LINUX_HEADERS_INCLUDES', linux_headers_includes)
--- a/build/moz.configure/init.configure
+++ b/build/moz.configure/init.configure
@@ -6,18 +6,16 @@
 
 include('util.configure')
 include('checks.configure')
 
 option(env='DIST', nargs=1, help='DIST directory')
 
 # Do not allow objdir == srcdir builds.
 # ==============================================================
-
-
 @depends('--help', 'DIST')
 @imports(_from='os.path', _import='exists')
 def check_build_environment(help, dist):
     topobjdir = os.path.realpath(os.path.abspath('.'))
     topsrcdir = os.path.realpath(os.path.abspath(
         os.path.join(os.path.dirname(__file__), '..', '..')))
 
     if dist:
@@ -39,17 +37,17 @@ def check_build_environment(help, dist):
             '  * Building directly in the main source directory is not allowed.\n'
             '  *\n'
             '  * To build, you must run configure from a separate directory\n'
             '  * (referred to as an object directory).\n'
             '  *\n'
             '  * If you are building with a mozconfig, you will need to change your\n'
             '  * mozconfig to point to a different object directory.\n'
             '  ***'
-            )
+        )
 
     # Check for a couple representative files in the source tree
     conflict_files = [
         '*         %s' % f for f in ('Makefile', 'config/autoconf.mk')
         if exists(os.path.join(topsrcdir, f))
     ]
     if conflict_files:
         die('  ***\n'
@@ -58,21 +56,20 @@ def check_build_environment(help, dist):
             '  *   This indicates that you previously built in the source tree.\n'
             '  *   A source tree build can confuse the separate objdir build.\n'
             '  *\n'
             '  *   To clean up the source tree:\n'
             '  *     1. cd %s\n'
             '  *     2. gmake distclean\n'
             '  ***'
             % ('\n  '.join(conflict_files), topsrcdir)
-            )
+        )
 
     return result
 
-
 set_config('TOPSRCDIR', check_build_environment.topsrcdir)
 set_config('TOPOBJDIR', check_build_environment.topobjdir)
 set_config('MOZ_BUILD_ROOT', check_build_environment.topobjdir)
 set_config('DIST', check_build_environment.dist)
 
 add_old_configure_assignment(
     '_topsrcdir', check_build_environment.topsrcdir)
 add_old_configure_assignment(
@@ -89,33 +86,29 @@ set_config('MOZ_AUTOMATION', depends_if(
 option(env='OLD_CONFIGURE', nargs=1, help='Path to the old configure script')
 
 option(env='MOZ_CURRENT_PROJECT', nargs=1, help='Current build project')
 option(env='MOZCONFIG', nargs=1, help='Mozconfig location')
 
 option('--with-external-source-dir', env='EXTERNAL_SOURCE_DIR', nargs=1,
        help='External directory containing additional build files')
 
-
 @depends('--with-external-source-dir')
 def external_source_dir(value):
     if value:
         return value[0]
 
-
 set_config('EXTERNAL_SOURCE_DIR', external_source_dir)
 add_old_configure_assignment('EXTERNAL_SOURCE_DIR', external_source_dir)
 
 # Read user mozconfig
 # ==============================================================
 # Note: the dependency on --help is only there to always read the mozconfig,
 # even when --help is passed. Without this dependency, the function wouldn't
 # be called when --help is passed, and the mozconfig wouldn't be read.
-
-
 @depends('MOZ_CURRENT_PROJECT', 'MOZCONFIG', 'OLD_CONFIGURE',
          check_build_environment, '--with-external-source-dir',
          '--help')
 @imports(_from='mozbuild.mozconfig', _import='MozconfigLoader')
 def mozconfig(current_project, mozconfig, old_configure, build_env,
               external_source_dir, help):
     if not old_configure:
         die('The OLD_CONFIGURE environment variable must be set')
@@ -145,26 +138,23 @@ def mozconfig(current_project, mozconfig
     loader = MozconfigLoader(topsrcdir)
     current_project = current_project[0] if current_project else None
     mozconfig = mozconfig[0] if mozconfig else None
     mozconfig = loader.find_mozconfig(env={'MOZCONFIG': mozconfig})
     mozconfig = loader.read_mozconfig(mozconfig, moz_build_app=current_project)
 
     return mozconfig
 
-
 set_config('MOZCONFIG', depends(mozconfig)(lambda m: m['path']))
 
 
 option(env='PYTHON', nargs=1, help='Python interpreter')
 
 # Setup python virtualenv
 # ==============================================================
-
-
 @depends('PYTHON', check_build_environment, mozconfig, '--help')
 @imports('os')
 @imports('sys')
 @imports('subprocess')
 @imports(_from='mozbuild.configure.util', _import='LineIO')
 @imports(_from='mozbuild.virtualenv', _import='VirtualenvManager')
 @imports(_from='mozbuild.virtualenv', _import='verify_python_version')
 @imports('distutils.sysconfig')
@@ -198,18 +188,17 @@ def virtualenv_python(env_python, build_
             topsrcdir, topobjdir,
             os.path.join(topobjdir, '_virtualenv'), out,
             os.path.join(topsrcdir, 'build', 'virtualenv_packages.txt'))
 
     if python:
         # If we're not in the virtualenv, we need the which module for
         # find_program.
         if normsep(sys.executable) != normsep(manager.python_path):
-            sys.path.append(os.path.join(
-                topsrcdir, 'third_party', 'python', 'which'))
+            sys.path.append(os.path.join(topsrcdir, 'third_party', 'python', 'which'))
         found_python = find_program(python)
         if not found_python:
             die('The PYTHON environment variable does not contain '
                 'a valid path. Cannot find %s', python)
         python = found_python
     else:
         python = sys.executable
 
@@ -228,42 +217,37 @@ def virtualenv_python(env_python, build_
         sys.exit(subprocess.call([python] + sys.argv))
 
     # We are now in the virtualenv
     if not distutils.sysconfig.get_python_lib():
         die('Could not determine python site packages directory')
 
     return python
 
-
 set_config('PYTHON', virtualenv_python)
 add_old_configure_assignment('PYTHON', virtualenv_python)
 
 # Inject mozconfig options
 # ==============================================================
 # All options defined above this point can't be injected in mozconfig_options
 # below, so collect them.
-
-
 @template
 def early_options():
     @dependable
     @imports('__sandbox__')
     def early_options():
         return set(
             option.env
             for option in __sandbox__._options.itervalues()
             if option.env
         )
     return early_options
 
-
 early_options = early_options()
 
-
 @depends(mozconfig, 'MOZ_AUTOMATION', '--help')
 # This gives access to the sandbox. Don't copy this blindly.
 @imports('__sandbox__')
 @imports('os')
 def mozconfig_options(mozconfig, automation, help):
     if mozconfig['path']:
         if 'MOZ_AUTOMATION_MOZCONFIG' in mozconfig['env']['added']:
             if not automation:
@@ -304,18 +288,16 @@ def mozconfig_options(mozconfig, automat
 # ==============================================================
 option(env='MOZILLABUILD', nargs=1,
        help='Path to Mozilla Build (Windows-only)')
 
 option(env='CONFIG_SHELL', nargs=1, help='Path to a POSIX shell')
 
 # It feels dirty replicating this from python/mozbuild/mozbuild/mozconfig.py,
 # but the end goal being that the configure script would go away...
-
-
 @depends('CONFIG_SHELL', 'MOZILLABUILD')
 @checking('for a shell')
 @imports('sys')
 def shell(value, mozillabuild):
     if value:
         return find_program(value[0])
     shell = 'sh'
     if mozillabuild:
@@ -325,17 +307,16 @@ def shell(value, mozillabuild):
     return find_program(shell)
 
 
 # Python 3
 # ========
 
 option(env='PYTHON3', nargs=1, help='Python 3 interpreter (3.5 or later)')
 
-
 @depends('PYTHON3')
 @checking('for Python 3',
           callback=lambda x: '%s (%s)' % (x.path, x.str_version) if x else 'no')
 @imports(_from='__builtin__', _import='Exception')
 @imports(_from='mozbuild.pythonutil', _import='find_python3_executable')
 @imports(_from='mozbuild.pythonutil', _import='python_executable_version')
 def python3(env_python):
     python = env_python[0] if env_python else None
@@ -362,75 +343,68 @@ def python3(env_python):
         python = python.decode('utf-8')
 
     return namespace(
         path=python,
         version=version,
         str_version='.'.join(str(v) for v in version),
     )
 
-
 set_config('PYTHON3', depends_if(python3)(lambda p: p.path))
 set_config('PYTHON3_VERSION', depends_if(python3)(lambda p: p.str_version))
 
 # Source checkout and version control integration.
 # ================================================
 
-
 @depends(check_build_environment, 'MOZ_AUTOMATION', '--help')
 @checking('for vcs source checkout')
 @imports('os')
 def vcs_checkout_type(build_env, automation, _):
     if os.path.exists(os.path.join(build_env.topsrcdir, '.hg')):
         return 'hg'
     elif os.path.exists(os.path.join(build_env.topsrcdir, '.git')):
         return 'git'
     elif automation:
         raise FatalCheckError('unable to resolve VCS type; must run '
                               'from a source checkout when MOZ_AUTOMATION '
                               'is set')
 
 # Resolve VCS binary for detected repository type.
 
-
 # TODO remove hg.exe once bug 1382940 addresses ambiguous executables case.
 hg = check_prog('HG', ('hg.exe', 'hg',), allow_missing=True,
                 when=depends(vcs_checkout_type)(lambda x: x == 'hg'))
 git = check_prog('GIT', ('git',), allow_missing=True,
                  when=depends(vcs_checkout_type)(lambda x: x == 'git'))
 
-
 @depends_if(hg)
 @checking('for Mercurial version')
 @imports('os')
 @imports('re')
 def hg_version(hg):
     # HGPLAIN in Mercurial 1.5+ forces stable output, regardless of set
     # locale or encoding.
     env = dict(os.environ)
     env['HGPLAIN'] = '1'
 
     out = check_cmd_output(hg, '--version', env=env)
 
     match = re.search(r'Mercurial Distributed SCM \(version ([^\)]+)', out)
 
     if not match:
-        raise FatalCheckError(
-            'unable to determine Mercurial version: %s' % out)
+        raise FatalCheckError('unable to determine Mercurial version: %s' % out)
 
     # The version string may be "unknown" for Mercurial run out of its own
     # source checkout or for bad builds. But LooseVersion handles it.
 
     return Version(match.group(1))
 
 # Resolve Mercurial config items so other checks have easy access.
 # Do NOT set this in the config because it may contain sensitive data
 # like API keys.
-
-
 @depends_all(check_build_environment, hg, hg_version)
 @imports('os')
 def hg_config(build_env, hg, version):
     env = dict(os.environ)
     env['HGPLAIN'] = '1'
 
     # Warnings may get sent to stderr. But check_cmd_output() ignores
     # stderr if exit code is 0. And the command should always succeed if
@@ -451,35 +425,32 @@ def hg_config(build_env, hg, version):
     config = {}
 
     for line in out.strip().splitlines():
         key, value = [s.strip() for s in line.split('=', 1)]
         config[key] = value
 
     return config
 
-
 @depends_if(git)
 @checking('for Git version')
 @imports('re')
 def git_version(git):
     out = check_cmd_output(git, '--version').rstrip()
 
     match = re.search('git version (.*)$', out)
 
     if not match:
         raise FatalCheckError('unable to determine Git version: %s' % out)
 
     return Version(match.group(1))
 
 # Only set VCS_CHECKOUT_TYPE if we resolved the VCS binary.
 # Require resolved VCS info when running in automation so automation's
 # environment is more well-defined.
-
-
 @depends(vcs_checkout_type, hg_version, git_version, 'MOZ_AUTOMATION')
 def exposed_vcs_checkout_type(vcs_checkout_type, hg, git, automation):
     if vcs_checkout_type == 'hg':
         if hg:
             return 'hg'
 
         if automation:
             raise FatalCheckError('could not resolve Mercurial binary info')
@@ -488,50 +459,44 @@ def exposed_vcs_checkout_type(vcs_checko
         if git:
             return 'git'
 
         if automation:
             raise FatalCheckError('could not resolve Git binary info')
     elif vcs_checkout_type:
         raise FatalCheckError('unhandled VCS type: %s' % vcs_checkout_type)
 
-
 set_config('VCS_CHECKOUT_TYPE', exposed_vcs_checkout_type)
 
 # Obtain a Repository interface for the current VCS repository.
-
-
 @depends(check_build_environment, exposed_vcs_checkout_type, hg, git)
 @imports(_from='mozversioncontrol', _import='get_repository_object')
 def vcs_repository(build_env, vcs_checkout_type, hg, git):
     if vcs_checkout_type == 'hg':
         return get_repository_object(build_env.topsrcdir, hg=hg)
     elif vcs_checkout_type == 'git':
         return get_repository_object(build_env.topsrcdir, git=git)
     elif vcs_checkout_type:
         raise FatalCheckError('unhandled VCS type: %s' % vcs_checkout_type)
 
-
 @depends_if(vcs_repository)
 @checking('for sparse checkout')
 def vcs_sparse_checkout(repo):
     return repo.sparse_checkout_present()
 
-
 set_config('VCS_SPARSE_CHECKOUT', vcs_sparse_checkout)
 
 # Host and target systems
 # ==============================================================
 option('--host', nargs=1, help='Define the system type performing the build')
 
 option('--target', nargs=1,
        help='Define the system type where the resulting executables will be '
             'used')
 
-
 @imports(_from='mozbuild.configure.constants', _import='CPU')
 @imports(_from='mozbuild.configure.constants', _import='CPU_bitness')
 @imports(_from='mozbuild.configure.constants', _import='Endianness')
 @imports(_from='mozbuild.configure.constants', _import='Kernel')
 @imports(_from='mozbuild.configure.constants', _import='OS')
 @imports(_from='__builtin__', _import='KeyError')
 @imports(_from='__builtin__', _import='ValueError')
 def split_triplet(triplet, allow_unknown=False):
@@ -694,83 +659,72 @@ def host(value, shell):
         config_guess = os.path.join(os.path.dirname(__file__), '..',
                                     'autoconf', 'config.guess')
         host = subprocess.check_output([shell, config_guess]).strip()
     else:
         host = value[0]
 
     return split_triplet(config_sub(shell, host))
 
-
 host = help_host_target | host
 
 
 @depends('--target', host, shell)
 @checking('for target system type', lambda t: t.alias)
 def target(value, host, shell):
     if not value:
         return host
     return split_triplet(config_sub(shell, value[0]))
 
-
 target = help_host_target | target
 
 
 @depends(host, target)
 @checking('whether cross compiling')
 def cross_compiling(host, target):
     return host != target
 
-
 set_config('CROSS_COMPILE', cross_compiling)
 set_define('CROSS_COMPILE', cross_compiling)
 add_old_configure_assignment('CROSS_COMPILE', cross_compiling)
 
 
 @depends(target)
 def have_64_bit(target):
     if target.bitness == 64:
         return True
 
-
 set_config('HAVE_64BIT_BUILD', have_64_bit)
 set_define('HAVE_64BIT_BUILD', have_64_bit)
 add_old_configure_assignment('HAVE_64BIT_BUILD', have_64_bit)
 
-
 @depends(host)
 def host_os_kernel_major_version(host):
     versions = host.raw_os.split('.')
     version = ''.join(x for x in versions[0] if x.isdigit())
     return version
 
-
 set_config('HOST_MAJOR_VERSION', host_os_kernel_major_version)
 
 # Autoconf needs these set
-
-
 @depends(host)
 def host_for_old_configure(host):
     return '--host=%s' % host.alias
 
-
 add_old_configure_arg(host_for_old_configure)
 
-
 @depends(target)
 def target_for_old_configure(target):
     target_alias = target.alias
     # old-configure does plenty of tests against $target and $target_os
     # and expects darwin for iOS, so make it happy.
     if target.os == 'iOS':
         target_alias = target_alias.replace('-ios', '-darwin')
     return '--target=%s' % target_alias
 
-
 add_old_configure_arg(target_for_old_configure)
 
 
 # These variables are for compatibility with the current moz.builds and
 # old-configure. Eventually, we'll want to canonicalize better.
 @depends(target)
 def target_variables(target):
     if target.kernel == 'kFreeBSD':
@@ -791,17 +745,16 @@ def target_variables(target):
 
     return namespace(
         OS_TARGET=os_target,
         OS_ARCH=os_arch,
         OS_TEST=os_test,
         INTEL_ARCHITECTURE=target.cpu in ('x86', 'x86_64') or None,
     )
 
-
 set_config('OS_TARGET', target_variables.OS_TARGET)
 add_old_configure_assignment('OS_TARGET',
                              target_variables.OS_TARGET)
 set_config('OS_ARCH', target_variables.OS_ARCH)
 add_old_configure_assignment('OS_ARCH',
                              target_variables.OS_ARCH)
 set_config('OS_TEST', target_variables.OS_TEST)
 add_old_configure_assignment('OS_TEST',
@@ -818,114 +771,95 @@ def host_variables(host):
     if host.kernel == 'kFreeBSD':
         os_arch = 'GNU_kFreeBSD'
     else:
         os_arch = host.kernel
     return namespace(
         HOST_OS_ARCH=os_arch,
     )
 
-
 set_config('HOST_CPU_ARCH', host.cpu)
 set_config('HOST_OS_ARCH', host_variables.HOST_OS_ARCH)
 add_old_configure_assignment('HOST_OS_ARCH',
                              host_variables.HOST_OS_ARCH)
 
-
 @depends(target)
 def target_is_windows(target):
     if target.kernel == 'WINNT':
         return True
 
-
 set_define('_WINDOWS', target_is_windows)
 set_define('WIN32', target_is_windows)
 set_define('XP_WIN', target_is_windows)
 set_define('XP_WIN32', target_is_windows)
 
-
 @depends(target)
 def target_is_unix(target):
     if target.kernel != 'WINNT':
         return True
 
-
 set_define('XP_UNIX', target_is_unix)
 
-
 @depends(target)
 def target_is_darwin(target):
     if target.kernel == 'Darwin':
         return True
 
-
 set_define('XP_DARWIN', target_is_darwin)
 
-
 @depends(target)
 def target_is_ios(target):
     if target.kernel == 'Darwin' and target.os == 'iOS':
         return True
 
-
 set_define('XP_IOS', target_is_ios)
 
-
 @depends(target)
 def target_is_osx(target):
     if target.kernel == 'Darwin' and target.os == 'OSX':
         return True
 
-
 set_define('XP_MACOSX', target_is_osx)
 
-
 @depends(target)
 def target_is_linux(target):
     if target.kernel == 'Linux':
         return True
 
-
 set_define('XP_LINUX', target_is_linux)
 
-
 @depends(target)
 def target_is_solaris(target):
     if target.kernel == 'SunOS':
         return True
 
-
 set_define('XP_SOLARIS', target_is_solaris)
 
 # The application/project to build
 # ==============================================================
 option('--enable-application', nargs=1, env='MOZ_BUILD_APP',
        help='Application to build. Same as --enable-project.')
 
-
 @depends('--enable-application', '--help')
 def application(app, help):
     if app:
         return app
 
-
 imply_option('--enable-project', application)
 
 
 @depends(check_build_environment, '--help')
 def default_project(build_env, help):
     if build_env.topobjdir.endswith('/js/src'):
         return 'js'
     return 'browser'
 
-
 option('--enable-project', nargs=1, default=default_project,
        help='Project to build')
 
-
 @depends('--enable-project', '--with-external-source-dir',
          check_build_environment, '--help')
 @imports(_from='os.path', _import='exists')
 def include_project_configure(project, external_source_dir, build_env, help):
     if not project:
         die('--enable-project is required.')
 
     base_dir = build_env.topsrcdir
@@ -939,17 +873,16 @@ def include_project_configure(project, e
 
 
 @depends(include_project_configure, check_build_environment, '--help')
 def build_project(include_project_configure, build_env, help):
     ret = os.path.dirname(os.path.relpath(include_project_configure,
                                           build_env.topsrcdir))
     return ret
 
-
 set_config('MOZ_BUILD_APP', build_project)
 set_define('MOZ_BUILD_APP', build_project)
 add_old_configure_assignment('MOZ_BUILD_APP', build_project)
 
 
 # set RELEASE_OR_BETA and NIGHTLY_BUILD variables depending on the cycle we're in
 # The logic works like this:
 # - if we have "a1" in GRE_MILESTONE, we're building Nightly (define NIGHTLY_BUILD)
@@ -970,17 +903,16 @@ def milestone(build_env, _):
         is_nightly = True
     elif 'a' not in milestone:
         is_release_or_beta = True
 
     return namespace(version=milestone,
                      is_nightly=is_nightly,
                      is_release_or_beta=is_release_or_beta)
 
-
 set_config('GRE_MILESTONE', milestone.version)
 set_config('NIGHTLY_BUILD', milestone.is_nightly)
 set_define('NIGHTLY_BUILD', milestone.is_nightly)
 add_old_configure_assignment('NIGHTLY_BUILD', milestone.is_nightly)
 set_config('RELEASE_OR_BETA', milestone.is_release_or_beta)
 set_define('RELEASE_OR_BETA', milestone.is_release_or_beta)
 add_old_configure_assignment('RELEASE_OR_BETA',
                              milestone.is_release_or_beta)
@@ -988,24 +920,22 @@ add_old_configure_assignment('RELEASE_OR
 # The app update channel is 'default' when not supplied. The value is used in
 # the application's confvars.sh (and is made available to a project specific
 # moz.configure).
 option('--enable-update-channel',
        nargs=1,
        help='Select application update channel',
        default='default')
 
-
 @depends('--enable-update-channel')
 def update_channel(channel):
     if channel[0] == '':
         return 'default'
     return channel[0].lower()
 
-
 set_config('MOZ_UPDATE_CHANNEL', update_channel)
 set_define('MOZ_UPDATE_CHANNEL', update_channel)
 add_old_configure_assignment('MOZ_UPDATE_CHANNEL', update_channel)
 
 
 # A template providing a shorthand for setting a variable. The created
 # option will only be settable with imply_option.
 # It is expected that a project-specific moz.configure will call imply_option
@@ -1014,18 +944,17 @@ add_old_configure_assignment('MOZ_UPDATE
 # will additionally cause the variable to be set using set_define and
 # add_old_configure_assignment. util.configure would be an appropriate place for
 # this, but it uses add_old_configure_assignment, which is defined in this file.
 @template
 def project_flag(env=None, set_for_old_configure=False,
                  set_as_define=False, **kwargs):
 
     if not env:
-        configure_error(
-            "A project_flag must be passed a variable name to set.")
+        configure_error("A project_flag must be passed a variable name to set.")
 
     opt = option(env=env, possible_origins=('implied',), **kwargs)
 
     @depends(opt.option)
     def option_implementation(value):
         if value:
             if len(value):
                 return value
@@ -1033,26 +962,22 @@ def project_flag(env=None, set_for_old_c
 
     set_config(env, option_implementation)
     if set_as_define:
         set_define(env, option_implementation)
     if set_for_old_configure:
         add_old_configure_assignment(env, option_implementation)
 
 # milestone.is_nightly corresponds to cases NIGHTLY_BUILD is set.
-
-
 @depends(milestone, '--help')
 def enabled_in_nightly(milestone, _):
     return milestone.is_nightly
 
 # Set the MOZ_CONFIGURE_OPTIONS variable with all the options that
 # were passed somehow (environment, command line, mozconfig)
-
-
 @dependable
 @imports(_from='mozbuild.shellutil', _import='quote')
 @imports('__sandbox__')
 def all_configure_options():
     result = []
     previous = None
     for option in __sandbox__._options.itervalues():
         # __sandbox__._options contains items for both option.name and
@@ -1074,17 +999,16 @@ def all_configure_options():
         # because we don't know their actual defaults. (Keep the conditions
         # separate for ease of understanding and ease of removal)
         elif (option.help == 'Help missing for old configure options' and
                 option in __sandbox__._raw_options):
             result.append(__sandbox__._raw_options[option])
 
     return quote(*result)
 
-
 set_config('MOZ_CONFIGURE_OPTIONS', all_configure_options)
 
 
 # This is temporary until js/src/configure and configure are merged.
 # Use instead of option() in js/moz.configure and more generally, for
 # options that are shared between configure and js/src/configure.
 @template
 def js_option(*args, **kwargs):
--- a/build/moz.configure/java.configure
+++ b/build/moz.configure/java.configure
@@ -5,58 +5,53 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
 # Java detection
 # ========================================================
 option('--with-java-bin-path', nargs=1,
        help='Location of Java binaries (java, javac, jar)')
 
-
 @depends('--with-java-bin-path')
 @imports(_from='os', _import='environ')
 def java_search_paths(path):
     if path:
         # Look for javac and jar in the specified path.
         return path
     # With no path specified, look for javac and jar in $JAVA_HOME (if set)
     # and $PATH.
     if 'JAVA_HOME' in environ:
         return [os.path.join(environ['JAVA_HOME'], 'bin'),
                 environ.get('PATH', '')]
     return [environ.get('PATH')]
 
 # Finds the given java tool, failing with a custom error message if we can't
 # find it.
-
-
 @template
 def check_java_tool(tool):
     check = check_prog(tool.upper(), (tool,), paths=java_search_paths,
                        allow_missing=True)
 
     @depends(check)
     def require_tool(result):
         if result is None:
             die("The program %s was not found.  Set $JAVA_HOME to your Java "
                 "SDK directory or use '--with-java-bin-path={java-bin-dir}'"
                 % tool)
         return result
 
     return require_tool
 
-
 check_java_tool('java')
 check_java_tool('javah')
 check_java_tool('jar')
 check_java_tool('jarsigner')
 check_java_tool('keytool')
 javac = check_java_tool('javac')
 
-
 @depends(javac)
 @checking('for javac version')
 @imports('subprocess')
 def javac_version(javac):
     try:
         output = subprocess.check_output([javac, '-version'],
                                          stderr=subprocess.STDOUT).rstrip()
         version = Version(output.split(' ')[-1])
--- a/build/moz.configure/keyfiles.configure
+++ b/build/moz.configure/keyfiles.configure
@@ -54,11 +54,12 @@ def id_and_secret_keyfile(desc, default=
             secret=secret,
         )
 
     content = keyfile(desc, help='Use the client id and secret key contained '
                                  'in the given keyfile for %s requests' % desc,
                       default=default,
                       callback=id_and_secret)
 
+
     name = desc.upper().replace(' ', '_')
     set_config('MOZ_%s_CLIENTID' % name, content.id)
     set_config('MOZ_%s_KEY' % name, content.secret)
--- a/build/moz.configure/memory.configure
+++ b/build/moz.configure/memory.configure
@@ -8,17 +8,16 @@
 @deprecated_option(env='MOZ_JEMALLOC4')
 def moz_jemalloc4(value):
     die('MOZ_JEMALLOC4 is deprecated')
 
 
 option('--enable-jemalloc', env='MOZ_MEMORY',
        help='Replace memory allocator with jemalloc')
 
-
 @depends('--enable-jemalloc', target, build_project, c_compiler)
 def jemalloc(value, target, build_project, c_compiler):
     if value.origin != 'default':
         return bool(value) or None
 
     if build_project == 'js':
         return True
 
@@ -44,30 +43,27 @@ add_old_configure_assignment('MOZ_MEMORY
 
 # Because --enable-jemalloc doesn't use a default because of the dependency
 # on the target, we can't use a js_option for it to propagate to js/src
 # through the old-configure.
 @depends(jemalloc)
 def jemalloc_for_old_configure(jemalloc):
     return '--%s-jemalloc' % ('enable' if jemalloc else 'disable')
 
-
 add_old_configure_arg(jemalloc_for_old_configure)
 
 
 option('--enable-replace-malloc',
        help='Enable ability to dynamically replace the malloc implementation')
 
-
 @depends('--enable-replace-malloc', jemalloc, milestone, build_project)
 def replace_malloc(value, jemalloc, milestone, build_project):
     # Enable on central for the debugging opportunities it adds.
     if value and not jemalloc:
         die('--enable-replace-malloc requires --enable-jemalloc')
     if value.origin != 'default':
         return bool(value) or None
     if milestone.is_nightly and jemalloc and build_project != 'js':
         return True
 
-
 set_config('MOZ_REPLACE_MALLOC', replace_malloc)
 set_define('MOZ_REPLACE_MALLOC', replace_malloc)
 add_old_configure_assignment('MOZ_REPLACE_MALLOC', replace_malloc)
--- a/build/moz.configure/old.configure
+++ b/build/moz.configure/old.configure
@@ -1,25 +1,23 @@
 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-
 @imports('codecs')
 @imports('sys')
 def encoded_open(path, mode):
     encoding = 'mbcs' if sys.platform == 'win32' else 'utf-8'
     return codecs.open(path, mode, encoding)
 
 
 option(env='AUTOCONF', nargs=1, help='Path to autoconf 2.13')
 
-
 @depends(mozconfig, 'AUTOCONF')
 @checking('for autoconf')
 @imports(_from='os.path', _import='exists')
 @imports('re')
 def autoconf(mozconfig, autoconf):
     mozconfig_autoconf = None
     if mozconfig['path']:
         make_extra = mozconfig['make_extra']
@@ -53,17 +51,16 @@ def autoconf(mozconfig, autoconf):
     if not autoconf:
         die('Could not find autoconf 2.13')
 
     if not exists(autoconf):
         die('Could not find autoconf 2.13 at %s', autoconf)
 
     return autoconf
 
-
 set_config('AUTOCONF', autoconf)
 
 
 @depends('OLD_CONFIGURE', mozconfig, autoconf, check_build_environment, shell,
          old_configure_assignments, build_project)
 @imports(_from='__builtin__', _import='open')
 @imports(_from='__builtin__', _import='print')
 @imports('glob')
@@ -115,17 +112,16 @@ def prepare_configure(old_configure, moz
         script = script.replace('>./config.log', '>>./config.log')
 
         with open(old_configure, 'wb') as fh:
             fh.write(script)
 
     cmd = [shell, old_configure]
     with encoded_open('old-configure.vars', 'w') as out:
         log.debug('Injecting the following to old-configure:')
-
         def inject(command):
             print(command, file=out)
             log.debug('| %s', command)
 
         if mozconfig['path']:
             for key, value in mozconfig['vars']['added'].items():
                 inject("%s=%s" % (key, quote(value)))
             for key, (old, value) in mozconfig['vars']['modified'].items():
@@ -359,17 +355,17 @@ def old_configure(prepare_configure, ext
         sys.exit(ret)
 
     raw_config = {}
     with encoded_open('config.data', 'r') as fh:
         code = compile(fh.read(), 'config.data', 'exec')
         # Every variation of the exec() function I tried led to:
         # SyntaxError: unqualified exec is not allowed in function 'main' it
         # contains a nested function with free variables
-        exec code in raw_config # noqa
+        exec code in raw_config
 
     # Ensure all the flags known to old-configure appear in the
     # @old_configure_options above.
     all_options = set(all_options)
     for flag in raw_config['flags']:
         if flag not in all_options:
             die('Missing option in `@old_configure_options` in %s: %s',
                 __file__, flag)
@@ -383,18 +379,16 @@ def old_configure(prepare_configure, ext
 # set_config is only available in the global namespace, not directly in
 # @depends functions, but we do need to enumerate the result of
 # old_configure, so we cheat.
 @imports('__sandbox__')
 def set_old_configure_config(name, value):
     __sandbox__.set_config_impl(name, value)
 
 # Same as set_old_configure_config, but for set_define.
-
-
 @imports('__sandbox__')
 def set_old_configure_define(name, value):
     __sandbox__.set_define_impl(name, value)
 
 
 @depends(old_configure)
 @imports('types')
 def post_old_configure(raw_config):
--- a/build/moz.configure/pkg.configure
+++ b/build/moz.configure/pkg.configure
@@ -1,24 +1,21 @@
 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-
 @depends('--enable-compile-environment')
 def pkg_config(compile_env):
     if compile_env:
         return ('pkg-config',)
 
-
 pkg_config = check_prog('PKG_CONFIG', pkg_config, allow_missing=True)
 
-
 @depends_if(pkg_config)
 @checking('for pkg-config version')
 @imports('subprocess')
 def pkg_config_version(pkg_config):
     return Version(check_cmd_output(pkg_config, '--version').rstrip())
 
 # Locates the given module using pkg-config.
 # - `var` determines the name of variables to set when the package is found.
@@ -27,18 +24,16 @@ def pkg_config_version(pkg_config):
 #   strings describing packages to locate, or depends function that will
 #   resolve to such a string or list of strings.
 # - `when` a depends function that will determine whether to perform
 #   any checks (default is to always perform checks).
 # - `allow_missing` If set, failure to fulfill the package description
 #   will not result in an error or logged message, and any error message
 #   will be returned to the caller.
 #   Returns `True` when the package description is fulfilled.
-
-
 @template
 def pkg_check_modules(var, package_desc, when=always,
                       allow_missing=False):
     if isinstance(package_desc, (tuple, list)):
         package_desc = ' '.join(package_desc)
     package_desc = dependable(package_desc)
 
     @depends(when, '--enable-compile-environment')
--- a/build/moz.configure/rust.configure
+++ b/build/moz.configure/rust.configure
@@ -4,28 +4,26 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 # Rust is required by `rust_compiler` below. We allow_missing here
 # to propagate failures to the better error message there.
 rustc = check_prog('RUSTC', ['rustc'], allow_missing=True)
 cargo = check_prog('CARGO', ['cargo'], allow_missing=True)
 
-
 @depends_if(rustc)
 @checking('rustc version', lambda info: info.version)
 def rustc_info(rustc):
     out = check_cmd_output(rustc, '--version', '--verbose').splitlines()
     info = dict((s.strip() for s in line.split(':', 1)) for line in out[1:])
     return namespace(
         version=Version(info.get('release', '0')),
         commit=info.get('commit-hash', 'unknown'),
     )
 
-
 @depends_if(cargo)
 @checking('cargo version', lambda info: info.version)
 @imports('re')
 def cargo_info(cargo):
     out = check_cmd_output(cargo, '--version', '--verbose').splitlines()
     info = dict((s.strip() for s in line.split(':', 1)) for line in out[1:])
     version = info.get('release')
     # Older versions of cargo didn't support --verbose, in which case, they
@@ -40,17 +38,16 @@ def cargo_info(cargo):
         if not m:
             die('Could not determine cargo version from output: %s', out)
         version = m.group(1)
 
     return namespace(
         version=Version(version),
     )
 
-
 @depends(rustc_info, cargo_info)
 @imports(_from='textwrap', _import='dedent')
 def rust_compiler(rustc_info, cargo_info):
     if not rustc_info:
         die(dedent('''\
         Rust compiler not found.
         To compile rust language sources, you must have 'rustc' in your path.
         See https://www.rust-lang.org/ for more information.
@@ -171,18 +168,17 @@ def rust_triple_alias(host_or_target):
         rustc_target = rust_supported_targets.per_os.get(
             (host_or_target.cpu, host_or_target_os))
 
         if rustc_target is None:
             rustc_target = rust_supported_targets.per_raw_os.get(
                 (host_or_target.cpu, host_or_target_raw_os))
 
         if rustc_target is None:
-            die("Don't know how to translate {} for rustc".format(
-                host_or_target.alias))
+            die("Don't know how to translate {} for rustc".format(host_or_target.alias))
 
         # Check to see whether our rustc has a reasonably functional stdlib
         # for our chosen target.
         target_arg = '--target=' + rustc_target.alias
         in_fd, in_path = mkstemp(prefix='conftest', suffix='.rs')
         out_fd, out_path = mkstemp(prefix='conftest', suffix='.rlib')
         os.close(out_fd)
         try:
@@ -196,17 +192,16 @@ def rust_triple_alias(host_or_target):
 
             cmd = [
                 rustc,
                 '--crate-type', 'staticlib',
                 target_arg,
                 '-o', out_path,
                 in_path,
             ]
-
             def failed():
                 die(dedent('''\
                 Cannot compile for {} with {}
                 The target may be unsupported, or you may not have
                 a rust std library for that target installed. Try:
 
                   rustup target add {}
                 '''.format(host_or_target.alias, rustc, rustc_target.alias)))
@@ -217,28 +212,25 @@ def rust_triple_alias(host_or_target):
             os.remove(in_path)
             os.remove(out_path)
 
         # This target is usable.
         return rustc_target.alias
 
     return rust_target
 
-
 rust_target_triple = rust_triple_alias(target)
 rust_host_triple = rust_triple_alias(host)
 
 set_config('RUST_TARGET', rust_target_triple)
 set_config('RUST_HOST_TARGET', rust_host_triple)
 
-
 @depends(rust_target_triple)
 def rust_target_env_name(triple):
-    return triple.upper().replace('-', '_')
-
+    return triple.upper().replace('-','_')
 
 # We need this to form various Cargo environment variables, as there is no
 # uppercase function in make, and we don't want to shell out just for
 # converting a string to uppercase.
 set_config('RUST_TARGET_ENV_NAME', rust_target_env_name)
 
 # This is used for putting source info into symbol files.
 set_config('RUSTC_COMMIT', depends(rustc_info)(lambda i: i.commit))
--- a/build/moz.configure/toolchain.configure
+++ b/build/moz.configure/toolchain.configure
@@ -10,35 +10,32 @@ option(env='MOZ_PGO', help='Build with p
 
 set_config('MOZ_PGO', depends('MOZ_PGO')(lambda x: bool(x)))
 add_old_configure_assignment('MOZ_PGO', depends('MOZ_PGO')(lambda x: bool(x)))
 
 # yasm detection
 # ==============================================================
 yasm = check_prog('YASM', ['yasm'], allow_missing=True)
 
-
 @depends_if(yasm)
 @checking('yasm version')
 def yasm_version(yasm):
     version = check_cmd_output(
         yasm, '--version',
         onerror=lambda: die('Failed to get yasm version.')
     ).splitlines()[0].split()[1]
     return Version(version)
 
-
 # Until we move all the yasm consumers out of old-configure.
 # bug 1257904
 add_old_configure_assignment('_YASM_MAJOR_VERSION',
                              yasm_version.major)
 add_old_configure_assignment('_YASM_MINOR_VERSION',
                              yasm_version.minor)
 
-
 @depends(yasm, target)
 def yasm_asflags(yasm, target):
     if yasm:
         asflags = {
             ('OSX', 'x86'): '-f macho32',
             ('OSX', 'x86_64'): '-f macho64',
             ('WINNT', 'x86'): '-f win32',
             ('WINNT', 'x86_64'): '-f x64',
@@ -49,49 +46,43 @@ def yasm_asflags(yasm, target):
             if target.cpu == 'x86':
                 asflags = '-f elf32'
             elif target.cpu == 'x86_64':
                 asflags = '-f elf64'
         if asflags:
             asflags += ' -rnasm -pnasm'
         return asflags
 
-
 set_config('YASM_ASFLAGS', yasm_asflags)
 
-
 @depends(yasm_asflags)
 def have_yasm(value):
     if value:
         return True
 
-
 set_config('HAVE_YASM', have_yasm)
 # Until the YASM variable is not necessary in old-configure.
 add_old_configure_assignment('YASM', have_yasm)
 
 # Android NDK
 # ==============================================================
 
-
 @depends('--disable-compile-environment', build_project, '--help')
 def compiling_android(compile_env, build_project, _):
     return compile_env and build_project in ('mobile/android', 'js')
 
-
 include('android-ndk.configure', when=compiling_android)
 
 # MacOS deployment target version
 # ==============================================================
 # This needs to happen before any compilation test is done.
 
 option('--enable-macos-target', env='MACOSX_DEPLOYMENT_TARGET', nargs=1,
        default='10.7', help='Set the minimum MacOS version needed at runtime')
 
-
 @depends('--enable-macos-target', target)
 @imports(_from='os', _import='environ')
 def macos_target(value, target):
     if value and target.os == 'OSX':
         # Ensure every compiler process we spawn uses this value.
         environ['MACOSX_DEPLOYMENT_TARGET'] = value[0]
         return value[0]
     if value and value.origin != 'default':
@@ -101,18 +92,17 @@ def macos_target(value, target):
 
 set_config('MACOSX_DEPLOYMENT_TARGET', macos_target)
 add_old_configure_assignment('MACOSX_DEPLOYMENT_TARGET', macos_target)
 
 # Xcode state
 # ===========
 
 js_option('--disable-xcode-checks',
-          help='Do not check that Xcode is installed and properly configured')
-
+       help='Do not check that Xcode is installed and properly configured')
 
 @depends(host, '--disable-xcode-checks')
 def xcode_path(host, xcode_checks):
     if host.kernel != 'Darwin' or not xcode_checks:
         return
 
     # xcode-select -p prints the path to the installed Xcode. It
     # should exit 0 and return non-empty result if Xcode is installed.
@@ -132,83 +122,71 @@ def xcode_path(host, xcode_checks):
     # Now look for the Command Line Tools.
     def no_cltools():
         die('Could not find installed Xcode Command Line Tools; '
             'run `xcode-select --install` and follow the instructions '
             'to install them then try again; if you wish to build without '
             'Xcode Command Line Tools installed, '
             'add the --disable-xcode-checks configure flag')
 
-    check_cmd_output('pkgutil', '--pkg-info',
-                     'com.apple.pkg.CLTools_Executables',
-                     onerror=no_cltools)
+    res = check_cmd_output('pkgutil', '--pkg-info',
+                           'com.apple.pkg.CLTools_Executables',
+                            onerror=no_cltools)
 
     return xcode_path
 
-
 set_config('XCODE_PATH', xcode_path)
 
 
 # Compiler wrappers
 # ==============================================================
 # Normally, we'd use js_option and automatically have those variables
 # propagated to js/src, but things are complicated by possible additional
 # wrappers in CC/CXX, and by other subconfigures that do not handle those
 # options and do need CC/CXX altered.
 option('--with-compiler-wrapper', env='COMPILER_WRAPPER', nargs=1,
        help='Enable compiling with wrappers such as distcc and ccache')
 
 option('--with-ccache', env='CCACHE', nargs='?',
        help='Enable compiling with ccache')
 
-
 @depends_if('--with-ccache')
 def ccache(value):
     if len(value):
         return value
     # If --with-ccache was given without an explicit value, we default to
     # 'ccache'.
     return 'ccache'
 
-
 ccache = check_prog('CCACHE', progs=(), input=ccache)
 
 # Distinguish ccache from sccache.
-
-
 @depends_if(ccache)
 def ccache_is_sccache(ccache):
     return check_cmd_output(ccache, '--version').startswith('sccache')
 
-
 @depends(ccache, ccache_is_sccache)
 def using_ccache(ccache, ccache_is_sccache):
     return ccache and not ccache_is_sccache
 
-
 @depends_if(ccache, ccache_is_sccache)
 def using_sccache(ccache, ccache_is_sccache):
     return ccache and ccache_is_sccache
 
-
 set_config('MOZ_USING_CCACHE', using_ccache)
 set_config('MOZ_USING_SCCACHE', using_sccache)
 
-option(env='SCCACHE_VERBOSE_STATS',
-       help='Print verbose sccache stats after build')
-
+option(env='SCCACHE_VERBOSE_STATS', help='Print verbose sccache stats after build')
 
 @depends(using_sccache, 'SCCACHE_VERBOSE_STATS')
 def sccache_verbose_stats(using_sccache, verbose_stats):
     return using_sccache and bool(verbose_stats)
 
-
 set_config('SCCACHE_VERBOSE_STATS', sccache_verbose_stats)
 
-
 @depends('--with-compiler-wrapper', ccache)
 @imports(_from='mozbuild.shellutil', _import='split', _as='shell_split')
 def compiler_wrapper(wrapper, ccache):
     if wrapper:
         raw_wrapper = wrapper[0]
         wrapper = shell_split(raw_wrapper)
         wrapper_program = find_program(wrapper[0])
         if not wrapper_program:
@@ -219,78 +197,68 @@ def compiler_wrapper(wrapper, ccache):
     if ccache:
         if wrapper:
             return tuple([ccache] + wrapper)
         else:
             return (ccache,)
     elif wrapper:
         return tuple(wrapper)
 
-
 add_old_configure_assignment('COMPILER_WRAPPER', compiler_wrapper)
 
-
 @depends_if(compiler_wrapper)
 def using_compiler_wrapper(compiler_wrapper):
     return True
 
-
 set_config('MOZ_USING_COMPILER_WRAPPER', using_compiler_wrapper)
 
 
 # GC rooting and hazard analysis.
 # ==============================================================
 option(env='MOZ_HAZARD', help='Build for the GC rooting hazard analysis')
 
-
 @depends('MOZ_HAZARD')
 def hazard_analysis(value):
     if value:
         return True
 
-
 set_config('MOZ_HAZARD', hazard_analysis)
 
 
 # Cross-compilation related things.
 # ==============================================================
 js_option('--with-toolchain-prefix', env='TOOLCHAIN_PREFIX', nargs=1,
           help='Prefix for the target toolchain')
 
-
 @depends('--with-toolchain-prefix', target, cross_compiling)
 def toolchain_prefix(value, target, cross_compiling):
     if value:
         return tuple(value)
     if cross_compiling:
         return ('%s-' % target.toolchain, '%s-' % target.alias)
 
-
 @depends(toolchain_prefix, target)
 def first_toolchain_prefix(toolchain_prefix, target):
     # Pass TOOLCHAIN_PREFIX down to the build system if it was given from the
     # command line/environment (in which case there's only one value in the tuple),
     # or when cross-compiling for Android.
     if toolchain_prefix and (target.os == 'Android' or len(toolchain_prefix) == 1):
         return toolchain_prefix[0]
 
-
 set_config('TOOLCHAIN_PREFIX', first_toolchain_prefix)
 add_old_configure_assignment('TOOLCHAIN_PREFIX', first_toolchain_prefix)
 
 
 # Compilers
 # ==============================================================
 include('compilers-util.configure')
 
-
 def try_preprocess(compiler, language, source):
     return try_invoke_compiler(compiler, language, source, ['-E'])
 
-
 @imports(_from='mozbuild.configure.constants', _import='CompilerType')
 @imports(_from='mozbuild.configure.constants',
          _import='CPU_preprocessor_checks')
 @imports(_from='mozbuild.configure.constants',
          _import='kernel_preprocessor_checks')
 @imports(_from='textwrap', _import='dedent')
 def get_compiler_info(compiler, language):
     '''Returns information about the given `compiler` (command line in the
@@ -459,17 +427,17 @@ def check_compiler(compiler, language, t
                 append_flag('-std=gnu++11')
             # MSVC 2015 headers include C++14 features, but don't guard them
             # with appropriate checks.
             if info.type == 'clang-cl' and info.language_version != cxx14_version:
                 append_flag('-std=c++14')
             # GCC 4.9 indicates that it implements draft C++14 features
             # instead of the full language.
             elif info.type == 'gcc' and not \
-                    (info.language_version == draft_cxx14_version or info.language_version == cxx14_version):
+                (info.language_version == draft_cxx14_version or info.language_version == cxx14_version):
                 append_flag('-std=gnu++14')
 
     # We force clang-cl to emulate Visual C++ 2015 Update 3.
     if info.type == 'clang-cl' and info.version != '19.00.24213':
         # This flag is a direct clang-cl flag that doesn't need -Xclang,
         # add it directly.
         flags.append('-fms-compatibility-version=19.00.24213')
 
@@ -528,39 +496,34 @@ def get_vc_paths(topsrcdir):
         yield (Version(install['installationVersion']), {
             'x64': [os.path.join(path, r'VC\bin\amd64')],
             # The x64->x86 cross toolchain requires DLLs from the native x64 toolchain.
             'x86': [os.path.join(path, r'VC\bin\amd64_x86'), os.path.join(path, r'VC\bin\amd64')],
         })
     # Then VS2017 and newer.
     for install in vswhere(['-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64']):
         path = install['installationPath']
-        tools_version = open(os.path.join(
-            path, r'VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt'), 'rb').read().strip()
-        tools_path = os.path.join(
-            path, r'VC\Tools\MSVC', tools_version, r'bin\HostX64')
+        tools_version = open(os.path.join(path, r'VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt'), 'rb').read().strip()
+        tools_path = os.path.join(path, r'VC\Tools\MSVC', tools_version, r'bin\HostX64')
         yield (Version(install['installationVersion']), {
             'x64': [os.path.join(tools_path, 'x64')],
             # The x64->x86 cross toolchain requires DLLs from the native x64 toolchain.
             'x86': [os.path.join(tools_path, 'x86'), os.path.join(tools_path, 'x64')],
         })
 
-
 js_option('--with-visual-studio-version', nargs=1,
           choices=('2015', '2017'),
           help='Select a specific Visual Studio version to use')
 
-
 @depends('--with-visual-studio-version')
 def vs_major_version(value):
     if value:
         return {'2015': 14,
                 '2017': 15}[value[0]]
 
-
 @depends(host, target, vs_major_version, check_build_environment, '--with-visual-studio-version')
 @imports(_from='__builtin__', _import='sorted')
 @imports(_from='operator', _import='itemgetter')
 @imports('platform')
 def vc_compiler_path(host, target, vs_major_version, env, vs_release_name):
     if host.kernel != 'WINNT':
         return
     vc_target = {
@@ -570,18 +533,17 @@ def vc_compiler_path(host, target, vs_ma
     }.get(target.cpu)
     if vc_target is None:
         return
 
     all_versions = sorted(get_vc_paths(env.topsrcdir), key=itemgetter(0))
     if not all_versions:
         return
     if vs_major_version:
-        versions = [d for (v, d) in all_versions if v.major ==
-                    vs_major_version]
+        versions = [d for (v, d) in all_versions if v.major == vs_major_version]
         if not versions:
             die('Visual Studio %s could not be found!' % vs_release_name)
         data = versions[0]
     else:
         # Choose the newest version.
         data = all_versions[-1][1]
     paths = data.get(vc_target)
     if not paths:
@@ -687,17 +649,17 @@ def compiler(language, host_or_target, c
         ('C++', host): 'HOST_CXX',
     }[language, host_or_target]
 
     default_compilers = {
         'C': lambda: default_c_compilers(host_or_target),
         'C++': lambda: default_cxx_compilers(c_compiler),
     }[language]()
 
-    what = 'the %s %s compiler' % (host_or_target_str, language)
+    what='the %s %s compiler' % (host_or_target_str, language)
 
     option(env=var, nargs=1, help='Path to %s' % what)
 
     # Handle the compiler given by the user through one of the CC/CXX/HOST_CC/
     # HOST_CXX variables.
     @depends_if(var)
     @imports(_from='itertools', _import='takewhile')
     @imports(_from='mozbuild.shellutil', _import='split', _as='shell_split')
@@ -920,28 +882,29 @@ def compiler(language, host_or_target, c
 
     def compiler_error():
         raise FatalCheckError('Failed compiling a simple %s source with %s'
                               % (language, what))
 
     valid_compiler.try_compile(check_msg='%s works' % what,
                                onerror=compiler_error)
 
+
     # Set CPP/CXXCPP for both the build system and old-configure. We don't
     # need to check this works for preprocessing, because we already relied
     # on $CC -E/$CXX -E doing preprocessing work to validate the compiler
     # in the first place.
     if host_or_target == target:
         pp_var = {
             'C': 'CPP',
             'C++': 'CXXCPP',
         }[language]
 
         preprocessor = depends_if(valid_compiler)(
-            lambda x: list(x.wrapper) + [x.compiler, '-E'] + list(x.flags))
+                lambda x: list(x.wrapper) + [x.compiler, '-E'] + list(x.flags))
 
         set_config(pp_var, preprocessor)
         add_old_configure_assignment(pp_var, preprocessor)
 
     if language == 'C':
         linker_var = {
             target: 'LD',
             host: 'HOST_LD',
@@ -974,103 +937,92 @@ host_c_compiler = compiler('C', host, ot
 host_cxx_compiler = compiler('C++', host, c_compiler=host_c_compiler,
                              other_compiler=cxx_compiler,
                              other_c_compiler=c_compiler)
 
 # Generic compiler-based conditions.
 non_msvc_compiler = depends(c_compiler)(lambda info: info.type != 'msvc')
 building_with_gcc = depends(c_compiler)(lambda info: info.type == 'gcc')
 
-
 @depends(c_compiler)
 def msvs_version(info):
     # clang-cl emulates the same version scheme as cl. And MSVS_VERSION needs to
     # be set for GYP on Windows.
     if info.type in ('clang-cl', 'msvc'):
         if info.version >= '19.10':
             return '2017'
         elif info.version >= '19.00':
             return '2015'
 
     return ''
 
-
 set_config('MSVS_VERSION', msvs_version)
 
 include('compile-checks.configure')
 
-
 @depends(have_64_bit,
          try_compile(body='static_assert(sizeof(void *) == 8, "")',
                      check_msg='for 64-bit OS'))
 def check_have_64_bit(have_64_bit, compiler_have_64_bit):
     if have_64_bit != compiler_have_64_bit:
         configure_error('The target compiler does not agree with configure '
                         'about the target bitness.')
 
-
 option(env='BINDGEN_CFLAGS',
        nargs=1,
        default=bindgen_cflags_defaults,
        help='Options bindgen should pass to the C/C++ parser')
 
-
 @depends('BINDGEN_CFLAGS')
 @checking('bindgen cflags', lambda s: s if s and s.strip() else 'no')
 def bindgen_cflags(value):
     if value and len(value):
         # Reformat the env value for substitution into a toml list.
         flags = value[0].split()
         return ', '.join('"' + flag + '"' for flag in flags)
     return ''
 
-
 set_config('BINDGEN_CFLAGS', bindgen_cflags)
 
-
 @depends(c_compiler)
 def default_debug_flags(compiler_info):
     # Debug info is ON by default.
     if compiler_info.type in ('msvc', 'clang-cl'):
         return '-Zi'
     return '-g'
 
-
 option(env='MOZ_DEBUG_FLAGS',
        nargs=1,
        help='Debug compiler flags')
 
 imply_option('--enable-debug-symbols',
              depends_if('--enable-debug')(lambda v: v))
 
 js_option('--enable-debug-symbols',
           nargs='?',
           default=True,
           help='Enable debug symbols using the given compiler flags')
 
 set_config('MOZ_DEBUG_SYMBOLS',
            depends_if('--enable-debug-symbols')(lambda _: True))
 
-
 @depends('MOZ_DEBUG_FLAGS', '--enable-debug-symbols', default_debug_flags)
 def debug_flags(env_debug_flags, enable_debug_flags, default_debug_flags):
     # If MOZ_DEBUG_FLAGS is set, and --enable-debug-symbols is set to a value,
     # --enable-debug-symbols takes precedence. Note, the value of
     # --enable-debug-symbols may be implied by --enable-debug.
     if len(enable_debug_flags):
         return enable_debug_flags[0]
     if env_debug_flags:
         return env_debug_flags[0]
     return default_debug_flags
 
-
 set_config('MOZ_DEBUG_FLAGS', debug_flags)
 add_old_configure_assignment('MOZ_DEBUG_FLAGS', debug_flags)
 
-
 @depends(c_compiler)
 def color_cflags(info):
     # We could test compiling with flags. By why incur the overhead when
     # color support should always be present in a specific toolchain
     # version?
 
     # Code for auto-adding this flag to compiler invocations needs to
     # determine if an existing flag isn't already present. That is likely
@@ -1080,17 +1032,16 @@ def color_cflags(info):
     # before adding flags to return values.
     if info.type == 'gcc' and info.version >= '4.9.0':
         return '-fdiagnostics-color'
     elif info.type == 'clang':
         return '-fcolor-diagnostics'
     else:
         return ''
 
-
 set_config('COLOR_CFLAGS', color_cflags)
 
 # Some standard library headers (notably bionic on Android) declare standard
 # functions (e.g. getchar()) and also #define macros for those standard
 # functions.  libc++ deals with this by doing something like the following
 # (explanatory comments added):
 #
 #   #ifdef FUNC
@@ -1122,55 +1073,47 @@ set_config('COLOR_CFLAGS', color_cflags)
 # However, libc++ will only define _LIBCPP_INLINE_VISIBILITY if there is no
 # existing definition.  We can therefore define it to the empty string (since
 # we are properly managing visibility ourselves) and avoid this whole mess.
 # Note that we don't need to do this with gcc, as libc++ detects gcc and
 # effectively does the same thing we are doing here.
 #
 # _LIBCPP_ALWAYS_INLINE needs similar workarounds, since it too declares
 # hidden visibility.
-
-
 @depends(c_compiler, target)
 def libcxx_override_visibility(c_compiler, target):
     if c_compiler.type == 'clang' and target.os == 'Android':
         return ''
 
-
 set_define('_LIBCPP_INLINE_VISIBILITY', libcxx_override_visibility)
-set_define('_LIBCPP_INLINE_VISIBILITY_EXCEPT_GCC49',
-           libcxx_override_visibility)
+set_define('_LIBCPP_INLINE_VISIBILITY_EXCEPT_GCC49', libcxx_override_visibility)
 set_define('_LIBCPP_ALWAYS_INLINE', libcxx_override_visibility)
 set_define('_LIBCPP_ALWAYS_INLINE_EXCEPT_GCC49', libcxx_override_visibility)
 
-
 @depends(target, check_build_environment)
 def visibility_flags(target, env):
     if target.os != 'WINNT':
         if target.kernel == 'Darwin':
             return ('-fvisibility=hidden', '-fvisibility-inlines-hidden')
         return ('-I%s/system_wrappers' % os.path.join(env.dist),
                 '-include',
                 '%s/config/gcc_hidden.h' % env.topsrcdir)
 
-
 @depends(target, visibility_flags)
 def wrap_system_includes(target, visibility_flags):
     if visibility_flags and target.kernel != 'Darwin':
         return True
 
-
 set_define('HAVE_VISIBILITY_HIDDEN_ATTRIBUTE',
            depends(visibility_flags)(lambda v: bool(v) or None))
 set_define('HAVE_VISIBILITY_ATTRIBUTE',
            depends(visibility_flags)(lambda v: bool(v) or None))
 set_config('WRAP_SYSTEM_INCLUDES', wrap_system_includes)
 set_config('VISIBILITY_FLAGS', visibility_flags)
 
-
 @depends(c_compiler)
 @imports('multiprocessing')
 @imports(_from='__builtin__', _import='min')
 def pgo_flags(compiler):
     if compiler.type in ('gcc', 'clang'):
         return namespace(
             gen_cflags=['-fprofile-generate'],
             gen_ldflags=['-fprofile-generate'],
@@ -1194,84 +1137,75 @@ def pgo_flags(compiler):
             # optimization/PGO case. I think it's probably a compiler bug,
             # but we work around it here.
             use_cflags=['-GL', '-wd4624', '-wd4952'],
             # XXX: should be -LTCG:PGOPTIMIZE, but that fails on libxul.
             # Probably also a compiler bug, but what can you do?
             use_ldflags=['-LTCG:PGUPDATE', cgthreads],
         )
 
-
 set_config('PROFILE_GEN_CFLAGS', pgo_flags.gen_cflags)
 set_config('PROFILE_GEN_LDFLAGS', pgo_flags.gen_ldflags)
 set_config('PROFILE_USE_CFLAGS', pgo_flags.use_cflags)
 set_config('PROFILE_USE_LDFLAGS', pgo_flags.use_ldflags)
 
 # We only want to include windows.configure when we are compiling on
 # Windows, for Windows.
-
-
 @depends(target, host)
 def is_windows(target, host):
     return host.kernel == 'WINNT' and target.kernel == 'WINNT'
 
-
 include('windows.configure', when=is_windows)
 
 # Shader Compiler for Windows (and MinGW Cross Compile)
 # ==============================================================
 
 fxc = check_prog('FXC', ('fxc.exe', 'fxc2.exe'), when=depends(target)
                  (lambda t: t.kernel == 'WINNT'))
 wine = check_prog('WINE', ['wine'], when=depends(target, host)
                   (lambda t, h: t.kernel == 'WINNT' and h.kernel == 'Linux'))
 
 # Security Hardening
 # ==============================================================
 
 option('--enable-hardening', env='MOZ_SECURITY_HARDENING',
        help='Enables security hardening compiler options')
 
-
 @depends('--enable-hardening', c_compiler)
 def security_hardening_cflags(value, c_compiler):
     if value and c_compiler.type in ['gcc', 'clang']:
         return '-fstack-protector-strong'
 
-
 add_old_configure_assignment('HARDENING_CFLAGS', security_hardening_cflags)
 imply_option('--enable-pie', depends_if('--enable-hardening')(lambda v: v))
 
 option(env='RUSTFLAGS',
        nargs=1,
        help='Rust compiler flags')
 set_config('RUSTFLAGS', depends('RUSTFLAGS')(lambda flags: flags))
 
 
 imply_option('--enable-release', mozilla_official)
 imply_option('--enable-release', depends_if('MOZ_AUTOMATION')(lambda x: True))
 
 js_option('--enable-release',
           help='Build with more conservative, release engineering-oriented '
                'options. This may slow down builds.')
 
-
 @depends('--enable-release')
 def developer_options(value):
     if not value:
         return True
 
-
 add_old_configure_assignment('DEVELOPER_OPTIONS', developer_options)
 set_config('DEVELOPER_OPTIONS', developer_options)
 
 # Linker detection
 # ==============================================================
 
-
 @depends(target)
 def is_linker_option_enabled(target):
     if target.kernel not in ('Darwin', 'WINNT', 'SunOS'):
         return True
 
 
 option('--enable-gold',
        env='MOZ_FORCE_GOLD',
@@ -1290,18 +1224,17 @@ def enable_gnu_linker(enable_gold_option
     if toolchain_flags:
         cmd_base += toolchain_flags
 
     def resolve_gold():
         # Try to force the usage of gold
         targetDir = os.path.join(build_env.topobjdir, 'build', 'unix', 'gold')
 
         gold_detection_arg = '-print-prog-name=ld.gold'
-        gold = check_cmd_output(c_compiler.compiler,
-                                gold_detection_arg).strip()
+        gold = check_cmd_output(c_compiler.compiler, gold_detection_arg).strip()
         if not gold:
             return
 
         goldFullPath = find_program(gold)
         if goldFullPath is None:
             return
 
         if os.path.exists(targetDir):
@@ -1347,57 +1280,51 @@ def enable_gnu_linker(enable_gold_option
             KIND='gold'
         )
 
     # For other platforms without gold or the GNU linker
     return namespace(
         KIND='other'
     )
 
-
 js_option('--enable-linker', nargs=1,
           choices=('bfd', 'gold', 'lld', 'other'),
           help='Select the linker',
           when=is_linker_option_enabled)
 
-
 @depends('--enable-linker', c_compiler, developer_options, check_build_environment,
          extra_toolchain_flags, when=is_linker_option_enabled)
 @checking('for linker', lambda x: x.KIND)
 def select_linker(linker, c_compiler, developer_options, build_env, toolchain_flags):
     linker = linker[0] if linker else 'other'
     if linker in ('gold', 'bfd', 'other'):
         return enable_gnu_linker(linker == 'gold', c_compiler, developer_options,
                                  build_env, toolchain_flags, linker)
     if linker == 'lld':
         version_check = ['-Wl,--version']
-        cmd_base = c_compiler.wrapper + \
-            [c_compiler.compiler] + c_compiler.flags
+        cmd_base = c_compiler.wrapper + [c_compiler.compiler] + c_compiler.flags
         lld = "-fuse-ld=" + linker
         cmd = cmd_base + [lld] + version_check
         if 'LLD' in check_cmd_output(*cmd).decode('utf-8'):
             return namespace(
                 KIND='lld',
                 LINKER_FLAG=lld,
             )
         else:
             die("Could not use lld as linker")
 
 
-set_config('LD_IS_BFD', depends(select_linker.KIND)
-           (lambda x: x == 'bfd' or None))
+set_config('LD_IS_BFD', depends(select_linker.KIND)(lambda x: x == 'bfd' or None))
 set_config('LINKER_LDFLAGS', select_linker.LINKER_FLAG)
 
 # Code Coverage
 # ==============================================================
 
 js_option('--enable-coverage', env='MOZ_CODE_COVERAGE',
-          help='Enable code coverage')
-
+       help='Enable code coverage')
 
 @depends('--enable-coverage')
 def code_coverage(value):
     if value:
         return True
 
-
 set_config('MOZ_CODE_COVERAGE', code_coverage)
 set_define('MOZ_CODE_COVERAGE', code_coverage)
--- a/build/moz.configure/util.configure
+++ b/build/moz.configure/util.configure
@@ -1,15 +1,14 @@
 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-
 @imports('sys')
 def die(*args):
     'Print an error and terminate configure.'
     log.error(*args)
     sys.exit(1)
 
 
 @imports(_from='mozbuild.configure', _import='ConfigureError')
@@ -18,18 +17,16 @@ def configure_error(message):
     Primarily for use in moz.configure templates to sanity check
     their inputs from moz.configure usage.'''
     raise ConfigureError(message)
 
 # A wrapper to obtain a process' output that returns the output generated
 # by running the given command if it exits normally, and streams that
 # output to log.debug and calls die or the given error callback if it
 # does not.
-
-
 @imports(_from='__builtin__', _import='unicode')
 @imports('subprocess')
 @imports('sys')
 @imports(_from='mozbuild.configure.util', _import='LineIO')
 @imports(_from='mozbuild.shellutil', _import='quote')
 def check_cmd_output(*args, **kwargs):
     onerror = kwargs.pop('onerror', None)
 
@@ -65,17 +62,16 @@ def check_cmd_output(*args, **kwargs):
                 log.debug('Its %s was:', desc)
                 with LineIO(lambda l: log.debug('| %s', l)) as o:
                     o.write(out)
         if onerror:
             return onerror()
         die('Command `%s` failed with exit status %d.' %
             (quote(*args), retcode))
 
-
 @imports('os')
 def is_absolute_or_relative(path):
     if os.altsep and os.altsep in path:
         return True
     return os.sep in path
 
 
 @imports(_import='mozpack.path', _as='mozpath')
@@ -87,18 +83,17 @@ def normsep(path):
 @imports(_from='ctypes', _import='wintypes')
 @imports(_from='mozbuild.configure.constants', _import='WindowsBinaryType')
 def windows_binary_type(path):
     """Obtain the type of a binary on Windows.
 
     Returns WindowsBinaryType constant.
     """
     GetBinaryTypeW = ctypes.windll.kernel32.GetBinaryTypeW
-    GetBinaryTypeW.argtypes = [wintypes.LPWSTR,
-                               wintypes.POINTER(wintypes.DWORD)]
+    GetBinaryTypeW.argtypes = [wintypes.LPWSTR, wintypes.POINTER(wintypes.DWORD)]
     GetBinaryTypeW.restype = wintypes.BOOL
 
     bin_type = wintypes.DWORD()
     res = GetBinaryTypeW(path, ctypes.byref(bin_type))
     if not res:
         die('could not obtain binary type of %s' % path)
 
     if bin_type.value == 0:
@@ -147,17 +142,16 @@ def normalize_path():
                 size = needed
 
     else:
         def normalize_path(path):
             return normsep(path)
 
     return normalize_path
 
-
 normalize_path = normalize_path()
 
 
 # Locates the given program using which, or returns the given path if it
 # exists.
 # The `paths` parameter may be passed to search the given paths instead of
 # $PATH.
 @imports(_from='which', _import='which')
@@ -365,18 +359,16 @@ def Version(v):
 # Denotes a deprecated option. Combines option() and @depends:
 # @deprecated_option('--option')
 # def option(value):
 #     ...
 # @deprecated_option() takes the same arguments as option(), except `help`.
 # The function may handle the option like a typical @depends function would,
 # but it is recommended it emits a deprecation error message suggesting an
 # alternative option to use if there is one.
-
-
 @template
 def deprecated_option(*args, **kwargs):
     assert 'help' not in kwargs
     kwargs['help'] = 'Deprecated'
     opt = option(*args, **kwargs)
 
     def decorator(func):
         @depends(opt.option)
@@ -417,17 +409,16 @@ never = dependable(False)
 # arguments.
 @template
 def depends_tmpl(eval_args_fn, *args, **kwargs):
     if kwargs:
         assert len(kwargs) == 1
         when = kwargs['when']
     else:
         when = None
-
     def decorator(func):
         @depends(*args, when=when)
         def wrapper(*args):
             if eval_args_fn(args):
                 return func(*args)
         return wrapper
     return decorator
 
@@ -448,22 +439,20 @@ def depends_all(*args, **kwargs):
 
 # Hacks related to old-configure
 # ==============================
 
 @dependable
 def old_configure_assignments():
     return []
 
-
 @dependable
 def extra_old_configure_args():
     return []
 
-
 @template
 def add_old_configure_assignment(var, value):
     var = dependable(var)
     value = dependable(value)
 
     @depends(old_configure_assignments, var, value)
     @imports(_from='mozbuild.shellutil', _import='quote')
     def add_assignment(assignments, var, value):
@@ -473,15 +462,14 @@ def add_old_configure_assignment(var, va
             assignments.append('%s=1' % var)
         elif value is False:
             assignments.append('%s=' % var)
         else:
             if isinstance(value, (list, tuple)):
                 value = quote(*value)
             assignments.append('%s=%s' % (var, quote(str(value))))
 
-
 @template
 def add_old_configure_arg(arg):
     @depends(extra_old_configure_args, arg)
     def add_arg(args, arg):
         if arg:
             args.append(arg)
--- a/build/moz.configure/windows.configure
+++ b/build/moz.configure/windows.configure
@@ -3,17 +3,16 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 option('--with-windows-version', nargs=1, default='603',
        help='Windows SDK version to target. Win 8.1 (603) is currently'
             'the minimum supported version.')
 
-
 @depends('--with-windows-version')
 @imports(_from='__builtin__', _import='ValueError')
 def valid_windows_version(value):
     if not value:
         die('Cannot build with --without-windows-version')
     try:
         version = int(value[0], 16)
         if version in (0x603,):
@@ -22,17 +21,16 @@ def valid_windows_version(value):
         pass
 
     die('Invalid value for --with-windows-version (%s)', value[0])
 
 
 option(env='WINDOWSSDKDIR', nargs=1,
        help='Directory containing the Windows SDK')
 
-
 @depends('WINDOWSSDKDIR', host)
 def windows_sdk_dir(value, host):
     if value:
         return value
     if host.kernel != 'WINNT':
         return ()
 
     return set(x[1] for x in get_registry_values(
@@ -41,18 +39,16 @@ def windows_sdk_dir(value, host):
 
 # The Windows SDK 8.1 and 10 have different layouts. The former has
 # $SDK/include/$subdir, while the latter has $SDK/include/$version/$subdir.
 # The vcvars* scripts don't actually care about the version, they just take
 # the last alphanumerically.
 # The $SDK/lib directories always have version subdirectories, but while the
 # versions match the one in $SDK/include for SDK 10, it's "winv6.3" for SDK
 # 8.1.
-
-
 @imports('os')
 @imports('re')
 @imports(_from='__builtin__', _import='sorted')
 @imports(_from='__builtin__', _import='WindowsError')
 def get_sdk_dirs(sdk, subdir):
     def get_dirs_containing(sdk, stem, subdir):
         base = os.path.join(sdk, stem)
         try:
@@ -88,17 +84,16 @@ def get_sdk_dirs(sdk, subdir):
         )
 
 
 @imports(_from='mozbuild.shellutil', _import='quote')
 def valid_windows_sdk_dir_result(value):
     if value:
         return '0x%04x in %s' % (value.version, quote(value.path))
 
-
 @depends(c_compiler, windows_sdk_dir, valid_windows_version, 'WINDOWSSDKDIR')
 @checking('for Windows SDK', valid_windows_sdk_dir_result)
 @imports(_from='__builtin__', _import='sorted')
 @imports(_from='textwrap', _import='dedent')
 def valid_windows_sdk_dir(compiler, windows_sdk_dir, target_version,
                           windows_sdk_dir_env):
     if windows_sdk_dir_env:
         windows_sdk_dir_env = windows_sdk_dir_env[0]
@@ -165,17 +160,16 @@ add_old_configure_assignment(
         lambda x: '0x%04X0000' % x.version if x else None))
 
 
 @imports(_from='mozbuild.shellutil', _import='quote')
 def valid_ucrt_sdk_dir_result(value):
     if value:
         return '%s in %s' % (value.version, quote(value.path))
 
-
 @depends(windows_sdk_dir, 'WINDOWSSDKDIR')
 @checking('for Universal CRT SDK', valid_ucrt_sdk_dir_result)
 @imports('os')
 @imports(_from='__builtin__', _import='sorted')
 @imports(_import='mozpack.path', _as='mozpath')
 def valid_ucrt_sdk_dir(windows_sdk_dir, windows_sdk_dir_env):
     if windows_sdk_dir_env:
         windows_sdk_dir_env = windows_sdk_dir_env[0]
@@ -227,17 +221,17 @@ def valid_ucrt_sdk_dir(windows_sdk_dir, 
         raise FatalCheckError('Cannot find the Universal CRT SDK. '
                               'Please install it.')
 
     version, sdk = sdks[valid_sdks[0]]
     minimum_ucrt_version = Version('10.0.10586.0')
     if version < minimum_ucrt_version:
         raise FatalCheckError('Latest Universal CRT SDK version found %s'
                               ' and minimum required is %s.'
-                              % (version, minimum_ucrt_version))
+                              % (version,  minimum_ucrt_version))
 
     return namespace(
         path=sdk.path,
         include=sdk.include,
         lib=sdk.lib,
         version=version,
     )
 
@@ -268,18 +262,17 @@ def vc_path(c_compiler):
 @imports(_from='os.path', _import='isdir')
 def dia_sdk_dir(vc_path, c_compiler):
     if vc_path:
         if c_compiler.version < '19.10':
             path = os.path.join(os.path.dirname(vc_path), 'DIA SDK')
         else:
             # This would be easier if we had the installationPath that
             # get_vc_paths works with, since 'DIA SDK' is relative to that.
-            path = os.path.normpath(os.path.join(
-                vc_path, r'..\..\..\..\DIA SDK'))
+            path = os.path.normpath(os.path.join(vc_path, r'..\..\..\..\DIA SDK'))
         if isdir(path):
             return path
 
 
 @depends(vc_path, valid_windows_sdk_dir, valid_ucrt_sdk_dir, dia_sdk_dir)
 @imports('os')
 def include_path(vc_path, windows_sdk_dir, ucrt_sdk_dir, dia_sdk_dir):
     if not vc_path:
@@ -308,17 +301,16 @@ def include_path(vc_path, windows_sdk_di
     ))
     if dia_sdk_dir:
         includes.append(os.path.join(dia_sdk_dir, 'include'))
     # Set in the environment for old-configure
     includes = os.pathsep.join(includes)
     os.environ['INCLUDE'] = includes
     return includes
 
-
 set_config('INCLUDE', include_path)
 
 
 @depends(target, c_compiler, vc_path, valid_windows_sdk_dir, valid_ucrt_sdk_dir, dia_sdk_dir)
 @imports('os')
 def lib_path(target, c_compiler, vc_path, windows_sdk_dir, ucrt_sdk_dir, dia_sdk_dir):
     if not vc_path:
         return
@@ -366,23 +358,21 @@ def lib_path(target, c_compiler, vc_path
         # For some reason the DIA SDK still uses the old-style targets
         # even in a newer MSVC.
         libs.append(os.path.join(dia_sdk_dir, 'lib', *old_target))
     # Set in the environment for old-configure
     libs = os.pathsep.join(libs)
     os.environ['LIB'] = libs
     return libs
 
-
 set_config('LIB', lib_path)
 
 
 option(env='MT', nargs=1, help='Path to the Microsoft Manifest Tool')
 
-
 @depends(valid_windows_sdk_dir, valid_ucrt_sdk_dir)
 @imports(_from='os', _import='environ')
 @imports('platform')
 def sdk_bin_path(valid_windows_sdk_dir, valid_ucrt_sdk_dir):
     if not valid_windows_sdk_dir:
         return
 
     vc_host = {
@@ -413,17 +403,17 @@ mt = check_prog('MT', ('mt.exe',), input
 @checking('whether MT is really Microsoft Manifest Tool', lambda x: bool(x))
 @imports('subprocess')
 def valid_mt(path):
     try:
         out = subprocess.check_output([path]).splitlines()
         out = '\n'.join(l for l in out
                         if 'Microsoft (R) Manifest Tool' in l)
         if out:
-            return path
+              return path
     except subprocess.CalledProcessError:
         pass
     raise FatalCheckError('%s is not Microsoft Manifest Tool')
 
 
 set_config('MSMANIFEST_TOOL', depends(valid_mt)(lambda x: bool(x)))
 
 
@@ -438,12 +428,12 @@ add_old_configure_assignment('LINK', lin
 # valid_compiler().
 @depends(sdk_bin_path)
 @imports('os')
 def alter_path(sdk_bin_path):
     path = os.pathsep.join(sdk_bin_path)
     os.environ['PATH'] = path
     return path
 
-
 set_config('PATH', alter_path)
 
 check_prog('MAKECAB', ('makecab.exe',))
+
--- a/tools/lint/flake8.yml
+++ b/tools/lint/flake8.yml
@@ -1,13 +1,12 @@
 ---
 flake8:
     description: Python linter
     include:
-        - build/moz.configure/*.configure
         - config/check_macroassembler_style.py
         - config/mozunit.py
         - layout/tools/reftest
         - python/mach
         - python/mach_commands.py
         - python/mozlint
         - python/mozversioncontrol
         - security/manager