Bug 1241022 - Remove affected_tiers. r=gps
authorMike Hommey <mh+mozilla@glandium.org>
Wed, 20 Jan 2016 16:10:05 +0900
changeset 303102 7b9c54abd2fe8932e19ad57e3b334684a8c7f77d
parent 303101 d2692a330fb015047f110473a19b669ce1269826
child 303103 1fc5f691e48258d3f9be7f857d0a081b6a473790
push id8978
push userraliiev@mozilla.com
push dateMon, 25 Jan 2016 14:05:32 +0000
treeherdermozilla-aurora@b9a803752a2c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersgps
bugs1241022
milestone46.0a1
Bug 1241022 - Remove affected_tiers. r=gps
python/mozbuild/mozbuild/frontend/context.py
python/mozbuild/mozbuild/sphinx.py
python/mozbuild/mozbuild/test/frontend/test_context.py
python/mozbuild/mozbuild/test/frontend/test_namespaces.py
python/mozbuild/mozbuild/test/frontend/test_sandbox.py
--- a/python/mozbuild/mozbuild/frontend/context.py
+++ b/python/mozbuild/mozbuild/frontend/context.py
@@ -182,18 +182,18 @@ class Context(KeyedDefaultDict):
             return default(self)
         else:
             return default()
 
     def _validate(self, key, value, is_template=False):
         """Validates whether the key is allowed and if the value's type
         matches.
         """
-        stored_type, input_type, docs, tier = \
-            self._allowed_variables.get(key, (None, None, None, None))
+        stored_type, input_type, docs = \
+            self._allowed_variables.get(key, (None, None, None))
 
         if stored_type is None or not is_template and key in TEMPLATE_VARIABLES:
             raise KeyError('global_ns', 'set_unknown', key, value)
 
         # If the incoming value is not the type we store, we try to convert
         # it to that type. This relies on proper coercion rules existing. This
         # is the responsibility of whoever defined the symbols: a type should
         # not be in the allowed set if the constructor function for the stored
@@ -630,32 +630,32 @@ class Files(SubContext):
     """
 
     VARIABLES = {
         'BUG_COMPONENT': (BugzillaComponent, tuple,
             """The bug component that tracks changes to these files.
 
             Values are a 2-tuple of unicode describing the Bugzilla product and
             component. e.g. ``('Core', 'Build Config')``.
-            """, None),
+            """),
 
         'FINAL': (bool, bool,
             """Mark variable assignments as finalized.
 
             During normal processing, values from newer Files contexts
             overwrite previously set values. Last write wins. This behavior is
             not always desired. ``FINAL`` provides a mechanism to prevent
             further updates to a variable.
 
             When ``FINAL`` is set, the value of all variables defined in this
             context are marked as frozen and all subsequent writes to them
             are ignored during metadata reading.
 
             See :ref:`mozbuild_files_metadata_finalizing` for more info.
-            """, None),
+            """),
         'IMPACTED_TESTS': (DependentTestsEntry, list,
             """File patterns, tags, and flavors for tests relevant to these files.
 
             Maps source files to the tests potentially impacted by those files.
             Tests can be specified by file pattern, tag, or flavor.
 
             For example:
 
@@ -693,17 +693,17 @@ class Files(SubContext):
 
             with Files('dom/base/nsGlobalWindow.cpp'):
                 IMPACTED_TESTS.flavors += [
                     'mochitest',
                 ]
 
             Would suggest that nsGlobalWindow.cpp is potentially relevant to
             any plain mochitest.
-            """, None),
+            """),
     }
 
     def __init__(self, parent, pattern=None):
         super(Files, self).__init__(parent)
         self.pattern = pattern
         self.finalized = set()
         self.test_files = set()
         self.test_tags = set()
@@ -814,111 +814,102 @@ for cls in SUBCONTEXTS:
 
 SUBCONTEXTS = {cls.__name__: cls for cls in SUBCONTEXTS}
 
 
 # This defines the set of mutable global variables.
 #
 # Each variable is a tuple of:
 #
-#   (storage_type, input_types, docs, tier)
-#
-# Tier says for which specific tier the variable has an effect.
-# Valid tiers are:
-# - 'export'
-# - 'libs': everything that is not built from C/C++/ObjC source and that has
-#      traditionally been in the libs tier.
-# - 'misc': like libs, but with parallel build. Eventually, everything that
-#      currently is in libs should move here.
-# A value of None means the variable has no direct effect on any tier.
+#   (storage_type, input_types, docs)
 
 VARIABLES = {
     'ALLOW_COMPILER_WARNINGS': (bool, bool,
         """Whether to allow compiler warnings (i.e. *not* treat them as
         errors).
 
         This is commonplace (almost mandatory, in fact) in directories
         containing third-party code that we regularly update from upstream and
         thus do not control, but is otherwise discouraged.
-        """, None),
+        """),
 
     # Variables controlling reading of other frontend files.
     'ANDROID_GENERATED_RESFILES': (StrictOrderingOnAppendList, list,
         """Android resource files generated as part of the build.
 
         This variable contains a list of files that are expected to be
         generated (often by preprocessing) into a 'res' directory as
         part of the build process, and subsequently merged into an APK
         file.
-        """, None),
+        """),
 
     'ANDROID_APK_NAME': (unicode, unicode,
         """The name of an Android APK file to generate.
-        """, None),
+        """),
 
     'ANDROID_APK_PACKAGE': (unicode, unicode,
         """The name of the Android package to generate R.java for, like org.mozilla.gecko.
