Clean up cross-compilation and features

Integrate cross-compilation and media-stack handling into the
`build_like_command_arguments` decorator. This removes a lot of
repetition in the code and standardizes how targets are selected for all
similar commands.

Now cross compilation targets, feature flags, and helper variables are
stored in the CommandBase instance. This also avoids having to
continuously pass these arguments down to functions called by the
commands.

6 files changed, 182 insertions, 173 deletions

diff --git a/python/servo/build_commands.py b/python/servo/build_commands.py
index 5c016b82200..e9687479ea3 100644
--- a/python/servo/build_commands.py
+++ b/python/servo/build_commands.py
@@ -62,41 +62,19 @@ class MachCommands(CommandBase):
     @CommandArgument('--very-verbose', '-vv',
                      action='store_true',
                      help='Print very verbose output')
-    @CommandArgument('--uwp',
-                     action='store_true',
-                     help='Build for HoloLens (x64)')
-    @CommandArgument('--win-arm64', action='store_true', help="Use arm64 Windows target")
     @CommandArgument('params', nargs='...',
                      help="Command-line arguments to be passed through to Cargo")
     @CommandBase.build_like_command_arguments
-    def build(self, release=False, dev=False, jobs=None, params=None, media_stack=None,
-              no_package=False, verbose=False, very_verbose=False,
-              target=None, android=False, libsimpleservo=False,
-              features=None, uwp=False, win_arm64=False, **kwargs):
-        # Force the UWP-enabled target if the convenience UWP flags are passed.
-        if uwp and not target:
-            if win_arm64:
-                target = 'aarch64-uwp-windows-msvc'
-            else:
-                target = 'x86_64-uwp-windows-msvc'
-
+    def build(self, release=False, dev=False, jobs=None, params=None, no_package=False,
+              verbose=False, very_verbose=False, libsimpleservo=False, **kwargs):
         opts = params or []
-        features = features or []
-
-        target, android = self.pick_target_triple(target, android)
-
-        # Infer UWP build if only provided a target.
-        if not uwp:
-            uwp = target and 'uwp' in target
-
-        media_stack = self.pick_media_stack(media_stack, target)
-        features += media_stack
-        has_media_stack = media_stack[0] == "media-gstreamer"
+        has_media_stack = "media-gstreamer" in self.features
 
         target_path = base_path = servo.util.get_target_dir()
-        if android:
+        if self.is_android_build:
+            assert self.cross_compile_target
             target_path = path.join(target_path, "android")
-            base_path = path.join(target_path, target)
+            base_path = path.join(target_path, self.cross_compile_target)
 
         release_path = path.join(base_path, "release", "servo")
         dev_path = path.join(base_path, "debug", "servo")
@@ -135,15 +113,15 @@ class MachCommands(CommandBase):
         if very_verbose:
             opts += ["-vv"]
 
-        env = self.build_env(target=target, is_build=True, uwp=uwp, features=features)
-        self.ensure_bootstrapped(target=target)
+        env = self.build_env(is_build=True, features=self.features)
+        self.ensure_bootstrapped()
         self.ensure_clobbered()
 
         build_start = time()
         env["CARGO_TARGET_DIR"] = target_path
 
         host = servo.platform.host_triple()
-        target_triple = target or servo.platform.host_triple()
+        target_triple = self.cross_compile_target or servo.platform.host_triple()
         if 'apple-darwin' in host and target_triple == host:
             if 'CXXFLAGS' not in env:
                 env['CXXFLAGS'] = ''
@@ -166,7 +144,7 @@ class MachCommands(CommandBase):
 
             env['PKG_CONFIG_ALLOW_CROSS'] = "1"
 
-        if uwp:
+        if self.is_uwp_build:
             # Ensure libstd is ready for the new UWP target.
             check_call(["rustup", "component", "add", "rust-src"])
 
@@ -225,7 +203,7 @@ class MachCommands(CommandBase):
                 print(stderr.decode(encoding))
                 exit(1)
 
