Rework experimental msvc_query_version_toolset function.

Changes:
* Add context manager functions to temporary change the policy for msvc not found and msvc script errors within a context block.
* Change msvc_query_version_toolset function behavior: raise exceptions if not found and for argument validation errors; otherwise return msvc version and toolset version.
* Additional logging of exception messages .
* Update tests for 14.3X/14.4X toolsets for VS 2022.

Author: jcbrill

SCons/Tool/MSCommon/MSVC/Policy.py

@@ -38,6 +38,10 @@
     namedtuple,
 )
 
+from contextlib import (
+    contextmanager,
+)
+
 import SCons.Warnings
 
 from ..common import (
@@ -215,6 +219,18 @@ def msvc_notfound_handler(env, msg):
     else:
         SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, msg)
 
+@contextmanager
+def msvc_notfound_policy_contextmanager(MSVC_NOTFOUND_POLICY=None):
+    """ Temporarily change the MSVC not found policy within a context.
+
+    Args:
+        MSVC_NOTFOUND_POLICY:
+           string representing the policy behavior
+           when MSVC is not found or None
+    """
+    prev_policy = msvc_set_notfound_policy(MSVC_NOTFOUND_POLICY)
+    yield
+    msvc_set_notfound_policy(prev_policy)
 
 def _msvc_scripterror_policy_lookup(symbol):
 
@@ -299,3 +315,16 @@ def msvc_scripterror_handler(env, msg):
     else:
         SCons.Warnings.warn(MSVCScriptExecutionWarning, msg)
 
+@contextmanager
+def msvc_scripterror_policy_contextmanager(MSVC_SCRIPTERROR_POLICY=None):
+    """ Temporarily change the msvc batch execution errors policy within a context.
+
+    Args:
+        MSVC_SCRIPTERROR_POLICY:
+           string representing the policy behavior
+           when msvc batch file execution errors are detected or None
+    """
+    prev_policy = msvc_set_scripterror_policy(MSVC_SCRIPTERROR_POLICY)
+    yield
+    msvc_set_scripterror_policy(prev_policy)
+

SCons/Tool/MSCommon/__init__.py

@@ -63,6 +63,8 @@
     msvc_get_notfound_policy,
     msvc_set_scripterror_policy,
     msvc_get_scripterror_policy,