-        """, None),
+        """),
 
     'ANDROID_EXTRA_PACKAGES': (StrictOrderingOnAppendList, list,
         """The name of extra Android packages to generate R.java for, like ['org.mozilla.other'].
-        """, None),
+        """),
 
     'ANDROID_EXTRA_RES_DIRS': (ContextDerivedTypedListWithItems(Path, List), list,
         """Android extra package resource directories.
 
         This variable contains a list of directories containing static files
         to package into a 'res' directory and merge into an APK file.  These
         directories are packaged into the APK but are assumed to be static
         unchecked dependencies that should not be otherwise re-distributed.
-        """, None),
+        """),
 
     'ANDROID_RES_DIRS': (ContextDerivedTypedListWithItems(Path, List), list,
         """Android resource directories.
 
         This variable contains a list of directories containing static
         files to package into a 'res' directory and merge into an APK
         file.
-        """, None),
+        """),
 
     'ANDROID_ASSETS_DIRS': (ContextDerivedTypedListWithItems(Path, List), list,
         """Android assets directories.
 
         This variable contains a list of directories containing static
         files to package into an 'assets' directory and merge into an
         APK file.
-        """, None),
+        """),
 
     'ANDROID_ECLIPSE_PROJECT_TARGETS': (dict, dict,
         """Defines Android Eclipse project targets.
 
         This variable should not be populated directly. Instead, it should
         populated by calling add_android_eclipse{_library}_project().
-        """, None),
+        """),
 
     'SOURCES': (ContextDerivedTypedListWithItems(Path, StrictOrderingOnAppendListWithFlagsFactory({'no_pgo': bool, 'flags': List})), list,
         """Source code files.
 
         This variable contains a list of source code files to compile.
         Accepts assembler, C, C++, Objective C/C++.
-        """, None),
+        """),
 
     'FILES_PER_UNIFIED_FILE': (int, int,
         """The number of source files to compile into each unified source file.
 
-        """, None),
+        """),
 
     'UNIFIED_SOURCES': (ContextDerivedTypedList(SourcePath, StrictOrderingOnAppendList), list,
         """Source code files that can be compiled together.
 
         This variable contains a list of source code files to compile,
         that can be concatenated all together and built as a single source
         file. This can help make the build faster and reduce the debug info
         size.
-        """, None),
+        """),
 
     'GENERATED_FILES': (StrictOrderingOnAppendListWithFlagsFactory({
                 'script': unicode,
                 'inputs': list }), list,
         """Generic generated files.
 
         This variable contains a list of files for the build system to
         generate at export time. The generation method may be declared
@@ -952,17 +943,17 @@ VARIABLES = {
         into ``script`` can be specified::
 
           GENERATED_FILES += ['bar.c']
           bar = GENERATED_FILES['bar.c']
           bar.script = 'generate.py:make_bar'
 
         The chosen script entry point may optionally return a set of strings,
         indicating extra files the output depends on.
-        """, None),
+        """),
 
     'DEFINES': (InitializedDefines, dict,
         """Dictionary of compiler defines to declare.
 
         These are passed in to the compiler as ``-Dkey='value'`` for string
         values, ``-Dkey=value`` for numeric values, or ``-Dkey`` if the
         value is True. Note that for string values, the outer-level of
         single-quotes will be consumed by the shell. If you want to have
@@ -980,323 +971,323 @@ VARIABLES = {
         respectively. These could also be combined into a single
         update::
 
            DEFINES.update({
                'NS_NO_XPCOM': True,
                'MOZ_EXTENSIONS_DB_SCHEMA': 15,
                'DLL_SUFFIX': '".so"',
            })
-        """, None),
+        """),
 
     'DELAYLOAD_DLLS': (List, list,
         """Delay-loaded DLLs.
 
         This variable contains a list of DLL files which the module being linked
         should load lazily.  This only has an effect when building with MSVC.
-        """, None),
+        """),
 
     'DIRS': (ContextDerivedTypedList(SourcePath), list,
         """Child directories to descend into looking for build frontend files.
 
         This works similarly to the ``DIRS`` variable in make files. Each str
         value in the list is the name of a child directory. When this file is
         done parsing, the build reader will descend into each listed directory
         and read the frontend file there. If there is no frontend file, an error
         is raised.
 
         Values are relative paths. They can be multiple directory levels
         above or below. Use ``..`` for parent directories and ``/`` for path
         delimiters.
