Feature/msvc msbuild

conan/tools/cmake/android.py

@@ -19,31 +19,6 @@ class CMakeAndroidToolchain(CMakeToolchainBase):
             set(CMAKE_ANDROID_STL_TYPE {{ CMAKE_ANDROID_STL_TYPE }})
             set(CMAKE_ANDROID_NDK {{ CMAKE_ANDROID_NDK }})
         {% endblock %}
-
-        {% block main %}
-            {{ super() }}
-
-            {% if shared_libs -%}
-            message(STATUS "Conan toolchain: Setting BUILD_SHARED_LIBS= {{ shared_libs }}")
-            set(BUILD_SHARED_LIBS {{ shared_libs }})
-            {%- endif %}
-
-            {% if parallel -%}
-            set(CONAN_CXX_FLAGS "${CONAN_CXX_FLAGS} {{ parallel }}")
-            set(CONAN_C_FLAGS "${CONAN_C_FLAGS} {{ parallel }}")
-            {%- endif %}
-
-            {% if cppstd -%}
-            message(STATUS "Conan C++ Standard {{ cppstd }} with extensions {{ cppstd_extensions }}}")
-            set(CMAKE_CXX_STANDARD {{ cppstd }})
-            set(CMAKE_CXX_EXTENSIONS {{ cppstd_extensions }})
-            {%- endif %}
-
-            set(CMAKE_CXX_FLAGS_INIT "${CONAN_CXX_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_C_FLAGS_INIT "${CONAN_C_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_SHARED_LINKER_FLAGS_INIT "${CONAN_SHARED_LINKER_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_EXE_LINKER_FLAGS_INIT "${CONAN_EXE_LINKER_FLAGS}" CACHE STRING "" FORCE)
-        {% endblock %}
     """)
 
     # TODO: fPIC, fPIE

conan/tools/cmake/base.py

@@ -95,6 +95,27 @@ class CMakeToolchainBase(object):
             {%- endif %}
         {% endblock %}
 
+        {% if shared_libs -%}
+            message(STATUS "Conan toolchain: Setting BUILD_SHARED_LIBS= {{ shared_libs }}")
+            set(BUILD_SHARED_LIBS {{ shared_libs }})
+        {%- endif %}
+
+        {% if parallel -%}
+        set(CONAN_CXX_FLAGS "${CONAN_CXX_FLAGS} {{ parallel }}")
+        set(CONAN_C_FLAGS "${CONAN_C_FLAGS} {{ parallel }}")
+        {%- endif %}
+
+        {% if cppstd -%}
+        message(STATUS "Conan C++ Standard {{ cppstd }} with extensions {{ cppstd_extensions }}}")
+        set(CMAKE_CXX_STANDARD {{ cppstd }})
+        set(CMAKE_CXX_EXTENSIONS {{ cppstd_extensions }})
+        {%- endif %}
+
+        set(CMAKE_CXX_FLAGS_INIT "${CONAN_CXX_FLAGS}" CACHE STRING "" FORCE)
+        set(CMAKE_C_FLAGS_INIT "${CONAN_C_FLAGS}" CACHE STRING "" FORCE)
+        set(CMAKE_SHARED_LINKER_FLAGS_INIT "${CONAN_SHARED_LINKER_FLAGS}" CACHE STRING "" FORCE)
+        set(CMAKE_EXE_LINKER_FLAGS_INIT "${CONAN_EXE_LINKER_FLAGS}" CACHE STRING "" FORCE)
+
         # Variables
         {% for it, value in variables.items() %}
         set({{ it }} "{{ value }}" CACHE STRING "Variable {{ it }} conan-toolchain defined")

conan/tools/cmake/generic.py

@@ -68,11 +68,6 @@ class CMakeGenericToolchain(CMakeToolchainBase):
         {% block main %}
             {{ super() }}
 
-            {% if shared_libs -%}
-                message(STATUS "Conan toolchain: Setting BUILD_SHARED_LIBS= {{ shared_libs }}")
-                set(BUILD_SHARED_LIBS {{ shared_libs }})
-            {%- endif %}
-
             {% if fpic -%}
                 message(STATUS "Conan toolchain: Setting CMAKE_POSITION_INDEPENDENT_CODE=ON (options.fPIC)")
                 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
@@ -85,11 +80,6 @@ class CMakeGenericToolchain(CMakeToolchainBase):
                 set(CMAKE_INSTALL_NAME_DIR "")
             {% endif -%}
 
-            {% if parallel -%}
-                set(CONAN_CXX_FLAGS "${CONAN_CXX_FLAGS} {{ parallel }}")
-                set(CONAN_C_FLAGS "${CONAN_C_FLAGS} {{ parallel }}")
-            {%- endif %}
-
             {% if architecture -%}
                 set(CONAN_CXX_FLAGS "${CONAN_CXX_FLAGS} {{ architecture }}")
                 set(CONAN_C_FLAGS "${CONAN_C_FLAGS} {{ architecture }}")
@@ -104,12 +94,6 @@ class CMakeGenericToolchain(CMakeToolchainBase):
                 add_definitions(-D_GLIBCXX_USE_CXX11_ABI={{ glibcxx }})
             {%- endif %}
 
-            {% if cppstd -%}
-                message(STATUS "Conan C++ Standard {{ cppstd }} with extensions {{ cppstd_extensions }}")
-                set(CMAKE_CXX_STANDARD {{ cppstd }})
-                set(CMAKE_CXX_EXTENSIONS {{ cppstd_extensions }})
-            {%- endif %}
-
             {% if vs_runtimes %}
             {% set genexpr = namespace(str='') %}
             {%- for config, value in vs_runtimes.items() -%}
@@ -118,11 +102,6 @@ class CMakeGenericToolchain(CMakeToolchainBase):
             {%- endfor -%}
             set(CMAKE_MSVC_RUNTIME_LIBRARY "{{ genexpr.str }}")
             {% endif %}
-
-            set(CMAKE_CXX_FLAGS_INIT "${CONAN_CXX_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_C_FLAGS_INIT "${CONAN_C_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_SHARED_LINKER_FLAGS_INIT "${CONAN_SHARED_LINKER_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_EXE_LINKER_FLAGS_INIT "${CONAN_EXE_LINKER_FLAGS}" CACHE STRING "" FORCE)
         {% endblock %}
         """)
 

conan/tools/cmake/ios.py

@@ -21,26 +21,6 @@ class CMakeiOSToolchain(CMakeToolchainBase):
               set(CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM "123456789A" CACHE INTERNAL "")
             endif()
         {% endblock %}
-        {% block main %}
-            {{ super() }}
-            {% if shared_libs -%}
-            message(STATUS "Conan toolchain: Setting BUILD_SHARED_LIBS= {{ shared_libs }}")
-            set(BUILD_SHARED_LIBS {{ shared_libs }})
-            {%- endif %}
-            {% if parallel -%}
-            set(CONAN_CXX_FLAGS "${CONAN_CXX_FLAGS} {{ parallel }}")
-            set(CONAN_C_FLAGS "${CONAN_C_FLAGS} {{ parallel }}")
-            {%- endif %}
-            {% if cppstd -%}
-            message(STATUS "Conan C++ Standard {{ cppstd }} with extensions {{ cppstd_extensions }}}")
-            set(CMAKE_CXX_STANDARD {{ cppstd }})
-            set(CMAKE_CXX_EXTENSIONS {{ cppstd_extensions }})
-            {%- endif %}
-            set(CMAKE_CXX_FLAGS_INIT "${CONAN_CXX_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_C_FLAGS_INIT "${CONAN_C_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_SHARED_LINKER_FLAGS_INIT "${CONAN_SHARED_LINKER_FLAGS}" CACHE STRING "" FORCE)
-            set(CMAKE_EXE_LINKER_FLAGS_INIT "${CONAN_EXE_LINKER_FLAGS}" CACHE STRING "" FORCE)
-        {% endblock %}
     """)
 
     def __init__(self, conanfile, build_type=None, **kwargs):

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/build/compiler_flags.py

@@ -28,7 +28,7 @@ def rpath_flags(settings, os_build, lib_paths):
     if not os_build:
         return []
     if compiler in GCC_LIKE:
-        rpath_separator = "," if is_apple_os(os_build) else "="
+        rpath_separator = ","
         return ['-Wl,-rpath%s"%s"' % (rpath_separator, x.replace("\\", "/"))
                 for x in lib_paths if x]
     return []

conans/client/command.py

@@ -1091,7 +1091,7 @@ def remove(self, *args):
                             help="Remove locks")
         parser.add_argument("-o", "--outdated", default=False, action="store_true",
                             help="Remove only outdated from recipe packages. "
-                                 "This flag can only be used with a reference")
+                                 "This flag can only be used with a pattern or a reference")
         parser.add_argument('-p', '--packages', nargs="*", action=Extender,
                             help="Remove all packages of the specified reference if "
                                  "no specific package ID is provided")

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