-        if android:
+        if self.is_android_build:
             if "ANDROID_NDK" not in env:
                 print("Please set the ANDROID_NDK environment variable.")
                 sys.exit(1)
@@ -244,7 +222,7 @@ class MachCommands(CommandBase):
             make_cmd = ["make"]
             if jobs is not None:
                 make_cmd += ["-j" + jobs]
-            openssl_dir = path.join(target_path, target, "native", "openssl")
+            openssl_dir = path.join(target_path, self.cross_compile_target, "native", "openssl")
             if not path.exists(openssl_dir):
                 os.makedirs(openssl_dir)
             shutil.copy(path.join(self.android_support_dir(), "openssl.makefile"), openssl_dir)
@@ -261,7 +239,7 @@ class MachCommands(CommandBase):
                     print("Currently only support NDK 15. Please re-run `./mach bootstrap-android`.")
                     sys.exit(1)
 
-            env["RUST_TARGET"] = target
+            env["RUST_TARGET"] = self.cross_compile_target
             with cd(openssl_dir):
                 status = call(
                     make_cmd + ["-f", "openssl.makefile"],
@@ -339,7 +317,7 @@ class MachCommands(CommandBase):
             # Also worth remembering: autoconf uses C for its configuration,
             # even for C++ builds, so the C flags need to line up with the C++ flags.
             env['CFLAGS'] = ' '.join([
-                "--target=" + target,
+                "--target=" + self.cross_compile_target,
                 "--sysroot=" + env['ANDROID_SYSROOT'],
                 "--gcc-toolchain=" + gcc_toolchain,
                 "-isystem", sysroot_include,
@@ -349,7 +327,7 @@ class MachCommands(CommandBase):
                 "-D__ANDROID_API__=" + android_api,
             ])
             env['CXXFLAGS'] = ' '.join([
-                "--target=" + target,
+                "--target=" + self.cross_compile_target,
                 "--sysroot=" + env['ANDROID_SYSROOT'],
                 "--gcc-toolchain=" + gcc_toolchain,
                 "-I" + cpufeatures_include,
@@ -368,7 +346,7 @@ class MachCommands(CommandBase):
                 "-D__NDK_FPABI__=",
             ])
             env['CPPFLAGS'] = ' '.join([
-                "--target=" + target,
+                "--target=" + self.cross_compile_target,
                 "--sysroot=" + env['ANDROID_SYSROOT'],
                 "-I" + arch_include,
             ])
@@ -431,26 +409,26 @@ class MachCommands(CommandBase):
 
         status = self.run_cargo_build_like_command(
             "build", opts, env=env, verbose=verbose,
-            target=target, android=android, libsimpleservo=libsimpleservo, uwp=uwp,
-            features=features, **kwargs
+            libsimpleservo=libsimpleservo, **kwargs
         )
 
         # Do some additional things if the build succeeded
         if status == 0:
-            if android and not no_package:
+            if self.is_android_build and not no_package:
                 flavor = None
-                if "googlevr" in features:
+                if "googlevr" in self.features:
                     flavor = "googlevr"
-                elif "oculusvr" in features:
+                elif "oculusvr" in self.features:
                     flavor = "oculusvr"
                 rv = Registrar.dispatch("package", context=self.context,
-                                        release=release, dev=dev, target=target, flavor=flavor)
+                                        release=release, dev=dev, target=self.cross_compile_target,
+                                        flavor=flavor)
                 if rv:
                     return rv
 
             if sys.platform == "win32":
                 servo_exe_dir = os.path.dirname(
-                    self.get_binary_path(release, dev, target=target, simpleservo=libsimpleservo)
+                    self.get_binary_path(release, dev, target=self.cross_compile_target, simpleservo=libsimpleservo)
                 )
                 assert os.path.exists(servo_exe_dir)
 
@@ -483,7 +461,7 @@ class MachCommands(CommandBase):
                         print("WARNING: could not find " + lib)
 
                 # UWP build has its own ANGLE library that it packages.
-                if not uwp:
+                if not self.is_uwp_build:
                     print("Packaging EGL DLLs")
                     egl_libs = ["libEGL.dll", "libGLESv2.dll"]
                     if not package_generated_shared_libraries(egl_libs, build_path, servo_exe_dir):