-        """, None),
+        """),
 
     'HAS_MISC_RULE': (bool, bool,
         """Whether this directory should be traversed in the ``misc`` tier.
 
         Many ``libs`` rules still exist in Makefile.in files. We highly prefer
         that these rules exist in the ``misc`` tier/target so that they can be
         executed concurrently during tier traversal (the ``misc`` tier is
         fully concurrent).
 
         Presence of this variable indicates that this directory should be
         traversed by the ``misc`` tier.
 
         Please note that converting ``libs`` rules to the ``misc`` tier must
         be done with care, as there are many implicit dependencies that can
         break the build in subtle ways.
-        """, None),
+        """),
 
     'FINAL_TARGET_FILES': (ContextDerivedTypedHierarchicalStringList(Path), list,
         """List of files to be installed into the application directory.
 
         ``FINAL_TARGET_FILES`` will copy (or symlink, if the platform supports it)
         the contents of its files to the directory specified by
         ``FINAL_TARGET`` (typically ``dist/bin``). Files that are destined for a
         subdirectory can be specified by accessing a field, or as a dict access.
         For example, to export ``foo.png`` to the top-level directory and
         ``bar.svg`` to the directory ``images/do-not-use``, append to
         ``FINAL_TARGET_FILES`` like so::
 
            FINAL_TARGET_FILES += ['foo.png']
            FINAL_TARGET_FILES.images['do-not-use'] += ['bar.svg']
-        """, None),
+        """),
 
     'DISABLE_STL_WRAPPING': (bool, bool,
         """Disable the wrappers for STL which allow it to work with C++ exceptions
         disabled.
-        """, None),
+        """),
 
     'FINAL_TARGET_PP_FILES': (ContextDerivedTypedHierarchicalStringList(Path), list,
         """Like ``FINAL_TARGET_FILES``, with preprocessing.
-        """, None),
+        """),
 
     'TESTING_FILES': (ContextDerivedTypedHierarchicalStringList(Path), list,
         """List of files to be installed in the _tests directory.
 
         This works similarly to FINAL_TARGET_FILES.
-        """, None),
+        """),
 
     'FINAL_LIBRARY': (unicode, unicode,
         """Library in which the objects of the current directory will be linked.
 
         This variable contains the name of a library, defined elsewhere with
         ``LIBRARY_NAME``, in which the objects of the current directory will be
         linked.
-        """, None),
+        """),
 
     'CPP_UNIT_TESTS': (StrictOrderingOnAppendList, list,
         """Compile a list of C++ unit test names.
 
         Each name in this variable corresponds to an executable built from the
         corresponding source file with the same base name.
 
         If the configuration token ``BIN_SUFFIX`` is set, its value will be
         automatically appended to each name. If a name already ends with
         ``BIN_SUFFIX``, the name will remain unchanged.
-        """, None),
+        """),
 
     'FORCE_SHARED_LIB': (bool, bool,
         """Whether the library in this directory is a shared library.
-        """, None),
+        """),
 
     'FORCE_STATIC_LIB': (bool, bool,
         """Whether the library in this directory is a static library.
-        """, None),
+        """),
 
     'USE_STATIC_LIBS': (bool, bool,
         """Whether the code in this directory is a built against the static
         runtime library.
 
         This variable only has an effect when building with MSVC.
-        """, None),
+        """),
 
     'HOST_SOURCES': (ContextDerivedTypedList(SourcePath, StrictOrderingOnAppendList), list,
         """Source code files to compile with the host compiler.
 
         This variable contains a list of source code files to compile.
         with the host compiler.
-        """, None),
+        """),
 
     'IS_COMPONENT': (bool, bool,
         """Whether the library contains a binary XPCOM component manifest.
 
         Implies FORCE_SHARED_LIB.
-        """, None),
+        """),
 
     'PYTHON_UNIT_TESTS': (StrictOrderingOnAppendList, list,
         """A list of python unit tests.
-        """, None),
+        """),
 
     'HOST_LIBRARY_NAME': (unicode, unicode,
         """Name of target library generated when cross compiling.
-        """, None),
+        """),
 
     'JAVA_JAR_TARGETS': (dict, dict,
         """Defines Java JAR targets to be built.
 
         This variable should not be populated directly. Instead, it should
         populated by calling add_java_jar().
-        """, None),
+        """),
 
     'LIBRARY_DEFINES': (OrderedDict, dict,
         """Dictionary of compiler defines to declare for the entire library.
 
         This variable works like DEFINES, except that declarations apply to all
         libraries that link into this library via FINAL_LIBRARY.
-        """, None),
+        """),
 
     'LIBRARY_NAME': (unicode, unicode,
         """The code name of the library generated for a directory.
 
         By default STATIC_LIBRARY_NAME and SHARED_LIBRARY_NAME take this name.
         In ``example/components/moz.build``,::
 
            LIBRARY_NAME = 'xpcomsample'
 
         would generate ``example/components/libxpcomsample.so`` on Linux, or
         ``example/components/xpcomsample.lib`` on Windows.
-        """, None),
+        """),
 
     'SHARED_LIBRARY_NAME': (unicode, unicode,
         """The name of the static library generated for a directory, if it needs to
         differ from the library code name.
 
         Implies FORCE_SHARED_LIB.
-        """, None),
+        """),
 
     'IS_FRAMEWORK': (bool, bool,
         """Whether the library to build should be built as a framework on OSX.
 
         This implies the name of the library won't be prefixed nor suffixed.
         Implies FORCE_SHARED_LIB.
-        """, None),
+        """),
 
     'STATIC_LIBRARY_NAME': (unicode, unicode,
         """The name of the static library generated for a directory, if it needs to
         differ from the library code name.
 
         Implies FORCE_STATIC_LIB.