+    msvc_notfound_policy_contextmanager,
+    msvc_scripterror_policy_contextmanager,
 )
 
 from .MSVC.Exceptions import (  # noqa: F401

SCons/Tool/MSCommon/vc.py

@@ -2572,28 +2572,24 @@ def msvc_toolset_versions_spectre(msvc_version=None, vswhere_exe=None):
 
 def msvc_query_version_toolset(version=None, prefer_newest: bool=True, vswhere_exe=None):
     """
-    Returns an msvc version and a toolset version given a version
+    Return an msvc version and a toolset version given a version
     specification.
 
     This is an EXPERIMENTAL proxy for using a toolset version to perform
     msvc instance selection.  This function will be removed when
     toolset version is taken into account during msvc instance selection.
 
-    Search for an installed Visual Studio instance that supports the
-    specified version.
+    This function searches for an installed Visual Studio instance that
+    contains the requested version. A component suffix (e.g., Exp) is not
+    supported for toolset version specifications (e.g., 14.39).
 
-    When the specified version contains a component suffix (e.g., Exp),
-    the msvc version is returned and the toolset version is None. No
-    search if performed.
+    An MSVCArgumentError is raised when argument validation fails. An
+    MSVCToolsetVersionNotFound exception is raised when the requested
+    version is not found.
 
-    When the specified version does not contain a component suffix, the
-    version is treated as a toolset version specification. A search is
-    performed for the first msvc instance that contains the toolset
-    version.
-
-    Only Visual Studio 2017 and later support toolset arguments.  For
-    Visual Studio 2015 and earlier, the msvc version is returned and
-    the toolset version is None.
+    For Visual Studio 2015 and earlier, the msvc version is returned and
+    the toolset version is None.  For Visual Studio 2017 and later, the
+    selected toolset version is returned.
 
     Args:
 
@@ -2623,106 +2619,132 @@ def msvc_query_version_toolset(version=None, prefer_newest: bool=True, vswhere_e
     msvc_version = None
     msvc_toolset_version = None
 
-    if not version:
-        version = msvc_default_version()
+    with MSVC.Policy.msvc_notfound_policy_contextmanager('suppress'):
 
-    if not version:
-        debug('no msvc versions detected')
-        return msvc_version, msvc_toolset_version
+        _VSWhereExecutable.vswhere_freeze_executable(vswhere_exe)
 
-    version_def = MSVC.Util.msvc_extended_version_components(version)
+        vcs = get_installed_vcs()
 
-    if not version_def:
-        msg = f'Unsupported msvc version {version!r}'
-        raise MSVCArgumentError(msg)
+        if not version:
+            version = msvc_default_version()
 
-    if version_def.msvc_suffix:
-        if version_def.msvc_verstr != version_def.msvc_toolset_version:
-            # toolset version with component suffix
-            msg = f'Unsupported toolset version {version!r}'
-            raise MSVCArgumentError(msg)
+        if not version:
+            msg = f'No versions of the MSVC compiler were found'
+            debug(f'MSVCToolsetVersionNotFound: {msg}')
+            raise MSVCToolsetVersionNotFound(msg)
 
-    if version_def.msvc_vernum > 14.0:
-        # VS2017 and later
-        force_toolset_msvc_version = False
-    else:
-        # VS2015 and earlier
-        force_toolset_msvc_version = True
-        extended_version = version_def.msvc_verstr + '0.00000'
-        if not extended_version.startswith(version_def.msvc_toolset_version):
-            # toolset not equivalent to msvc version
-            msg = 'Unsupported toolset version {} (expected {})'.format(
-                repr(version), repr(extended_version)
-            )
+        version_def = MSVC.Util.msvc_extended_version_components(version)
+
+        if not version_def:
+            msg = f'Unsupported MSVC version {version!r}'
+            debug(f'MSVCArgumentError: {msg}')
             raise MSVCArgumentError(msg)
 
-    msvc_version = version_def.msvc_version
+        msvc_version = version_def.msvc_version
 
-    if msvc_version not in MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP:
-        # VS2013 and earlier
-        debug(
-            'ignore: msvc_version=%s, msvc_toolset_version=%s',
-            repr(msvc_version), repr(msvc_toolset_version)
-        )
-        return msvc_version, msvc_toolset_version
+        if version_def.msvc_suffix:
 
-    if force_toolset_msvc_version:
-        query_msvc_toolset_version = version_def.msvc_verstr
-    else:
-        query_msvc_toolset_version = version_def.msvc_toolset_version
+            if version_def.msvc_verstr != version_def.msvc_toolset_version:
+                # toolset version with component suffix
+                msg = f'Unsupported MSVC toolset version {version!r}'
+                debug(f'MSVCArgumentError: {msg}')
+                raise MSVCArgumentError(msg)
 
-    if prefer_newest:
-        query_version_list = MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP[msvc_version]
-    else:
-        query_version_list = MSVC.Config.MSVC_VERSION_TOOLSET_DEFAULTS_MAP[msvc_version] + \
-                             MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP[msvc_version]
+            if msvc_version not in vcs:
+                msg = f'MSVC version {msvc_version!r} not found'
+                debug(f'MSVCToolsetVersionNotFound: {msg}')
+                raise MSVCToolsetVersionNotFound(msg)
 
-    seen_msvc_version = set()
-    for query_msvc_version in query_version_list:
+            if msvc_version not in MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP:
+                debug(
+                    'suffix: msvc_version=%s, msvc_toolset_version=%s',
+                    repr(msvc_version), repr(msvc_toolset_version)
+                )
+                return msvc_version, msvc_toolset_version
 
-        if query_msvc_version in seen_msvc_version:
-            continue
-        seen_msvc_version.add(query_msvc_version)
+        if version_def.msvc_vernum > 14.0:
+            # VS2017 and later
+            force_toolset_msvc_version = False
+        else:
+            # VS2015 and earlier
+            force_toolset_msvc_version = True
+            extended_version = version_def.msvc_verstr + '0.00000'
+            if not extended_version.startswith(version_def.msvc_toolset_version):
+                # toolset not equivalent to msvc version
+                msg = 'Unsupported MSVC toolset version {} (expected {})'.format(
+                    repr(version), repr(extended_version)
+                )
+                debug(f'MSVCArgumentError: {msg}')
+                raise MSVCArgumentError(msg)
 
-        vc_dir = _find_vc_pdir(query_msvc_version, vswhere_exe)
-        if not vc_dir:
-            continue
+        if msvc_version not in MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP:
+
+            # VS2013 and earlier
+
+            if msvc_version not in vcs:
+                msg = f'MSVC version {version!r} not found'
+                debug(f'MSVCToolsetVersionNotFound: {msg}')
+                raise MSVCToolsetVersionNotFound(msg)
 
-        if query_msvc_version.startswith('14.0'):
-            # VS2015 does not support toolset version argument
-            msvc_toolset_version = None
             debug(
-                'found: msvc_version=%s, msvc_toolset_version=%s',
-                repr(query_msvc_version), repr(msvc_toolset_version)
+                'earlier: msvc_version=%s, msvc_toolset_version=%s',
+                repr(msvc_version), repr(msvc_toolset_version)
             )
-            return query_msvc_version, msvc_toolset_version
+            return msvc_version, msvc_toolset_version
 
-        try:
-            toolset_vcvars = MSVC.ScriptArguments._msvc_toolset_internal(query_msvc_version, query_msvc_toolset_version, vc_dir)
-            if toolset_vcvars:
-                msvc_toolset_version = toolset_vcvars
+        if force_toolset_msvc_version:
+            query_msvc_toolset_version = version_def.msvc_verstr
+        else:
+            query_msvc_toolset_version = version_def.msvc_toolset_version
+
+        if prefer_newest:
+            query_version_list = MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP[msvc_version]
+        else:
+            query_version_list = MSVC.Config.MSVC_VERSION_TOOLSET_DEFAULTS_MAP[msvc_version] + \
+                                 MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP[msvc_version]
+
+        seen_msvc_version = set()
+        for query_msvc_version in query_version_list:
+
+            if query_msvc_version in seen_msvc_version:
+                continue
+            seen_msvc_version.add(query_msvc_version)
+
+            vc_dir = _find_vc_pdir(query_msvc_version, vswhere_exe)
+            if not vc_dir:
+                continue
+
+            if query_msvc_version.startswith('14.0'):
+                # VS2015 does not support toolset version argument
+                msvc_toolset_version = None
                 debug(
                     'found: msvc_version=%s, msvc_toolset_version=%s',
                     repr(query_msvc_version), repr(msvc_toolset_version)
                 )
                 return query_msvc_version, msvc_toolset_version
 
-        except MSVCToolsetVersionNotFound:
-            pass
+            try:
+                toolset_vcvars = MSVC.ScriptArguments._msvc_toolset_internal(query_msvc_version, query_msvc_toolset_version, vc_dir)
+                if toolset_vcvars:
+                    msvc_toolset_version = toolset_vcvars
+                    debug(
+                        'found: msvc_version=%s, msvc_toolset_version=%s',
+                        repr(query_msvc_version), repr(msvc_toolset_version)
+                    )
+                    return query_msvc_version, msvc_toolset_version
 
-    msvc_toolset_version = query_msvc_toolset_version
+            except MSVCToolsetVersionNotFound:
+                pass
+
+        msvc_toolset_version = query_msvc_toolset_version
 
     debug(
         'not found: msvc_version=%s, msvc_toolset_version=%s',
         repr(msvc_version), repr(msvc_toolset_version)
     )
 
-    if version_def.msvc_verstr == msvc_toolset_version:
-        msg = f'MSVC version {version!r} was not found'
-        MSVC.Policy.msvc_notfound_handler(None, msg)
-        return msvc_version, msvc_toolset_version
-
     msg = f'MSVC toolset version {version!r} not found'
+    debug(f'MSVCToolsetVersionNotFound: {msg}')
     raise MSVCToolsetVersionNotFound(msg)
 
 

SCons/Tool/MSCommon/vcTests.py

@@ -234,8 +234,18 @@ class Data:
         HAVE_MSVC = False
         DEFAULT_VERSION_DEF = None
 
+    INSTALLED_VCS = MSCommon.vc.get_installed_vcs()
     INSTALLED_VCS_COMPONENTS = MSCommon.vc.get_installed_vcs_components()
 
+    @classmethod
+    def query_version_list(cls, vcver):
+        # VS 2022 (14.3) can have either/both toolset versions 14.3X and 14.4X
+        if vcver == '14.3' or (vcver is None and cls.DEFAULT_VERSION == '14.3'):
+            vcver_list = ['14.4', '14.3']
+        else:
+            vcver_list = [vcver]
+        return vcver_list
+
     @classmethod
     def _msvc_toolset_notfound_list(cls, toolset_seen, toolset_list):
         new_toolset_list = []
@@ -454,15 +464,26 @@ class MsvcQueryVersionToolsetTests(unittest.TestCase):
 
     def run_valid_default_msvc(self, have_msvc) -> None:
         for prefer_newest in (True, False):
-            msvc_version, msvc_toolset_version = MSCommon.vc.msvc_query_version_toolset(
-                version=None, prefer_newest=prefer_newest
-            )
-            expect = (have_msvc and msvc_version) or (not have_msvc and not msvc_version)
-            self.assertTrue(expect, "unexpected msvc_version {} for for msvc version {}".format(
+            if not have_msvc:
+                with self.assertRaises(MSCommon.vc.MSVCToolsetVersionNotFound):
+                    msvc_version, msvc_toolset_version = MSCommon.vc.msvc_query_version_toolset(
+                        version=None, prefer_newest=prefer_newest
+                    )
+                continue
+            msvc_version = msvc_toolset_version = None
+            for vcver in Data.query_version_list(None):
+                try:
+                    msvc_version, msvc_toolset_version = MSCommon.vc.msvc_query_version_toolset(
+                        version=vcver, prefer_newest=prefer_newest
+                    )
+                    break
+                except MSCommon.vc.MSVCToolsetVersionNotFound:
+                    pass
+            self.assertTrue(msvc_version, "unexpected msvc_version {} for for msvc version {}".format(
                 repr(msvc_version), repr(None)
             ))
             version_def = MSCommon.msvc_version_components(msvc_version)
-            if have_msvc and version_def.msvc_vernum > 14.0:
+            if version_def.msvc_vernum > 14.0:
                 # VS2017 and later for toolset version
                 self.assertTrue(msvc_toolset_version, "msvc_toolset_version is undefined for msvc version {}".format(
                     repr(None)
@@ -477,11 +498,24 @@ def test_valid_default_msvc(self) -> None:
 
     def test_valid_vcver(self) -> None:
         for symbol in MSCommon.vc._VCVER:
+            have_msvc = bool(symbol in Data.INSTALLED_VCS)
             version_def = MSCommon.msvc_version_components(symbol)
             for prefer_newest in (True, False):
-                msvc_version, msvc_toolset_version = MSCommon.vc.msvc_query_version_toolset(
-                    version=symbol, prefer_newest=prefer_newest
-                )
+                if not have_msvc:
+                    with self.assertRaises(MSCommon.vc.MSVCToolsetVersionNotFound):
+                        msvc_version, msvc_toolset_version = MSCommon.vc.msvc_query_version_toolset(
+                            version=symbol, prefer_newest=prefer_newest
+                        )
+                    continue
+                msvc_version = msvc_toolset_version = None
+                for vcver in Data.query_version_list(symbol):
+                    try:
+                        msvc_version, msvc_toolset_version = MSCommon.vc.msvc_query_version_toolset(
+                            version=vcver, prefer_newest=prefer_newest
+                        )
+                        break
+                    except:
+                        pass
                 self.assertTrue(msvc_version, "msvc_version is undefined for msvc version {}".format(repr(symbol)))
                 if version_def.msvc_vernum > 14.0:
                     # VS2017 and later for toolset version

test/MSVC/no_msvc.py

@@ -75,8 +75,7 @@ def exists(env):
 
 # test no msvc's and msvc_query_version_toolset() call
 test.file_fixture('no_msvc/no_msvcs_sconstruct_msvc_query_toolset_version.py', 'SConstruct')
-test.run(arguments='-Q -s')
-test.must_contain_all(test.stdout(), 'msvc_version=None, msvc_toolset_version=None')
+test.run(arguments='-Q -s', status=2, stderr=r"^.*MSVCToolsetVersionNotFound.+", match=TestSCons.match_re_dotall)
 
 test.pass_test()