Set the meson command to use when we know what it is

Instead of using fragile guessing to figure out how to invoke meson,
set the value when meson is run. Also rework how we pass of
meson_script_launcher to regenchecker.py -- it wasn't even being used

With this change, we only need to guess the meson path when running
the tests, and in that case:

1. If MESON_EXE is set in the env, we know how to run meson
   for project tests.
2. MESON_EXE is not set, which means we run the configure in-process
   for project tests and need to guess what meson to run, so either
   - meson.py is found next to run_tests.py, or
   - meson, meson.py, or meson.exe is in PATH

Otherwise, you can invoke meson in the following ways:

1. meson is installed, and mesonbuild is available in PYTHONPATH:
   - meson, meson.py, meson.exe from PATH
   - python3 -m mesonbuild.mesonmain
   - python3 /path/to/meson.py
   - meson is a shell wrapper to meson.real
2. meson is not installed, and is run from git:
   - Absolute path to meson.py
   - Relative path to meson.py
   - Symlink to meson.py

All these are tested in test_meson_commands.py, except meson.exe since
that involves building the meson msi and installing it.

4 files changed, 33 insertions, 61 deletions

diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py
index fc837d6..4bcffbd 100644
--- a/mesonbuild/environment.py
+++ b/mesonbuild/environment.py
@@ -262,10 +262,9 @@ class Environment:
     private_dir = 'meson-private'
     log_dir = 'meson-logs'
 
-    def __init__(self, source_dir, build_dir, main_script_launcher, options, original_cmd_line_args):
+    def __init__(self, source_dir, build_dir, options, original_cmd_line_args):
         self.source_dir = source_dir
         self.build_dir = build_dir
-        self.meson_script_launcher = main_script_launcher
         self.scratch_dir = os.path.join(build_dir, Environment.private_dir)
         self.log_dir = os.path.join(build_dir, Environment.log_dir)
         os.makedirs(self.scratch_dir, exist_ok=True)
@@ -278,7 +277,8 @@ class Environment:
             # re-initialized with project options by the interpreter during
             # build file parsing.
             self.coredata = coredata.CoreData(options)
-            self.coredata.meson_script_launcher = self.meson_script_launcher
+            # Used by the regenchecker script, which runs meson
+            self.coredata.meson_command = mesonlib.meson_command
             self.first_invocation = True
         if self.coredata.cross_file:
             self.cross_info = CrossBuildInfo(self.coredata.cross_file)
diff --git a/mesonbuild/mesonlib.py b/mesonbuild/mesonlib.py
index 6a38479..5305ecb 100644
--- a/mesonbuild/mesonlib.py
+++ b/mesonbuild/mesonlib.py
@@ -38,58 +38,12 @@ except Exception:
 
 from glob import glob
 
-def detect_meson_py_location():
-    c = sys.argv[0]
-    c_dir, c_fname = os.path.split(c)
-
-    # get the absolute path to the <mesontool> folder
-    m_dir = None
-    if os.path.isabs(c):
-        # $ /foo/<mesontool>.py <args>
-        m_dir = c_dir
-    elif c_dir == '':
-        # $ <mesontool> <args> (gets run from /usr/bin/<mesontool>)
-        in_path_exe = shutil.which(c_fname)
-        if in_path_exe:
-            if not os.path.isabs(in_path_exe):
-                m_dir = os.getcwd()
-                c_fname = in_path_exe
-            else:
-                m_dir, c_fname = os.path.split(in_path_exe)
-    else:
-        m_dir = os.path.abspath(c_dir)
-
-    # find meson in m_dir
-    if m_dir is not None:
-        for fname in ['meson', 'meson.py']:
-            m_path = os.path.join(m_dir, fname)
-            if os.path.exists(m_path):
-                return m_path
-
-    # No meson found, which means that either:
-    # a) meson is not installed
-    # b) meson is installed to a non-standard location
-    # c) the script that invoked mesonlib is not the one of meson tools (e.g. run_unittests.py)
-    fname = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', 'meson.py'))
-    if os.path.exists(fname):
-        return fname
-    # If meson is still not found, we might be imported by out-of-source tests
-    # https://github.com/mesonbuild/meson/issues/3015
-    exe = shutil.which('meson')
-    if exe is None:
-        exe = shutil.which('meson.py')
-    if exe is not None:
-        return exe
-    # Give up.
-    raise RuntimeError('Could not determine how to run Meson. Please file a bug with details.')
-
 if os.path.basename(sys.executable) == 'meson.exe':
     # In Windows and using the MSI installed executable.
-    meson_command = [sys.executable]
     python_command = [sys.executable, 'runpython']
 else:
     python_command = [sys.executable]
-    meson_command = python_command + [detect_meson_py_location()]
+meson_command = None
 
 def is_ascii_string(astring):
     try:
diff --git a/mesonbuild/mesonmain.py b/mesonbuild/mesonmain.py
index 4a977a1..c03ef9b 100644
--- a/mesonbuild/mesonmain.py
+++ b/mesonbuild/mesonmain.py
@@ -73,9 +73,8 @@ def filter_builtin_options(args, original_args):
 
 class MesonApp:
 
-    def __init__(self, dir1, dir2, script_launcher, handshake, options, original_cmd_line_args):
+    def __init__(self, dir1, dir2, handshake, options, original_cmd_line_args):
         (self.source_dir, self.build_dir) = self.validate_dirs(dir1, dir2, handshake)
-        self.meson_script_launcher = script_launcher
         self.options = options
         self.original_cmd_line_args = original_cmd_line_args
 
@@ -129,7 +128,7 @@ class MesonApp:
             env.coredata.pkgconf_envvar = curvar
 
     def generate(self):
-        env = environment.Environment(self.source_dir, self.build_dir, self.meson_script_launcher, self.options, self.original_cmd_line_args)
+        env = environment.Environment(self.source_dir, self.build_dir, self.options, self.original_cmd_line_args)
         mlog.initialize(env.get_log_dir())
         with mesonlib.BuildDirLock(self.build_dir):
             self._generate(env)
@@ -269,12 +268,27 @@ def run_script_command(args):
         raise MesonException('Unknown internal command {}.'.format(cmdname))
     return cmdfunc(cmdargs)
 
-def run(original_args, mainfile=None):
+def set_meson_command(mainfile):
+    if mainfile.endswith('.exe'):
+        mesonlib.meson_command = [mainfile]
+    elif os.path.isabs(mainfile) and mainfile.endswith('mesonmain.py'):
+        # Can't actually run meson with an absolute path to mesonmain.py, it must be run as -m mesonbuild.mesonmain
+        mesonlib.meson_command = mesonlib.python_command + ['-m', 'mesonbuild.mesonmain']
+    else:
+        mesonlib.meson_command = mesonlib.python_command + [mainfile]
+    # This won't go into the log file because it's not initialized yet, and we
+    # need this value for unit tests.
+    if 'MESON_COMMAND_TESTS' in os.environ:
+        mlog.log('meson_command is {!r}'.format(mesonlib.meson_command))
+
+def run(original_args, mainfile):
     if sys.version_info < (3, 5):
         print('Meson works correctly only with python 3.5+.')
         print('You have python %s.' % sys.version)
         print('Please update your environment')
         return 1
+    # Set the meson command that will be used to run scripts and so on
+    set_meson_command(mainfile)
     args = original_args[:]
     if len(args) > 0:
         # First check if we want to run a subcommand.
@@ -352,9 +366,7 @@ def run(original_args, mainfile=None):
         else:
             dir2 = '.'
     try:
-        if mainfile is None:
-            raise AssertionError('I iz broken. Sorry.')
-        app = MesonApp(dir1, dir2, mainfile, handshake, options, original_args)
+        app = MesonApp(dir1, dir2, handshake, options, original_args)
     except Exception as e:
         # Log directory does not exist, so just print
         # to stdout.
@@ -382,3 +394,11 @@ def run(original_args, mainfile=None):
         mlog.shutdown()
 
     return 0
+
+def main():
+    # Always resolve the command path so Ninja can find it for regen, tests, etc.
+    launcher = os.path.realpath(sys.argv[0])
+    return run(sys.argv[1:], launcher)
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/mesonbuild/scripts/regen_checker.py b/mesonbuild/scripts/regen_checker.py
index a9b00c7..80d9242 100644
--- a/mesonbuild/scripts/regen_checker.py
+++ b/mesonbuild/scripts/regen_checker.py
@@ -14,7 +14,6 @@
 
 import sys, os
 import pickle, subprocess
-from mesonbuild.mesonlib import meson_command
 
 # This could also be used for XCode.
 
@@ -32,7 +31,7 @@ def need_regen(regeninfo, regen_timestamp):
     Vs2010Backend.touch_regen_timestamp(regeninfo.build_dir)
     return False
 
-def regen(regeninfo, mesonscript, backend):
+def regen(regeninfo, meson_command, backend):
     cmd = meson_command + ['--internal',
                            'regenerate',
                            regeninfo.build_dir,
@@ -48,11 +47,10 @@ def run(args):
         regeninfo = pickle.load(f)
     with open(coredata, 'rb') as f:
         coredata = pickle.load(f)
-    mesonscript = coredata.meson_script_launcher
     backend = coredata.get_builtin_option('backend')
     regen_timestamp = os.stat(dumpfile).st_mtime
     if need_regen(regeninfo, regen_timestamp):
-        regen(regeninfo, mesonscript, backend)
+        regen(regeninfo, coredata.meson_command, backend)
     sys.exit(0)
 
 if __name__ == '__main__':