@@ -492,7 +470,7 @@ class MachCommands(CommandBase):
                 # copy needed gstreamer DLLs in to servo.exe dir
                 if has_media_stack:
                     print("Packaging gstreamer DLLs")
-                    if not package_gstreamer_dlls(env, servo_exe_dir, target_triple, uwp):
+                    if not package_gstreamer_dlls(env, servo_exe_dir, target_triple, self.is_uwp_build):
                         status = 1
 
                 # UWP app packaging already bundles all required DLLs for us.
@@ -501,13 +479,14 @@ class MachCommands(CommandBase):
                     status = 1
 
             elif sys.platform == "darwin":
-                servo_path = self.get_binary_path(release, dev, target=target, simpleservo=libsimpleservo)
+                servo_path = self.get_binary_path(
+                    release, dev, target=self.cross_compile_target, simpleservo=libsimpleservo)
                 servo_bin_dir = os.path.dirname(servo_path)
                 assert os.path.exists(servo_bin_dir)
 
                 if has_media_stack:
                     print("Packaging gstreamer dylibs")
-                    if not package_gstreamer_dylibs(target, servo_path):
+                    if not package_gstreamer_dylibs(self.cross_compile_target, servo_path):
                         return 1
 
                     # On Mac we use the relocatable dylibs from offical gstreamer
diff --git a/python/servo/command_base.py b/python/servo/command_base.py
index e6209b0cf23..268422fa38f 100644
--- a/python/servo/command_base.py
+++ b/python/servo/command_base.py
@@ -10,6 +10,7 @@
 from __future__ import print_function
 
 import contextlib
+from typing import Optional
 import distro
 import functools
 import gzip
@@ -38,7 +39,7 @@ import servo.util as util
 
 from xml.etree.ElementTree import XML
 from servo.util import download_file, get_default_cache_dir
-from mach.decorators import CommandArgument
+from mach.decorators import CommandArgument, CommandArgumentGroup
 from mach.registrar import Registrar
 
 BIN_SUFFIX = ".exe" if sys.platform == "win32" else ""
@@ -228,6 +229,10 @@ class CommandBase(object):
 
     def __init__(self, context):
         self.context = context
+        self.features = []
+        self.cross_compile_target = None
+        self.is_uwp_build = False
+        self.is_android_build = False
 
         def get_env_bool(var, default):
             # Contents of env vars are strings by default. This returns the
@@ -285,8 +290,9 @@ class CommandBase(object):
         self.config["android"].setdefault("sdk", "")
         self.config["android"].setdefault("ndk", "")
         self.config["android"].setdefault("toolchain", "")
+
         # Set default android target
-        self.handle_android_target("armv7-linux-androideabi")
+        self.setup_configuration_for_android_target("armv7-linux-androideabi")
 
     _rust_toolchain = None
 
@@ -516,12 +522,13 @@ class CommandBase(object):
             'vcdir': vcinstalldir,
         }
 
-    def build_env(self, hosts_file_path=None, target=None, is_build=False, test_unit=False, uwp=False, features=None):
+    def build_env(self, hosts_file_path=None, is_build=False, test_unit=False, features=None):
         """Return an extended environment dictionary."""
         env = os.environ.copy()
 
         if not features or "media-dummy" not in features:
-            servo.platform.get().set_gstreamer_environment_variables_if_necessary(env, cross_compilation_target=target)
+            servo.platform.get().set_gstreamer_environment_variables_if_necessary(
+                env, cross_compilation_target=self.cross_compile_target)
 
         if sys.platform == "win32" and type(env['PATH']) == six.text_type:
             # On win32, the virtualenv's activate_this.py script sometimes ends up
@@ -532,7 +539,8 @@ class CommandBase(object):
             # it in any case.
             env['PATH'] = env['PATH'].encode('ascii', 'ignore')
         extra_path = []