-        """, None),
+        """),
 
     'USE_LIBS': (StrictOrderingOnAppendList, list,
         """List of libraries to link to programs and libraries.
-        """, None),
+        """),
 
     'HOST_USE_LIBS': (StrictOrderingOnAppendList, list,
         """List of libraries to link to host programs and libraries.
-        """, None),
+        """),
 
     'HOST_OS_LIBS': (List, list,
         """List of system libraries for host programs and libraries.
-        """, None),
+        """),
 
     'LOCAL_INCLUDES': (ContextDerivedTypedList(Path, StrictOrderingOnAppendList), list,
         """Additional directories to be searched for include files by the compiler.
-        """, None),
+        """),
 
     'NO_PGO': (bool, bool,
         """Whether profile-guided optimization is disable in this directory.
-        """, None),
+        """),
 
     'NO_VISIBILITY_FLAGS': (bool, bool,
         """Build sources listed in this file without VISIBILITY_FLAGS.
-        """, None),
+        """),
 
     'OS_LIBS': (List, list,
         """System link libraries.
 
         This variable contains a list of system libaries to link against.
-        """, None),
+        """),
     'RCFILE': (unicode, unicode,
         """The program .rc file.
 
         This variable can only be used on Windows.
-        """, None),
+        """),
 
     'RESFILE': (unicode, unicode,
         """The program .res file.
 
         This variable can only be used on Windows.
-        """, None),
+        """),
 
     'RCINCLUDE': (unicode, unicode,
         """The resource script file to be included in the default .res file.
 
         This variable can only be used on Windows.
-        """, None),
+        """),
 
     'DEFFILE': (unicode, unicode,
         """The program .def (module definition) file.
 
         This variable can only be used on Windows.
-        """, None),
+        """),
 
     'LD_VERSION_SCRIPT': (unicode, unicode,
         """The linker version script for shared libraries.
 
         This variable can only be used on Linux.
-        """, None),
+        """),
 
     'SYMBOLS_FILE': (SourcePath, unicode,
         """A file containing a list of symbols to export from a shared library.
 
         The given file contains a list of symbols to be exported, and is
         preprocessed.
         A special marker "@DATA@" must be added after a symbol name if it
         points to data instead of code, so that the Windows linker can treat
         them correctly.
-        """, None),
+        """),
 
     'BRANDING_FILES': (ContextDerivedTypedHierarchicalStringList(Path), list,
         """List of files to be installed into the branding directory.
 
         ``BRANDING_FILES`` will copy (or symlink, if the platform supports it)
         the contents of its files to the ``dist/branding`` directory. Files that
         are destined for a subdirectory can be specified by accessing a field.
         For example, to export ``foo.png`` to the top-level directory and
         ``bar.png`` to the directory ``images/subdir``, append to
         ``BRANDING_FILES`` like so::
 
            BRANDING_FILES += ['foo.png']
            BRANDING_FILES.images.subdir += ['bar.png']
-        """, None),
+        """),
 
     'SDK_LIBRARY': (bool, bool,
         """Whether the library built in the directory is part of the SDK.
 
         The library will be copied into ``SDK_LIB_DIR`` (``$DIST/sdk/lib``).
-        """, None),
+        """),
 
     'SIMPLE_PROGRAMS': (StrictOrderingOnAppendList, list,
         """Compile a list of executable names.
 
         Each name in this variable corresponds to an executable built from the
         corresponding source file with the same base name.
 
         If the configuration token ``BIN_SUFFIX`` is set, its value will be
         automatically appended to each name. If a name already ends with
         ``BIN_SUFFIX``, the name will remain unchanged.
-        """, None),
+        """),
 
     'SONAME': (unicode, unicode,
         """The soname of the shared object currently being linked
 
         soname is the "logical name" of a shared object, often used to provide
         version backwards compatibility. This variable makes sense only for
         shared objects, and is supported only on some unix platforms.
-        """, None),
+        """),
 
     'HOST_SIMPLE_PROGRAMS': (StrictOrderingOnAppendList, list,
         """Compile a list of host executable names.
 
         Each name in this variable corresponds to a hosst executable built
         from the corresponding source file with the same base name.
 
         If the configuration token ``HOST_BIN_SUFFIX`` is set, its value will
         be automatically appended to each name. If a name already ends with
         ``HOST_BIN_SUFFIX``, the name will remain unchanged.
-        """, None),
+        """),
 
     'CONFIGURE_SUBST_FILES': (ContextDerivedTypedList(SourcePath, StrictOrderingOnAppendList), list,
         """Output files that will be generated using configure-like substitution.
 
         This is a substitute for ``AC_OUTPUT`` in autoconf. For each path in this
         list, we will search for a file in the srcdir having the name
         ``{path}.in``. The contents of this file will be read and variable
         patterns like ``@foo@`` will be substituted with the values of the
         ``AC_SUBST`` variables declared during configure.
-        """, None),
+        """),
 
     'CONFIGURE_DEFINE_FILES': (ContextDerivedTypedList(SourcePath, StrictOrderingOnAppendList), list,
         """Output files generated from configure/config.status.
 
         This is a substitute for ``AC_CONFIG_HEADER`` in autoconf. This is very
         similar to ``CONFIGURE_SUBST_FILES`` except the generation logic takes
         into account the values of ``AC_DEFINE`` instead of ``AC_SUBST``.
