[feat] Introduce exception raised in 'configure' that will propagate only if 'build'

conans/client/conanfile/build.py

@@ -13,6 +13,9 @@ def run_build_method(conanfile, hook_manager, **hook_kwargs):
     with get_env_context_manager(conanfile):
         conanfile.output.highlight("Calling build()")
         with conanfile_exception_formatter(str(conanfile), "build"):
+            configure_exception = getattr(conanfile, '_conan_exception_build', None)
+            if configure_exception:
+                raise configure_exception
             conanfile.build()
 
     hook_manager.execute("post_build", conanfile=conanfile, **hook_kwargs)

conans/client/conanfile/configure.py

@@ -1,4 +1,4 @@
-from conans.errors import (conanfile_exception_formatter)
+from conans.errors import ConanIWontBuild, conanfile_exception_formatter
 from conans.model.conan_file import get_env_context_manager
 from conans.util.conan_v2_mode import conan_v2_behavior
 
@@ -25,7 +25,12 @@ def run_configure_method(conanfile, down_options, down_ref, ref):
                 conanfile.config()
 
         with conanfile_exception_formatter(str(conanfile), "configure"):
-            conanfile.configure()
+            try:
+                conanfile.configure()
+            except ConanIWontBuild as e:
+                # Capture and silence this exception until the 'build' method.
+                # TODO: This has to be the last exception after any ConanInvalidConfiguration
+                conanfile._conan_exception_build = e
 
         conanfile.settings.validate()  # All has to be ok!
         conanfile.options.validate()

conans/errors.py

@@ -148,6 +148,10 @@ class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod):
     pass
 
 
+class ConanIWontBuild(ConanInvalidConfiguration):
+    pass
+
+
 class ConanMigrationError(ConanException):
     pass
 

conans/test/functional/conanfile/i_wont_build_test.py

@@ -0,0 +1,99 @@
+import textwrap
+import unittest
+
+from conans.client.command import ERROR_INVALID_CONFIGURATION
+from conans.test.utils.tools import TestClient
+
+
+class IWontBuildTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.client = TestClient()
+        self.client.save({"conanfile.py": textwrap.dedent("""
+            from conans import ConanFile
+            from conans.errors import ConanIWontBuild
+
+            class MyPkg(ConanFile):
+                settings = "os", "compiler", "build_type", "arch"
+
+                def configure(self):
+                    if self.settings.compiler.version == "10":
+                        raise ConanIWontBuild("won't build with compiler.version=10")
+
+            """)})
+        settings = "-s os=Windows -s compiler='Visual Studio' -s compiler.version={ver}"
+        self.settings_msvc15 = settings.format(ver="15")
+        self.settings_msvc10 = settings.format(ver="10")
+
+    def test_install_method(self):
+        self.client.run("install . %s" % self.settings_msvc15, assert_error=False)
+        self.client.run("install . %s" % self.settings_msvc10, assert_error=False)
+
+    def test_info_method(self):
+        self.client.run("info . %s" % self.settings_msvc15, assert_error=False)
+        self.client.run("info . %s" % self.settings_msvc10, assert_error=False)
+
+    def test_create_method(self):
+        self.client.run("create . name/ver@jgsogo/test %s" % self.settings_msvc15)
+
+        error = self.client.run("create . name/ver@jgsogo/test %s" % self.settings_msvc10,
+                                assert_error=True)
+        self.assertEqual(error, ERROR_INVALID_CONFIGURATION)
+        self.assertIn("ERROR: name/ver@jgsogo/test: Invalid configuration: won't"
+                      " build with compiler.version=10", self.client.out)
+
+    def test_as_requirement(self):
+        self.client.run("create . name/ver@jgsogo/test %s" % self.settings_msvc15)
+        self.client.save({"other/conanfile.py": textwrap.dedent("""
+            from conans import ConanFile
+            from conans.errors import ConanIWontBuild
+
+            class MyPkg(ConanFile):
+                requires = "name/ver@jgsogo/test"
+                settings = "os", "compiler", "build_type", "arch"
+            """)})
+        self.client.run("create other/ other/ver@jgsogo/test %s" % self.settings_msvc15)
+
+        error = self.client.run("create other/ other/ver@ %s --build missing" % self.settings_msvc10,
+                                assert_error=True)
+        self.assertEqual(error, ERROR_INVALID_CONFIGURATION)
+        self.assertIn("ERROR: name/ver@jgsogo/test: Invalid configuration: won't"
+                      " build with compiler.version=10", self.client.out)
+
+
+class IWontBuildCompatiblePackagesTestCase(unittest.TestCase):
+    conanfile = textwrap.dedent("""
+        from conans import ConanFile
+        from conans.errors import ConanIWontBuild
+
+        class Recipe(ConanFile):
+            settings = "os", "compiler", "arch", "build_type"
+
+            def configure(self):
+                if self.settings.compiler.version == "15":
+                    raise ConanIWontBuild("Invalid compiler version: 15")
+
+            def package_id(self):
+                if self.settings.compiler.version == "15":
+                    for version in ("10", "12"):
+                        compatible_pkg = self.info.clone()
+                        compatible_pkg.settings.compiler.version = version
+                        self.compatible_packages.append(compatible_pkg)
+        """)
+
+    def test_compatible_package(self):
+        client = TestClient()
+        client.save({"conanfile.py": self.conanfile})
+
+        # Create binaries for VS 12
+        client.run("create . name/version@ -s compiler='Visual Studio' -s compiler.version=12")
+
+        # It doesn't compile using VS 15
+        error = client.run("install name/version@ -s compiler='Visual Studio'"
+                           " -s compiler.version=15 --build=name", assert_error=True)
+        self.assertEqual(error, ERROR_INVALID_CONFIGURATION)
+        self.assertIn("Invalid compiler version: 15", client.out)
+
+        # ...but it can be consumed
+        client.run("install name/version@ -s compiler='Visual Studio' -s compiler.version=15")
+        self.assertIn("Using compatible package", client.out)