-        if "msvc" in (target or servo.platform.host_triple()):
+        effective_target = self.cross_compile_target or servo.platform.host_triple()
+        if "msvc" in effective_target:
             extra_path += [path.join(self.msvc_package_dir("cmake"), "bin")]
             extra_path += [path.join(self.msvc_package_dir("llvm"), "bin")]
             extra_path += [path.join(self.msvc_package_dir("ninja"), "bin")]
@@ -540,20 +548,20 @@ class CommandBase(object):
 
             env.setdefault("CC", "clang-cl.exe")
             env.setdefault("CXX", "clang-cl.exe")
-            if uwp:
+            if self.is_uwp_build:
                 env.setdefault("TARGET_CFLAGS", "")
                 env.setdefault("TARGET_CXXFLAGS", "")
                 env["TARGET_CFLAGS"] += " -DWINAPI_FAMILY=WINAPI_FAMILY_APP"
                 env["TARGET_CXXFLAGS"] += " -DWINAPI_FAMILY=WINAPI_FAMILY_APP"
 
-            arch = (target or servo.platform.host_triple()).split('-')[0]
+            arch = effective_target.split('-')[0]
             vcpkg_arch = {
                 "x86_64": "x64-windows",
                 "i686": "x86-windows",
                 "aarch64": "arm64-windows",
             }
             target_arch = vcpkg_arch[arch]
-            if uwp:
+            if self.is_uwp_build:
                 target_arch += "-uwp"
             openssl_base_dir = path.join(self.msvc_package_dir("openssl"), target_arch)
 
@@ -657,9 +665,10 @@ class CommandBase(object):
             env['CCACHE'] = self.config["build"]["ccache"]
 
         # Ensure Rust uses hard floats and SIMD on ARM devices
-        if target:
-            if target.startswith('arm') or target.startswith('aarch64'):
-                env['RUSTFLAGS'] = env.get('RUSTFLAGS', "") + " -C target-feature=+neon"
+        if self.cross_compile_target and (
+            self.cross_compile_target.startswith('arm')
+                or self.cross_compile_target.startswith('aarch64')):
+            env['RUSTFLAGS'] = env.get('RUSTFLAGS', "") + " -C target-feature=+neon"
 
         env['RUSTFLAGS'] = env.get('RUSTFLAGS', "") + " -W unused-extern-crates"
 
@@ -708,107 +717,151 @@ class CommandBase(object):
         return env
 
     @staticmethod
-    def build_like_command_arguments(decorated_function):
+    def build_like_command_arguments(original_function):
         decorators = [
+            CommandArgumentGroup('Cross Compilation'),
             CommandArgument(
                 '--target', '-t',
+                group="Cross Compilation",
                 default=None,
                 help='Cross compile for given target platform',
             ),
             CommandArgument(
-                '--media-stack',
-                default=None,
-                choices=["gstreamer", "dummy"],
-                help='Which media stack to use',
+                '--android', default=None, action='store_true',
+                help='Build for Android. If --target is not specified, this '
+                     'will choose a default target architecture.',
             ),
             CommandArgument(
-                '--android',
-                default=None,
+                '--uwp',
+                group="Cross Compilation",
                 action='store_true',
-                help='Build for Android',
+                help='Build for HoloLens (x64)'),
+            CommandArgument('--win-arm64', action='store_true', help="Use arm64 Windows target"),
+            CommandArgumentGroup('Feature Selection'),
+            CommandArgument(
+                '--features', default=None, group="Feature Selection", nargs='+',
+                help='Space-separated list of features to also build',
+            ),
+            CommandArgument(
+                '--media-stack', default=None, group="Feature Selection",
+                choices=["gstreamer", "dummy"], help='Which media stack to use',
             ),
             CommandArgument(
                 '--libsimpleservo',
                 default=None,
+                group="Feature Selection",
                 action='store_true',
                 help='Build the libsimpleservo library instead of the servo executable',
             ),
             CommandArgument(
-                '--features',
-                default=None,
-                help='Space-separated list of features to also build',
-                nargs='+',
-            ),
-            CommandArgument(
                 '--debug-mozjs',
-                default=None,
+                default=False,
+                group="Feature Selection",
                 action='store_true',
                 help='Enable debug assertions in mozjs',
             ),
             CommandArgument(
                 '--with-debug-assertions',
-                default=None,
+                default=False,
+                group="Feature Selection",
                 action='store_true',
                 help='Enable debug assertions in release',
             ),
             CommandArgument(
                 '--with-frame-pointer',
-                default=None,
+                default=None, group="Feature Selection",
                 action='store_true',
                 help='Build with frame pointer enabled, used by the background hang monitor.',
             ),
-            CommandArgument('--with-layout-2020', '--layout-2020', default=None, action='store_true'),
-            CommandArgument('--with-layout-2013', '--layout-2013', default=None, action='store_true'),
-            CommandArgument('--without-wgl', default=None, action='store_true'),
+            CommandArgument(
+                '--with-layout-2020', '--layout-2020',
+                group="Feature Selection", default=None, action='store_true'),
+            CommandArgument(
+                '--with-layout-2013', '--layout-2013', group="Feature Selection", default=None, action='store_true'),
+            CommandArgument('--without-wgl', group="Feature Selection", default=None, action='store_true'),
         ]
 