-        """, None),
+        """),
 
     'EXPORTS': (ContextDerivedTypedHierarchicalStringList(Path), list,
         """List of files to be exported, and in which subdirectories.
 
         ``EXPORTS`` is generally used to list the include files to be exported to
         ``dist/include``, but it can be used for other files as well. This variable
         behaves as a list when appending filenames for export in the top-level
         directory. Files can also be appended to a field to indicate which
@@ -1305,242 +1296,242 @@ VARIABLES = {
         append to ``EXPORTS`` like so::
 
            EXPORTS += ['foo.h']
            EXPORTS.mozilla.dom += ['bar.h']
 
         Entries in ``EXPORTS`` are paths, so objdir paths may be used, but
         any files listed from the objdir must also be listed in
         ``GENERATED_FILES``.
-        """, None),
+        """),
 
     'PROGRAM' : (unicode, unicode,
         """Compiled executable name.
 
         If the configuration token ``BIN_SUFFIX`` is set, its value will be
         automatically appended to ``PROGRAM``. If ``PROGRAM`` already ends with
         ``BIN_SUFFIX``, ``PROGRAM`` will remain unchanged.
-        """, None),
+        """),
 
     'HOST_PROGRAM' : (unicode, unicode,
         """Compiled host executable name.
 
         If the configuration token ``HOST_BIN_SUFFIX`` is set, its value will be
         automatically appended to ``HOST_PROGRAM``. If ``HOST_PROGRAM`` already
         ends with ``HOST_BIN_SUFFIX``, ``HOST_PROGRAM`` will remain unchanged.
-        """, None),
+        """),
 
     'DIST_INSTALL': (Enum(None, False, True), bool,
         """Whether to install certain files into the dist directory.
 
         By default, some files types are installed in the dist directory, and
         some aren't. Set this variable to True to force the installation of
         some files that wouldn't be installed by default. Set this variable to
         False to force to not install some files that would be installed by
         default.
 
         This is confusing for historical reasons, but eventually, the behavior
         will be made explicit.
-        """, None),
+        """),
 
     'JAR_MANIFESTS': (ContextDerivedTypedList(SourcePath, StrictOrderingOnAppendList), list,
         """JAR manifest files that should be processed as part of the build.
 
         JAR manifests are files in the tree that define how to package files
         into JARs and how chrome registration is performed. For more info,
         see :ref:`jar_manifests`.
-        """, None),
+        """),
 
     # IDL Generation.
     'XPIDL_SOURCES': (StrictOrderingOnAppendList, list,
         """XPCOM Interface Definition Files (xpidl).
 
         This is a list of files that define XPCOM interface definitions.
         Entries must be files that exist. Entries are almost certainly ``.idl``
         files.
-        """, None),
+        """),
 
     'XPIDL_MODULE': (unicode, unicode,
         """XPCOM Interface Definition Module Name.
 
         This is the name of the ``.xpt`` file that is created by linking
         ``XPIDL_SOURCES`` together. If unspecified, it defaults to be the same
         as ``MODULE``.
-        """, None),
+        """),
 
     'XPIDL_NO_MANIFEST': (bool, bool,
         """Indicate that the XPIDL module should not be added to a manifest.
 
         This flag exists primarily to prevent test-only XPIDL modules from being
         added to the application's chrome manifest. Most XPIDL modules should
         not use this flag.
-        """, None),
+        """),
 
     'IPDL_SOURCES': (StrictOrderingOnAppendList, list,
         """IPDL source files.
 
         These are ``.ipdl`` files that will be parsed and converted to
         ``.cpp`` files.
-        """, None),
+        """),
 
     'WEBIDL_FILES': (StrictOrderingOnAppendList, list,
         """WebIDL source files.
 
         These will be parsed and converted to ``.cpp`` and ``.h`` files.
-        """, None),
+        """),
 
     'GENERATED_EVENTS_WEBIDL_FILES': (StrictOrderingOnAppendList, list,
         """WebIDL source files for generated events.
 
         These will be parsed and converted to ``.cpp`` and ``.h`` files.
-        """, None),
+        """),
 
     'TEST_WEBIDL_FILES': (StrictOrderingOnAppendList, list,
          """Test WebIDL source files.
 
          These will be parsed and converted to ``.cpp`` and ``.h`` files
          if tests are enabled.
-         """, None),
+         """),
 
     'GENERATED_WEBIDL_FILES': (StrictOrderingOnAppendList, list,
          """Generated WebIDL source files.
 
          These will be generated from some other files.
-         """, None),
+         """),
 
     'PREPROCESSED_TEST_WEBIDL_FILES': (StrictOrderingOnAppendList, list,
          """Preprocessed test WebIDL source files.
 
          These will be preprocessed, then parsed and converted to .cpp
          and ``.h`` files if tests are enabled.
-         """, None),
+         """),
 
     'PREPROCESSED_WEBIDL_FILES': (StrictOrderingOnAppendList, list,
          """Preprocessed WebIDL source files.
 
          These will be preprocessed before being parsed and converted.
-         """, None),
+         """),
 
     'WEBIDL_EXAMPLE_INTERFACES': (StrictOrderingOnAppendList, list,
         """Names of example WebIDL interfaces to build as part of the build.
 
         Names in this list correspond to WebIDL interface names defined in
         WebIDL files included in the build from one of the \*WEBIDL_FILES
         variables.
