Feature/msvc msbuild

conan/tools/microsoft/msbuild.py

@@ -15,8 +15,15 @@ class MSBuild(object):
     def __init__(self, conanfile):
         self._conanfile = conanfile
         self.compiler = conanfile.settings.get_safe("compiler")
+        # This is assuming this is the Visual Studio IDE version, used for the vcvars
         self.version = (conanfile.settings.get_safe("compiler.base.version") or
                         conanfile.settings.get_safe("compiler.version"))
+        if self.compiler == "msvc":
+            version = self.version[:4]  # Remove the latest version number 19.1X if existing
+            _visuals = {'19.0': '14',  # TODO: This is common to CMake, refactor
+                        '19.1': '15',
+                        '19.2': '16'}
+            self.version = _visuals[version]
         self.vcvars_arch = vcvars_arch(conanfile)
         self.build_type = conanfile.settings.get_safe("build_type")
         msvc_arch = {'x86': 'x86',

conan/tools/microsoft/toolchain.py

@@ -3,7 +3,6 @@
 import warnings
 from xml.dom import minidom
 
-from conans.client.tools import msvs_toolset
 from conans.errors import ConanException
 from conans.util.files import save, load
 
@@ -17,6 +16,9 @@ def __init__(self, conanfile):
         self.preprocessor_definitions = {}
         self.compile_options = {}
         self.configuration = conanfile.settings.build_type
+        self.runtime_library = self._runtime_library(conanfile.settings)
+        self.cppstd = conanfile.settings.get_safe("compiler.cppstd")
+        self.toolset = self._msvs_toolset(conanfile.settings)
 
     def _name_condition(self, settings):
         props = [("Configuration", self.configuration),
@@ -49,20 +51,59 @@ def generate(self):
         self._write_config_toolchain(config_filename)
         self._write_main_toolchain(config_filename, condition)
 
+    @staticmethod
+    def _msvs_toolset(settings):
+        compiler = settings.get_safe("compiler")
+        compiler_version = settings.get_safe("compiler.version")
+        if compiler == "msvc":
+            version = compiler_version[:4]  # Remove the latest version number 19.1X if existing
+            toolsets = {'19.0': 'v140',  # TODO: This is common to CMake, refactor
+                        '19.1': 'v141',
+                        '19.2': 'v142'}
+            return toolsets[version]
+        if compiler == "intel":
+            compiler_version = compiler_version if "." in compiler_version else \
+                "%s.0" % compiler_version
+            return "Intel C++ Compiler " + compiler_version
+        if compiler == "Visual Studio":
+            toolset = settings.get_safe("compiler.toolset")
+            if not toolset:
+                toolsets = {"16": "v142",
+                            "15": "v141",
+                            "14": "v140",
+                            "12": "v120",
+                            "11": "v110",
+                            "10": "v100",
+                            "9": "v90",
+                            "8": "v80"}
+                toolset = toolsets.get(compiler_version)
+            return toolset or ""
+
+    @staticmethod
+    def _runtime_library(settings):
+        compiler = settings.compiler
+        runtime = settings.get_safe("compiler.runtime")
+        if compiler == "msvc":
+            build_type = settings.get_safe("build_type")
+            if build_type != "Debug":
+                runtime_library = {"static": "MultiThreaded",
+                                   "dynamic": "MultiThreadedDLL"}.get(runtime, "")
+            else:
+                runtime_library = {"static": "MultiThreadedDebug",
+                                   "dynamic": "MultiThreadedDebugDLL"}.get(runtime, "")
+        else:
+            runtime_library = {"MT": "MultiThreaded",
+                               "MTd": "MultiThreadedDebug",
+                               "MD": "MultiThreadedDLL",
+                               "MDd": "MultiThreadedDebugDLL"}.get(runtime, "")
+        return runtime_library
+
     def _write_config_toolchain(self, config_filename):
 
         def format_macro(k, value):
             return '%s="%s"' % (k, value) if value is not None else k
 
-        runtime = self._conanfile.settings.get_safe("compiler.runtime")
-        cppstd = self._conanfile.settings.get_safe("compiler.cppstd")
-        toolset = msvs_toolset(self._conanfile.settings)
-        runtime_library = {"MT": "MultiThreaded",
-                           "MTd": "MultiThreadedDebug",
-                           "MD": "MultiThreadedDLL",
-                           "MDd": "MultiThreadedDebugDLL"}.get(runtime, "")
-
-        content = textwrap.dedent("""\
+        toolchain_file = textwrap.dedent("""\
             <?xml version="1.0" encoding="utf-8"?>
             <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <ItemDefinitionGroup>
@@ -81,17 +122,18 @@ def format_macro(k, value):
             """)
         preprocessor_definitions = ";".join([format_macro(k, v)
                                              for k, v in self.preprocessor_definitions.items()])
-        # It is useless to set PlatformToolset in the config file, because the conditional checks it
-        cppstd = "stdcpp%s" % cppstd if cppstd else ""
-        toolset = toolset or ""
+
+        cppstd = "stdcpp%s" % self.cppstd if self.cppstd else ""
+        runtime_library = self.runtime_library
+        toolset = self.toolset
         compile_options = self._conanfile.conf["tools.microsoft.msbuildtoolchain"].compile_options
         if compile_options is not None:
             compile_options = eval(compile_options)
             self.compile_options.update(compile_options)
         compile_options = "".join("\n      <{k}>{v}</{k}>".format(k=k, v=v)
                                   for k, v in self.compile_options.items())
-        config_props = content.format(preprocessor_definitions, runtime_library, cppstd,
-                                      compile_options, toolset)
+        config_props = toolchain_file.format(preprocessor_definitions, runtime_library, cppstd,
+                                             compile_options, toolset)
         config_filepath = os.path.abspath(config_filename)
         self._conanfile.output.info("MSBuildToolchain created %s" % config_filename)
         save(config_filepath, config_props)

conans/client/conf/__init__.py

@@ -504,14 +504,6 @@ def full_transitive_package_id(self):
         except ConanException:
             return None
 
-    @property
-    def msvc_visual_incompatible(self):
-        try:
-            visual_comp = self.get_item("general.msvc_visual_incompatible")
-            return visual_comp.lower() in ("1", "true")
-        except ConanException:
-            return False
-
     @property
     def short_paths_home(self):
         short_paths_home = get_env("CONAN_USER_HOME_SHORT")

conans/client/graph/graph_binaries.py

@@ -339,7 +339,8 @@ def _compute_package_id(self, node, default_package_id_mode, default_python_requ
                                           python_requires=python_requires,
                                           default_python_requires_id_mode=
                                           default_python_requires_id_mode)
-        if not self._cache.config.msvc_visual_incompatible:
+
+        if not self._cache.new_config["core.package_id"].msvc_visual_incompatible:
             msvc_compatible = conanfile.info.msvc_compatible()
             if msvc_compatible:
                 conanfile.compatible_packages.append(msvc_compatible)

conans/client/tools/win.py

@@ -138,8 +138,9 @@ def msvs_toolset(conanfile):
         settings = conanfile
     toolset = settings.get_safe("compiler.toolset")
     if not toolset:
+        compiler = settings.get_safe("compiler")
         compiler_version = settings.get_safe("compiler.version")
-        if settings.get_safe("compiler") == "intel":
+        if compiler == "intel":
             compiler_version = compiler_version if "." in compiler_version else \
                 "%s.0" % compiler_version
             toolset = "Intel C++ Compiler " + compiler_version

conans/test/functional/toolchains/cmake/test_ninja.py

@@ -10,6 +10,7 @@
 from conans.test.utils.tools import TestClient
 from conans.client.tools import which
 
+
 @pytest.mark.tool_cmake
 class CMakeNinjaTestCase(unittest.TestCase):
     # This test assumes that 'CMake' and 'Ninja' are available in the system

conans/test/functional/toolchains/test_msbuild.py

@@ -6,6 +6,8 @@
 import unittest
 
 import pytest
+from parameterized import parameterized
+
 
 from conans.client.tools import chdir
 from conans.util.files import mkdir
@@ -399,19 +401,22 @@ def _run_app(self, client, arch, build_type, shared=None):
         self.assertIn("DEFINITIONS_CONFIG: %s" % build_type, client.out)
 
     @pytest.mark.tool_cmake
-    def test_toolchain_win(self):
+    @parameterized.expand([("Visual Studio", "15", "MT"),
+                           ("msvc", "19.1", "static")]
+                          )
+    def test_toolchain_win(self, compiler, version, runtime):
         client = TestClient(path_with_spaces=False)
-        settings = {"compiler": "Visual Studio",
-                    "compiler.version": "15",
+        settings = {"compiler": compiler,
+                    "compiler.version": version,
                     "compiler.cppstd": "17",
-                    "compiler.runtime": "MT",
+                    "compiler.runtime": runtime,
                     "build_type": "Release",
                     "arch": "x86"}
 
         # Build the profile according to the settings provided
         settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v)
 
-        client.run("new hello/0.1 -s")
+        client.run("new hello/0.1 -m=v2_cmake")
         client.run("create . hello/0.1@ %s" % (settings, ))
 
         # Prepare the actual consumer package

conans/test/integration/package_id/compatible_test.py

@@ -4,6 +4,7 @@
 
 from conans.model.ref import ConanFileReference
 from conans.test.utils.tools import TestClient, GenConanfile
+from conans.util.files import save
 
 
 class CompatibleIDsTest(unittest.TestCase):
@@ -497,15 +498,23 @@ def package_id(self):
 def test_msvc_visual_incompatible():
     conanfile = GenConanfile().with_settings("os", "compiler", "build_type", "arch")
     client = TestClient()
-    client.save({"conanfile.py": conanfile})
+    profile = textwrap.dedent("""
+        [settings]
+        os=Windows
+        compiler=msvc
+        compiler.version=19.1
+        compiler.runtime=dynamic
+        compiler.cppstd=14
+        build_type=Release
+        arch=x86_64
+        """)
+    client.save({"conanfile.py": conanfile,
+                 "profile": profile})
     client.run('create . pkg/0.1@ -s os=Windows -s compiler="Visual Studio" -s compiler.version=15 '
                '-s compiler.runtime=MD -s build_type=Release -s arch=x86_64')
-    client.run("install pkg/0.1@  -s os=Windows -s compiler=msvc -s compiler.version=19.1 "
-               "-s compiler.runtime=dynamic -s build_type=Release -s arch=x86_64 "
-               "-s compiler.cppstd=14")
+    client.run("install pkg/0.1@ -pr=profile")
     assert "Using compatible package" in client.out
-    client.run("config set general.msvc_visual_incompatible=1")
-    client.run("install pkg/0.1@  -s os=Windows -s compiler=msvc -s compiler.version=19.1 "
-               "-s compiler.runtime=dynamic -s build_type=Release -s arch=x86_64 "
-               "-s compiler.cppstd=14", assert_error=True)
+    new_config = "core.package_id:msvc_visual_incompatible=1"
+    save(client.cache.new_config_path, new_config)
+    client.run("install pkg/0.1@ -pr=profile", assert_error=True)
     assert "ERROR: Missing prebuilt package for 'pkg/0.1'" in client.out

conans/test/unittests/model/transitive_reqs_test.py

@@ -1,5 +1,5 @@
 import unittest
-from collections import namedtuple, Counter
+from collections import namedtuple, Counter, defaultdict
 
 import six
 from mock import Mock
@@ -87,6 +87,7 @@ def setUp(self):
                                         self.resolver, None)
         cache = Mock()
         cache.config.default_package_id_mode = "semver_direct_mode"
+        cache.new_config = defaultdict(Mock)
         self.binaries_analyzer = GraphBinariesAnalyzer(cache, self.output, self.remote_manager)
 
     def build_graph(self, content, options="", settings=""):