+        def configuration_decorator(self, *args, **kwargs):
+            self.configure_cross_compilation(
+                kwargs['target'], kwargs['android'],
+                kwargs['uwp'], kwargs['win_arm64'])
+
+            self.features = kwargs.get("features", None) or []
+            self.configure_media_stack(kwargs['media_stack'])
+            original_function(self, *args, **kwargs)
+
+        decorators.reverse()
+        decorated_function = configuration_decorator
         for decorator in decorators:
             decorated_function = decorator(decorated_function)
         return decorated_function
 
-    def pick_target_triple(self, target, android):
+    def configure_cross_compilation(
+            self,
+            cross_compile_target: Optional[str],
+            android: Optional[str],
+            uwp: Optional[str],
+            win_arm64: Optional[str]):
+        # Force the UWP-enabled target if the convenience UWP flags are passed.
+        if uwp and not cross_compile_target:
+            if win_arm64:
+                cross_compile_target = 'aarch64-uwp-windows-msvc'
+            else:
+                cross_compile_target = 'x86_64-uwp-windows-msvc'
+
         if android is None:
             android = self.config["build"]["android"]
-        if target and android:
-            assert self.handle_android_target(target)
-        if android and not target:
-            target = self.config["android"]["target"]
-        if target and not android:
-            android = self.handle_android_target(target)
-        return target, android
-
-    # A guess about which platforms should use the gstreamer media stack
-    def pick_media_stack(self, media_stack, target):
+        if android:
+            if not cross_compile_target:
+                cross_compile_target = self.config["android"]["target"]
+            assert cross_compile_target
+            assert self.setup_configuration_for_android_target(cross_compile_target)
+        elif cross_compile_target:
+            # If a target was specified, it might also be an android target,
+            # so set up the configuration in that case.
+            self.setup_configuration_for_android_target(cross_compile_target)
+
+        self.cross_compile_target = cross_compile_target
+        self.is_uwp_build = uwp or (cross_compile_target and "uwp" in cross_compile_target)
+        self.is_android_build = (cross_compile_target and "android" in cross_compile_target)
+
+        if self.cross_compile_target:
+            print(f"Targeting '{self.cross_compile_target}' for cross-compilation")
+
+    def configure_media_stack(self, media_stack: Optional[str]):
+        """Determine what media stack to use based on the value of the build target
+           platform and the value of the '--media-stack' command-line argument.
+           The chosen media stack is written into the `features` instance variable."""
         if not media_stack:
             if self.config["build"]["media-stack"] != "auto":
                 media_stack = self.config["build"]["media-stack"]
+                assert media_stack
             elif (
-                not target
-                or ("armv7" in target and "android" in target)
-                or "x86_64" in target
-                or "uwp" in target
+                not self.cross_compile_target
+                or ("armv7" in self.cross_compile_target and self.is_android_build)
+                or "x86_64" in self.cross_compile_target
+                or "uwp" in self.cross_compile_target
             ):
                 media_stack = "gstreamer"
             else:
                 media_stack = "dummy"