-        """, None),
+        """),
 
     # Test declaration.
     'A11Y_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining a11y tests.
-        """, None),
+        """),
 
     'BROWSER_CHROME_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining browser chrome tests.
-        """, None),
+        """),
 
     'JETPACK_PACKAGE_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining jetpack package tests.
-        """, None),
+        """),
 
     'JETPACK_ADDON_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining jetpack addon tests.
-        """, None),
+        """),
 
     'CRASHTEST_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining crashtests.
 
         These are commonly named crashtests.list.
-        """, None),
+        """),
 
     'ANDROID_INSTRUMENTATION_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining Android instrumentation tests.
-        """, None),
+        """),
 
     'METRO_CHROME_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining metro browser chrome tests.
-        """, None),
+        """),
 
     'MOCHITEST_CHROME_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining mochitest chrome tests.
-        """, None),
+        """),
 
     'MOCHITEST_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining mochitest tests.
-        """, None),
+        """),
 
     'MOCHITEST_WEBAPPRT_CONTENT_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining webapprt mochitest content tests.
-        """, None),
+        """),
 
     'MOCHITEST_WEBAPPRT_CHROME_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining webapprt mochitest chrome tests.
-        """, None),
+        """),
 
     'REFTEST_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining reftests.
 
         These are commonly named reftest.list.
-        """, None),
+        """),
 
     'WEB_PLATFORM_TESTS_MANIFESTS': (TypedList(WebPlatformTestManifest), list,
         """List of (manifest_path, test_path) defining web-platform-tests.
-        """, None),
+        """),
 
     'WEBRTC_SIGNALLING_TEST_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining WebRTC signalling tests.
-        """, None),
+        """),
 
     'XPCSHELL_TESTS_MANIFESTS': (StrictOrderingOnAppendList, list,
         """List of manifest files defining xpcshell tests.
-        """, None),
+        """),
 
     # The following variables are used to control the target of installed files.
     'XPI_NAME': (unicode, unicode,
         """The name of an extension XPI to generate.
 
         When this variable is present, the results of this directory will end up
         being packaged into an extension instead of the main dist/bin results.
-        """, None),
+        """),
 
     'DIST_SUBDIR': (unicode, unicode,
         """The name of an alternate directory to install files to.
 
         When this variable is present, the results of this directory will end up
         being placed in the $(DIST_SUBDIR) subdirectory of where it would
         otherwise be placed.
-        """, None),
+        """),
 
     'FINAL_TARGET': (FinalTargetValue, unicode,
         """The name of the directory to install targets to.
 
         The directory is relative to the top of the object directory. The
         default value is dependent on the values of XPI_NAME and DIST_SUBDIR. If
         neither are present, the result is dist/bin. If XPI_NAME is present, the
         result is dist/xpi-stage/$(XPI_NAME). If DIST_SUBDIR is present, then
         the $(DIST_SUBDIR) directory of the otherwise default value is used.
-        """, None),
+        """),
 
     'USE_EXTENSION_MANIFEST': (bool, bool,
         """Controls the name of the manifest for JAR files.
 
         By default, the name of the manifest is ${JAR_MANIFEST}.manifest.
         Setting this variable to ``True`` changes the name of the manifest to
         chrome.manifest.
-        """, None),
+        """),
 
     'NO_JS_MANIFEST': (bool, bool,
         """Explicitly disclaims responsibility for manifest listing in EXTRA_COMPONENTS.
 
         Normally, if you have .js files listed in ``EXTRA_COMPONENTS`` or
         ``EXTRA_PP_COMPONENTS``, you are expected to have a corresponding
         .manifest file to go with those .js files.  Setting ``NO_JS_MANIFEST``
         indicates that the relevant .manifest file and entries for those .js
         files are elsehwere (jar.mn, for instance) and this state of affairs
         is OK.
-        """, None),
+        """),
 
     'GYP_DIRS': (StrictOrderingOnAppendListWithFlagsFactory({
             'variables': dict,
             'input': unicode,
             'sandbox_vars': dict,
             'non_unified_sources': StrictOrderingOnAppendList,
         }), list,
         """Defines a list of object directories handled by gyp configurations.
@@ -1563,154 +1554,154 @@ VARIABLES = {
         Typical use looks like:
             GYP_DIRS += ['foo', 'bar']
             GYP_DIRS['foo'].input = 'foo/foo.gyp'
             GYP_DIRS['foo'].variables = {
                 'foo': 'bar',
                 (...)
             }
             (...)
-        """, None),
+        """),
 
     'SPHINX_TREES': (dict, dict,
         """Describes what the Sphinx documentation tree will look like.
 
         Keys are relative directories inside the final Sphinx documentation
         tree to install files into. Values are directories (relative to this
         file) whose content to copy into the Sphinx documentation tree.
-        """, None),
+        """),
 
     'SPHINX_PYTHON_PACKAGE_DIRS': (StrictOrderingOnAppendList, list,
         """Directories containing Python packages that Sphinx documents.