-        return ["media-" + media_stack]
+        self.features += ["media-" + media_stack]
 
     def run_cargo_build_like_command(
         self, command, cargo_args,
         env=None, verbose=False,
-        target=None, android=False, libsimpleservo=False,
-        features=None, debug_mozjs=False, with_debug_assertions=False,
+        libsimpleservo=False,
+        debug_mozjs=False, with_debug_assertions=False,
         with_frame_pointer=False, without_wgl=False,
         with_layout_2020=False, with_layout_2013=False,
-        uwp=False, media_stack=None,
+        **_kwargs
     ):
         env = env or self.build_env()
-        target, android = self.pick_target_triple(target, android)
 
         args = []
         if "--manifest-path" not in cargo_args:
-            if libsimpleservo or android:
-                if android:
+            if libsimpleservo or self.is_android_build:
+                if self.is_android_build:
                     api = "jniapi"
                 else:
                     api = "capi"
@@ -819,19 +872,17 @@ class CommandBase(object):
                 "--manifest-path",
                 path.join(self.context.topdir, "ports", port, "Cargo.toml"),
             ]
-        if target:
-            args += ["--target", target]
-
-        if features is None:  # If we're passed a list, mutate it even if it's empty
-            features = []
+        if self.cross_compile_target:
+            args += ["--target", self.cross_compile_target]
 
+        features = list(self.features)
         if "-p" not in cargo_args:  # We're building specific package, that may not have features
             if self.config["build"]["debug-mozjs"] or debug_mozjs:
                 features.append("debugmozjs")
 
             features.append("native-bluetooth")
 
-            if uwp:
+            if self.is_uwp_build:
                 features.append("no-wgl")
                 features.append("uwp")
             else:
@@ -856,7 +907,7 @@ class CommandBase(object):
         assert "--features" not in cargo_args
         args += ["--features", " ".join(features)]
 
-        if target and 'uwp' in target:
+        if self.is_uwp_build:
             cargo_args += ["-Z", "build-std"]
         return self.call_rustup_run(["cargo", command] + args + cargo_args, env=env, verbose=verbose)
 
@@ -880,7 +931,10 @@ class CommandBase(object):
                 return sdk_adb
         return "emulator"
 
-    def handle_android_target(self, target):
+    def setup_configuration_for_android_target(self, target: str):
+        """If cross-compilation targets Android, configure the Android
+           build by writing the appropriate toolchain configuration values
+           into the stored configuration."""
         if target == "armv7-linux-androideabi":
             self.config["android"]["platform"] = "android-21"
             self.config["android"]["target"] = target
@@ -908,13 +962,12 @@ class CommandBase(object):
             return True
         return False
 
-    def ensure_bootstrapped(self, target=None, rustup_components=None):
+    def ensure_bootstrapped(self, rustup_components=None):
         if self.context.bootstrapped:
             return
 
-        target_platform = target or servo.platform.host_triple()
-
         # Always check if all needed MSVC dependencies are installed
+        target_platform = self.cross_compile_target or servo.platform.host_triple()
         if "msvc" in target_platform:
             Registrar.dispatch("bootstrap", context=self.context)
 
@@ -943,10 +996,13 @@ class CommandBase(object):
                 if component.encode("utf-8") not in installed:
                     check_call(["rustup", "component", "add", "--toolchain", toolchain, component])
 
-            if target and "uwp" not in target and target.encode("utf-8") not in check_output(
-                ["rustup", "target", "list", "--installed", "--toolchain", toolchain]
-            ):
-                check_call(["rustup", "target", "add", "--toolchain", toolchain, target])
+            needs_toolchain_install = self.cross_compile_target \
+                and not self.is_uwp_build \
+                and self.cross_compile_target.encode("utf-8") not in check_output(
+                    ["rustup", "target", "list", "--installed", "--toolchain", toolchain]
+                )
+            if needs_toolchain_install:
+                check_call(["rustup", "target", "add", "--toolchain", toolchain, self.cross_compile_target])
 
         self.context.bootstrapped = True
 
diff --git a/python/servo/devenv_commands.py b/python/servo/devenv_commands.py
index 77b95ba743f..065afed2a45 100644
--- a/python/servo/devenv_commands.py
+++ b/python/servo/devenv_commands.py
@@ -35,21 +35,13 @@ class MachCommands(CommandBase):
         'params', default=None, nargs='...',
         help="Command-line arguments to be passed through to cargo check")
     @CommandBase.build_like_command_arguments
-    def check(self, params, features=[], media_stack=None, target=None,
-              android=False, **kwargs):
+    def check(self, params, **kwargs):
         if not params:
             params = []
 
-        features = features or []
-
-        target, android = self.pick_target_triple(target, android)
-
-        features += self.pick_media_stack(media_stack, target)
-
-        self.ensure_bootstrapped(target=target)
+        self.ensure_bootstrapped()
         self.ensure_clobbered()
-
-        status = self.run_cargo_build_like_command("check", params, features=features, **kwargs)
+        status = self.run_cargo_build_like_command("check", params, **kwargs)
         if status == 0:
             print('Finished checking, binary NOT updated. Consider ./mach build before ./mach run')
 
@@ -128,21 +120,13 @@ class MachCommands(CommandBase):
         'params', default=None, nargs='...',
         help="Command-line arguments to be passed through to cargo-fix")
     @CommandBase.build_like_command_arguments
-    def cargo_fix(self, params, features=[], media_stack=None, target=None,
-                  android=False, **kwargs):
+    def cargo_fix(self, params, **kwargs):
         if not params:
             params = []
 
-        features = features or []
-
-        target, android = self.pick_target_triple(target, android)
-
-        features += self.pick_media_stack(media_stack, target)
-
-        self.ensure_bootstrapped(target=target)
+        self.ensure_bootstrapped()
         self.ensure_clobbered()
-
-        return self.run_cargo_build_like_command("fix", params, features=features, **kwargs)
+        return self.run_cargo_build_like_command("fix", params, **kwargs)
 
     @Command('cargo-clippy',
              description='Run "cargo clippy"',
@@ -151,21 +135,13 @@ class MachCommands(CommandBase):
         'params', default=None, nargs='...',
         help="Command-line arguments to be passed through to cargo-clippy")
     @CommandBase.build_like_command_arguments
-    def cargo_clippy(self, params, features=[], media_stack=None, target=None,
-                     android=False, **kwargs):
+    def cargo_clippy(self, params, **kwargs):
         if not params:
             params = []
 
-        features = features or []
-
-        target, android = self.pick_target_triple(target, android)
-
-        features += self.pick_media_stack(media_stack, target)
-
-        self.ensure_bootstrapped(target=target)
+        self.ensure_bootstrapped()
         self.ensure_clobbered()