-        """, None),
+        """),
 
     'CFLAGS': (List, list,
         """Flags passed to the C compiler for all of the C source files
            declared in this directory.
 
            Note that the ordering of flags matters here, these flags will be
            added to the compiler's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'CXXFLAGS': (List, list,
         """Flags passed to the C++ compiler for all of the C++ source files
            declared in this directory.
 
            Note that the ordering of flags matters here; these flags will be
            added to the compiler's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'HOST_DEFINES': (InitializedDefines, dict,
         """Dictionary of compiler defines to declare for host compilation.
         See ``DEFINES`` for specifics.
-        """, None),
+        """),
 
     'CMFLAGS': (List, list,
         """Flags passed to the Objective-C compiler for all of the Objective-C
            source files declared in this directory.
 
            Note that the ordering of flags matters here; these flags will be
            added to the compiler's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'CMMFLAGS': (List, list,
         """Flags passed to the Objective-C++ compiler for all of the
            Objective-C++ source files declared in this directory.
 
            Note that the ordering of flags matters here; these flags will be
            added to the compiler's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'ASFLAGS': (List, list,
         """Flags passed to the assembler for all of the assembly source files
            declared in this directory.
 
            Note that the ordering of flags matters here; these flags will be
            added to the assembler's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'HOST_CFLAGS': (List, list,
         """Flags passed to the host C compiler for all of the C source files
            declared in this directory.
 
            Note that the ordering of flags matters here, these flags will be
            added to the compiler's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'HOST_CXXFLAGS': (List, list,
         """Flags passed to the host C++ compiler for all of the C++ source files
            declared in this directory.
 
            Note that the ordering of flags matters here; these flags will be
            added to the compiler's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'LDFLAGS': (List, list,
         """Flags passed to the linker when linking all of the libraries and
            executables declared in this directory.
 
            Note that the ordering of flags matters here; these flags will be
            added to the linker's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'EXTRA_DSO_LDOPTS': (List, list,
         """Flags passed to the linker when linking a shared library.
 
            Note that the ordering of flags matter here, these flags will be
            added to the linker's command line in the same order as they
            appear in the moz.build file.
-        """, None),
+        """),
 
     'WIN32_EXE_LDFLAGS': (List, list,
         """Flags passed to the linker when linking a Windows .exe executable
            declared in this directory.
 
            Note that the ordering of flags matter here, these flags will be
            added to the linker's command line in the same order as they
            appear in the moz.build file.
 
            This variable only has an effect on Windows.
-        """, None),
+        """),
 
     'TEST_HARNESS_FILES': (HierarchicalStringList, list,
         """List of files to be installed for test harnesses.
 
         ``TEST_HARNESS_FILES`` can be used to install files to any directory
         under $objdir/_tests. Files can be appended to a field to indicate
         which subdirectory they should be exported to. For example,
         to export ``foo.py`` to ``_tests/foo``, append to
         ``TEST_HARNESS_FILES`` like so::
            TEST_HARNESS_FILES.foo += ['foo.py']
 
         Files from topsrcdir and the objdir can also be installed by prefixing
         the path(s) with a '/' character and a '!' character, respectively::
            TEST_HARNESS_FILES.path += ['/build/bar.py', '!quux.py']
-        """, None),
+        """),
 
     'NO_EXPAND_LIBS': (bool, bool,
         """Forces to build a real static library, and no corresponding fake
            library.
-        """, None),
+        """),
 
     'NO_COMPONENTS_MANIFEST': (bool, bool,
         """Do not create a binary-component manifest entry for the
         corresponding XPCOMBinaryComponent.
-        """, None),
+        """),
 }
 
 # Sanity check: we don't want any variable above to have a list as storage type.
-for name, (storage_type, input_types, docs, tier) in VARIABLES.items():
+for name, (storage_type, input_types, docs) in VARIABLES.items():
     if storage_type == list:
         raise RuntimeError('%s has a "list" storage type. Use "List" instead.'
             % name)
 
 # Set of variables that are only allowed in templates:
 TEMPLATE_VARIABLES = {
     'CPP_UNIT_TESTS',
     'FORCE_SHARED_LIB',
@@ -1724,19 +1715,19 @@ TEMPLATE_VARIABLES = {
     'SIMPLE_PROGRAMS',
 }
 
 # Add a note to template variable documentation.
 for name in TEMPLATE_VARIABLES:
     if name not in VARIABLES:
         raise RuntimeError('%s is in TEMPLATE_VARIABLES but not in VARIABLES.'
             % name)
-    storage_type, input_types, docs, tier = VARIABLES[name]
+    storage_type, input_types, docs = VARIABLES[name]
     docs += 'This variable is only available in templates.\n'
-    VARIABLES[name] = (storage_type, input_types, docs, tier)
+    VARIABLES[name] = (storage_type, input_types, docs)
 
 
 # The set of functions exposed to the sandbox.
 #
 # Each entry is a tuple of:
 #
 #  (function returning the corresponding function from a given sandbox,
 #   (argument types), docs)
--- a/python/mozbuild/mozbuild/sphinx.py
+++ b/python/mozbuild/mozbuild/sphinx.py
@@ -46,17 +46,17 @@ def function_reference(f, attr, args, do
     ])
 
     lines.extend(docstring[1:])
     lines.append('')
 
     return lines
 
 