-
-        return self.run_cargo_build_like_command("clippy", params, features=features, **kwargs)
+        return self.run_cargo_build_like_command("clippy", params, **kwargs)
 
     @Command('grep',
              description='`git grep` for selected directories.',
@@ -224,9 +200,11 @@ class MachCommands(CommandBase):
         if not path.isfile(logfile):
             print(logfile + " doesn't exist")
             return -1
-        env = self.build_env(target=target)
+
+        self.cross_compile_target = target
+        env = self.build_env()
         ndk_stack = path.join(env["ANDROID_NDK"], "ndk-stack")
-        self.handle_android_target(target)
+        self.setup_configuration_for_android_target(target)
         sym_path = path.join(
             "target",
             target,
@@ -244,8 +222,9 @@ class MachCommands(CommandBase):
     @CommandArgument('--target', action='store', default="armv7-linux-androideabi",
                      help="Build target")
     def ndk_gdb(self, release, target):
-        env = self.build_env(target)
-        self.handle_android_target(target)
+        self.cross_compile_target = target
+        self.setup_configuration_for_android_target(target)
+        env = self.build_env()
         ndk_gdb = path.join(env["ANDROID_NDK"], "ndk-gdb")
         adb_path = path.join(env["ANDROID_SDK"], "platform-tools", "adb")
         sym_paths = [
diff --git a/python/servo/package_commands.py b/python/servo/package_commands.py
index cfd81e7d647..13ef267f6c2 100644
--- a/python/servo/package_commands.py
+++ b/python/servo/package_commands.py
@@ -147,19 +147,20 @@ class PackageCommands(CommandBase):
                      action='append',
                      help='Create an APPX package')
     @CommandArgument('--ms-app-store', default=None, action='store_true')
-    def package(self, release=False, dev=False, android=None, debug=False,
-                debugger=None, target=None, flavor=None, maven=False, uwp=None, ms_app_store=False):
+    def package(self, release=False, dev=False, android=None, target=None,
+                flavor=None, maven=False, uwp=None, ms_app_store=False):
         if android is None:
             android = self.config["build"]["android"]
         if target and android:
             print("Please specify either --target or --android.")
             sys.exit(1)
         if not android:
-            android = self.handle_android_target(target)
+            android = self.setup_configuration_for_android_target(target)
         else:
             target = self.config["android"]["target"]
 
-        env = self.build_env(target=target)
+        self.cross_compile_target = target
+        env = self.build_env()
         binary_path = self.get_binary_path(
             release, dev, target=target, android=android,
             simpleservo=uwp is not None
@@ -423,9 +424,10 @@ class PackageCommands(CommandBase):
             print("Please specify either --target or --android.")
             sys.exit(1)
         if not android:
-            android = self.handle_android_target(target)
+            android = self.setup_configuration_for_android_target(target)
+        self.cross_compile_target = target
 
-        env = self.build_env(target=target)
+        env = self.build_env()
         try:
             binary_path = self.get_binary_path(release, dev, android=android)
         except BuildNotFound:
diff --git a/python/servo/post_build_commands.py b/python/servo/post_build_commands.py
index 07f104630a1..afe8b12dfd4 100644
--- a/python/servo/post_build_commands.py
+++ b/python/servo/post_build_commands.py
@@ -242,8 +242,7 @@ class PostBuildCommands(CommandBase):
         'params', nargs='...',
         help="Command-line arguments to be passed through to cargo doc")
     @CommandBase.build_like_command_arguments
-    def doc(self, params, features, target=None, android=False,
-            media_stack=None, **kwargs):
+    def doc(self, params, **kwargs):
         self.ensure_bootstrapped(rustup_components=["rust-docs"])
         rustc_path = check_output(
             ["rustup" + BIN_SUFFIX, "which", "--toolchain", self.rust_toolchain(), "rustc"]
@@ -271,15 +270,8 @@ class PostBuildCommands(CommandBase):
                     else:
                         copy2(full_name, destination)
 
-        features = features or []
-
-        target, android = self.pick_target_triple(target, android)
-
-        features += self.pick_media_stack(media_stack, target)
-
-        env = self.build_env(target=target, is_build=True, features=features)
-
-        returncode = self.run_cargo_build_like_command("doc", params, features=features, env=env, **kwargs)
+        env = self.build_env(is_build=True)
+        returncode = self.run_cargo_build_like_command("doc", params, env=env, **kwargs)
         if returncode:
             return returncode
 
diff --git a/python/servo/testing_commands.py b/python/servo/testing_commands.py
index f632ce30a1c..ee630be47aa 100644
--- a/python/servo/testing_commands.py
+++ b/python/servo/testing_commands.py
@@ -470,10 +470,11 @@ class MachCommands(CommandBase):
         avd = "servo-x86"
         target = "i686-linux-android"
         print("Assuming --target " + target)
+        self.cross_compile_target = target
 
-        env = self.build_env(target=target)
+        env = self.build_env()
         os.environ["PATH"] = env["PATH"]
-        assert self.handle_android_target(target)
+        assert self.setup_configuration_for_android_target(target)
         apk = self.get_apk_path(release)
 
         py = path.join(self.context.topdir, "etc", "run_in_headless_android_emulator.py")