-def variable_reference(v, st_type, in_type, doc, tier):
+def variable_reference(v, st_type, in_type, doc):
     lines = [
         v,
         '-' * len(v),
         '',
     ]
 
     docstring = prepare_docstring(doc)
 
--- a/python/mozbuild/mozbuild/test/frontend/test_context.py
+++ b/python/mozbuild/mozbuild/test/frontend/test_context.py
@@ -26,19 +26,19 @@ from mozbuild.frontend.context import (
 
 from mozbuild.util import StrictOrderingOnAppendListWithFlagsFactory
 from mozpack import path as mozpath
 
 
 class TestContext(unittest.TestCase):
     def test_defaults(self):
         test = Context({
-            'foo': (int, int, '', None),
-            'bar': (bool, bool, '', None),
-            'baz': (dict, dict, '', None),
+            'foo': (int, int, ''),
+            'bar': (bool, bool, ''),
+            'baz': (dict, dict, ''),
         })
 
         self.assertEqual(test.keys(), [])
 
         self.assertEqual(test['foo'], 0)
 
         self.assertEqual(set(test.keys()), { 'foo' })
 
@@ -52,18 +52,18 @@ class TestContext(unittest.TestCase):
 
         with self.assertRaises(KeyError):
             test['qux']
 
         self.assertEqual(set(test.keys()), { 'foo', 'bar', 'baz' })
 
     def test_type_check(self):
         test = Context({
-            'foo': (int, int, '', None),
-            'baz': (dict, list, '', None),
+            'foo': (int, int, ''),
+            'baz': (dict, list, ''),
         })
 
         test['foo'] = 5
 
         self.assertEqual(test['foo'], 5)
 
         with self.assertRaises(ValueError):
             test['foo'] = {}
@@ -74,19 +74,19 @@ class TestContext(unittest.TestCase):
             test['bar'] = True
 
         test['baz'] = [('a', 1), ('b', 2)]
 
         self.assertEqual(test['baz'], { 'a': 1, 'b': 2 })
 
     def test_update(self):
         test = Context({
-            'foo': (int, int, '', None),
-            'bar': (bool, bool, '', None),
-            'baz': (dict, list, '', None),
+            'foo': (int, int, ''),
+            'bar': (bool, bool, ''),
+            'baz': (dict, list, ''),
         })
 
         self.assertEqual(test.keys(), [])
 
         with self.assertRaises(ValueError):
             test.update(bar=True, foo={})
 
         self.assertEqual(test.keys(), [])
@@ -253,17 +253,17 @@ class TestSymbols(unittest.TestCase):
 
         self.assertGreater(len(lines), 0)
         self.assertGreater(len(lines[0].strip()), 0)
 
         # Last line should be empty.
         self.assertEqual(lines[-1].strip(), '')
 
     def test_documentation_formatting(self):
-        for typ, inp, doc, tier in VARIABLES.values():
+        for typ, inp, doc in VARIABLES.values():
             self._verify_doc(doc)
 
         for attr, args, doc in FUNCTIONS.values():
             self._verify_doc(doc)
 
         for func, typ, doc in SPECIAL_VARIABLES.values():
             self._verify_doc(doc)
 
--- a/python/mozbuild/mozbuild/test/frontend/test_namespaces.py
+++ b/python/mozbuild/mozbuild/test/frontend/test_namespaces.py
@@ -43,26 +43,26 @@ class Piyo(ContextDerivedValue):
     def __cmp__(self, other):
         return cmp(self.value, str(other))
 
     def __hash__(self):
         return hash(self.value)
 
 
 VARIABLES = {
-    'HOGE': (unicode, unicode, None, None),
-    'FUGA': (Fuga, unicode, None, None),
-    'PIYO': (Piyo, unicode, None, None),
+    'HOGE': (unicode, unicode, None),
+    'FUGA': (Fuga, unicode, None),
+    'PIYO': (Piyo, unicode, None),
     'HOGERA': (ContextDerivedTypedList(Piyo, StrictOrderingOnAppendList),
-        list, None, None),
+        list, None),
     'HOGEHOGE': (ContextDerivedTypedListWithItems(
         Piyo,
         StrictOrderingOnAppendListWithFlagsFactory({
             'foo': bool,
-        })), list, None, None),
+        })), list, None),
 }
 
 class TestContext(unittest.TestCase):
     def test_key_rejection(self):
         # Lowercase keys should be rejected during normal operation.
         ns = Context(allowed_variables=VARIABLES)
 
         with self.assertRaises(KeyError) as ke:
--- a/python/mozbuild/mozbuild/test/frontend/test_sandbox.py
+++ b/python/mozbuild/mozbuild/test/frontend/test_sandbox.py
@@ -36,17 +36,17 @@ import mozpack.path as mozpath
 
 test_data_path = mozpath.abspath(mozpath.dirname(__file__))
 test_data_path = mozpath.join(test_data_path, 'data')
 
 
 class TestSandbox(unittest.TestCase):
     def sandbox(self):
         return Sandbox(Context({
-            'DIRS': (list, list, None, None),
+            'DIRS': (list, list, None),
         }))
 
     def test_exec_source_success(self):
         sandbox = self.sandbox()
         context = sandbox._context
 
         sandbox.exec_source('foo = True', mozpath.abspath('foo.py'))