Model system_libs in cpp_info/deps_cpp_info and generators

conans/client/generators/cmake.py

@@ -30,8 +30,10 @@ def join_defines(values, prefix=""):
         self.bin_paths = join_paths(cpp_info.bin_paths)
         self.build_paths = join_paths(cpp_info.build_paths)
         self.src_paths = join_paths(cpp_info.src_paths)
-
+        # libs_system_frameworks == Package libs, system deps and frameworks
+        self.libs_system_frameworks = join_flags(" ", cpp_info.libs + cpp_info.system_libs)
         self.libs = join_flags(" ", cpp_info.libs)
+        self.system_libs = join_flags(" ", cpp_info.system_libs)
 
         framework_paths = join_paths(cpp_info.framework_paths)
         self.find_frameworks = ""
@@ -44,7 +46,7 @@ def join_defines(values, prefix=""):
                                                      framework=framework,
                                                      framework_paths=framework_paths)
             var = '${%s}' % var
-            self.libs += " " + var
+            self.libs_system_frameworks += " " + var
             self.find_frameworks += find_framework
 
         self.defines = join_defines(cpp_info.defines, "-D")

conans/client/generators/cmake_common.py

@@ -7,6 +7,7 @@
 set(CONAN_SRC_DIRS_{dep}{build_type} {deps.src_paths})
 set(CONAN_BUILD_DIRS_{dep}{build_type} {deps.build_paths})
 set(CONAN_LIBS_{dep}{build_type} {deps.libs})
+set(CONAN_SYSTEM_LIBS_{dep}{build_type} {deps.system_libs})
 set(CONAN_DEFINES_{dep}{build_type} {deps.defines})
 # COMPILE_DEFINITIONS are equal to CONAN_DEFINES without -D, for targets
 set(CONAN_COMPILE_DEFINITIONS_{dep}{build_type} {deps.compile_definitions})
@@ -83,7 +84,8 @@ def cmake_dependencies(dependencies, build_type=""):
 set(CONAN_LIB_DIRS{build_type} {deps.lib_paths} ${{CONAN_LIB_DIRS{build_type}}})
 set(CONAN_BIN_DIRS{build_type} {deps.bin_paths} ${{CONAN_BIN_DIRS{build_type}}})
 set(CONAN_RES_DIRS{build_type} {deps.res_paths} ${{CONAN_RES_DIRS{build_type}}})
-set(CONAN_LIBS{build_type} {deps.libs} ${{CONAN_LIBS{build_type}}})
+set(CONAN_LIBS{build_type} {deps.libs_system_frameworks} ${{CONAN_LIBS{build_type}}})
+set(CONAN_SYSTEM_LIBS{build_type} {deps.system_libs} ${{CONAN_SYSTEM_LIBS{build_type}}})
 set(CONAN_DEFINES{build_type} {deps.defines} ${{CONAN_DEFINES{build_type}}})
 set(CONAN_CMAKE_MODULE_PATH{build_type} {deps.build_paths} ${{CONAN_CMAKE_MODULE_PATH{build_type}}})
 
@@ -111,15 +113,20 @@ def cmake_global_vars(deps, build_type=""):
 
 _target_template = """
     conan_package_library_targets("${{CONAN_LIBS_{uname}}}" "${{CONAN_LIB_DIRS_{uname}}}"
-                                  CONAN_PACKAGE_TARGETS_{uname} "{deps}" "" {pkg_name})
+                                  CONAN_PACKAGE_TARGETS_{uname} "${{CONAN_SYSTEM_LIBS_{uname}}} {deps}"
+                                  "" {pkg_name})
     conan_package_library_targets("${{CONAN_LIBS_{uname}_DEBUG}}" "${{CONAN_LIB_DIRS_{uname}_DEBUG}}"
-                                  CONAN_PACKAGE_TARGETS_{uname}_DEBUG "{deps}" "debug" {pkg_name})
+                                  CONAN_PACKAGE_TARGETS_{uname}_DEBUG "${{CONAN_SYSTEM_LIBS_{uname}_DEBUG}} {deps}"
+                                  "debug" {pkg_name})
     conan_package_library_targets("${{CONAN_LIBS_{uname}_RELEASE}}" "${{CONAN_LIB_DIRS_{uname}_RELEASE}}"
-                                  CONAN_PACKAGE_TARGETS_{uname}_RELEASE "{deps}" "release" {pkg_name})
+                                  CONAN_PACKAGE_TARGETS_{uname}_RELEASE "${{CONAN_SYSTEM_LIBS_{uname}_RELEASE}} {deps}"
+                                  "release" {pkg_name})
     conan_package_library_targets("${{CONAN_LIBS_{uname}_RELWITHDEBINFO}}" "${{CONAN_LIB_DIRS_{uname}_RELWITHDEBINFO}}"
-                                  CONAN_PACKAGE_TARGETS_{uname}_RELWITHDEBINFO "{deps}" "relwithdebinfo" {pkg_name})
+                                  CONAN_PACKAGE_TARGETS_{uname}_RELWITHDEBINFO "${{CONAN_SYSTEM_LIBS_{uname}_RELWITHDEBINFO}} {deps}"
+                                  "relwithdebinfo" {pkg_name})
     conan_package_library_targets("${{CONAN_LIBS_{uname}_MINSIZEREL}}" "${{CONAN_LIB_DIRS_{uname}_MINSIZEREL}}"
-                                  CONAN_PACKAGE_TARGETS_{uname}_MINSIZEREL "{deps}" "minsizerel" {pkg_name})
+                                  CONAN_PACKAGE_TARGETS_{uname}_MINSIZEREL "${{CONAN_SYSTEM_LIBS_{uname}_MINSIZEREL}} {deps}"
+                                  "minsizerel" {pkg_name})
 
     add_library({name} INTERFACE IMPORTED)
 

conans/client/generators/cmake_find_package_common.py

@@ -8,6 +8,7 @@
 set({name}_LIBRARIES_TARGETS{build_type_suffix} "") # Will be filled later, if CMake 3
 set({name}_LIBRARIES{build_type_suffix} "") # Will be filled later
 set({name}_LIBS{build_type_suffix} "") # Same as {name}_LIBRARIES
+set({name}_SYSTEM_LIBS{build_type_suffix} {deps.system_libs})
 
 {deps.find_frameworks}
 

conans/client/generators/compiler_args.py

@@ -62,6 +62,7 @@ def content(self):
         flags.extend(rpath_flags(the_os, self.compiler, self._deps_build_info.lib_paths))
         flags.extend(format_library_paths(self._deps_build_info.lib_paths, compiler=self.compiler))
         flags.extend(format_libraries(self._deps_build_info.libs, compiler=self.compiler))
+        flags.extend(format_libraries(self._deps_build_info.system_libs, compiler=self.compiler))
         flags.extend(self._deps_build_info.sharedlinkflags)
         flags.extend(self._deps_build_info.exelinkflags)
         flags.extend(self._libcxx_flags())

conans/client/generators/json_generator.py

@@ -11,6 +11,7 @@ def serialize_cpp_info(cpp_info):
         "sysroot",
         "include_paths", "lib_paths", "bin_paths", "build_paths", "res_paths",
         "libs",
+        "system_libs",
         "defines", "cflags", "cxxflags", "sharedlinkflags", "exelinkflags",
         "frameworks", "framework_paths"
     ]

conans/client/generators/make.py

@@ -53,6 +53,7 @@ def create_content_from_dep(self, pkg_name, cpp_info):
                      ("BUILD_DIRS", self.assignment_append, cpp_info.build_paths),
                      ("RES_DIRS", self.assignment_append, cpp_info.res_paths),
                      ("LIBS", self.assignment_append, cpp_info.libs),
+                     ("SYSTEM_LIBS", self.assignment_append, cpp_info.system_libs),
                      ("DEFINES", self.assignment_append, cpp_info.defines),
                      ("CFLAGS", self.assignment_append, cpp_info.cflags),
                      ("CXXFLAGS", self.assignment_append, cpp_info.cxxflags),
@@ -108,4 +109,4 @@ def create_makefile_var_value(self, values):
     def all_dep_vars():
         return ["rootpath", "sysroot", "include_dirs", "lib_dirs", "bin_dirs", "build_dirs",
                 "res_dirs", "libs", "defines", "cflags", "cxxflags", "sharedlinkflags",
-                "exelinkflags", "frameworks", "framework_paths"]
+                "exelinkflags", "frameworks", "framework_paths", "system_libs"]

conans/client/generators/pkg_config.py

@@ -61,7 +61,7 @@ def single_pc_file_contents(self, cpp_info):
         lines.append("Description: %s" % description)
         lines.append("Version: %s" % cpp_info.version)
         libdirs_flags = ["-L${%s}" % name for name in libdir_vars]
-        libnames_flags = ["-l%s " % name for name in cpp_info.libs]
+        libnames_flags = ["-l%s " % name for name in (cpp_info.libs + cpp_info.system_libs)]
         shared_flags = cpp_info.sharedlinkflags + cpp_info.exelinkflags
         the_os = (self.conanfile.settings.get_safe("os_build") or
                   self.conanfile.settings.get_safe("os"))

conans/client/generators/text.py

@@ -22,6 +22,7 @@ def __init__(self, cpp_info):
         self.build_paths = "\n".join(p.replace("\\", "/")
                                      for p in cpp_info.build_paths)
         self.libs = "\n".join(cpp_info.libs)
+        self.system_libs = "\n".join(cpp_info.system_libs)
         self.defines = "\n".join(cpp_info.defines)
         self.cxxflags = "\n".join(cpp_info.cxxflags)
         self.cflags = "\n".join(cpp_info.cflags)
@@ -143,6 +144,7 @@ def content(self):
                     '[resdirs{dep}{config}]\n{deps.res_paths}\n\n'
                     '[builddirs{dep}{config}]\n{deps.build_paths}\n\n'
                     '[libs{dep}{config}]\n{deps.libs}\n\n'
+                    '[system_libs{dep}{config}]\n{deps.system_libs}\n\n'
                     '[defines{dep}{config}]\n{deps.defines}\n\n'
                     '[cppflags{dep}{config}]\n{deps.cxxflags}\n\n'  # Backwards compatibility
                     '[cxxflags{dep}{config}]\n{deps.cxxflags}\n\n'

conans/client/generators/visualstudio.py

@@ -27,6 +27,7 @@ class VisualStudioGenerator(Generator):
     <ConanLibraryDirectories>{lib_dirs}</ConanLibraryDirectories>
     <ConanBinaryDirectories>{bin_dirs}</ConanBinaryDirectories>
     <ConanLibraries>{libs}</ConanLibraries>
+    <ConanSystemDeps>{system_libs}</ConanSystemDeps>
   </PropertyGroup>
   <PropertyGroup{condition}>
     <LocalDebuggerEnvironment>PATH=%PATH%;{bin_dirs}</LocalDebuggerEnvironment>
@@ -41,6 +42,7 @@ class VisualStudioGenerator(Generator):
     <Link>
       <AdditionalLibraryDirectories>$(ConanLibraryDirectories)%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>$(ConanLibraries)%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(ConanSystemDeps)%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalOptions>$(ConanLinkerFlags) %(AdditionalOptions)</AdditionalOptions>
     </Link>
     <Midl>
@@ -84,6 +86,8 @@ def has_valid_ext(lib):
             'lib_dirs': "".join("%s;" % p for p in build_info.lib_paths),
             'libs': "".join(['%s.lib;' % lib if not has_valid_ext(lib)
                              else '%s;' % lib for lib in build_info.libs]),
+            'system_libs': "".join(['%s.lib;' % sys_dep if not has_valid_ext(sys_dep)
+                                    else '%s;' % sys_dep for sys_dep in build_info.system_libs]),
             'definitions': "".join("%s;" % d for d in build_info.defines),
             'compiler_flags': " ".join(build_info.cxxflags + build_info.cflags),
             'linker_flags': " ".join(build_info.sharedlinkflags),

conans/client/generators/xcode.py

@@ -8,7 +8,7 @@ class XCodeGenerator(Generator):
     template = '''
 HEADER_SEARCH_PATHS = $(inherited) {include_dirs}
 LIBRARY_SEARCH_PATHS = $(inherited) {lib_dirs}
-OTHER_LDFLAGS = $(inherited) {linker_flags} {libs} {frameworks}
+OTHER_LDFLAGS = $(inherited) {linker_flags} {libs} {system_libs} {frameworks}
 
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) {definitions}
 OTHER_CFLAGS = $(inherited) {c_compiler_flags}
@@ -31,6 +31,7 @@ def __init__(self, conanfile):
         self.rootpaths = " ".join('"%s"' % d.replace("\\", "/") for d in deps_cpp_info.rootpaths)
         self.frameworks = " ".join(format_frameworks(deps_cpp_info.frameworks, compiler="apple-clang"))
         self.framework_paths = " ".join(deps_cpp_info.framework_paths)
+        self.system_libs = " ".join(['-l%s' % lib for lib in deps_cpp_info.system_libs])
 
     @property
     def filename(self):

conans/model/build_info.py

@@ -19,6 +19,7 @@ class _CppInfo(object):
     """
     def __init__(self):
         self.name = None
+        self.system_libs = []  # Ordered list of system libraries
         self.includedirs = []  # Ordered list of include paths
         self.srcdirs = []  # Ordered list of source paths
         self.libdirs = []  # Directories to find libraries
@@ -155,6 +156,7 @@ def update(self, dep_cpp_info):
         def merge_lists(seq1, seq2):
             return [s for s in seq1 if s not in seq2] + seq2
 
+        self.system_libs = merge_lists(self.system_libs, dep_cpp_info.system_libs)
         self.includedirs = merge_lists(self.includedirs, dep_cpp_info.include_paths)
         self.srcdirs = merge_lists(self.srcdirs, dep_cpp_info.src_paths)
         self.libdirs = merge_lists(self.libdirs, dep_cpp_info.lib_paths)

conans/test/functional/generators/cmake_find_package_multi_test.py

@@ -76,3 +76,53 @@ def test_native_export_multi(self):
                         self.assertIn("Hello World {}!".format(bt), c.out)
                         self.assertIn("bye World {}!".format(bt), c.out)
                         os.remove(os.path.join(c.current_folder, "example"))
+
+    @unittest.skipUnless(platform.system() != "Windows", "Skip Visual Studio config for build type")
+    def cmake_find_package_system_libs_test(self):
+        conanfile = textwrap.dedent("""
+            from conans import ConanFile, tools
+
+            class Test(ConanFile):
+                name = "Test"
+                version = "0.1"
+                settings = "build_type"
+                def package_info(self):
+                    if self.settings.build_type == "Debug":
+                        self.cpp_info.system_libs.append("sys1d")
+                    else:
+                        self.cpp_info.system_libs.append("sys1")
+            """)
+        client = TestClient()
+        client.save({"conanfile.py": conanfile})
+        client.run("export .")
+
+        conanfile = textwrap.dedent("""
+            [requires]
+            Test/0.1
+
+            [generators]
+            cmake_find_package_multi
+            """)
+        cmakelists = textwrap.dedent("""
+            cmake_minimum_required(VERSION 3.1)
+            project(consumer CXX)
+            set(CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR})
+            set(CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR})
+            find_package(Test)
+            message("System libs: ${Test_SYSTEM_LIBS}")
+            message("Libraries to Link: ${Test_LIBS}")
+            get_target_property(tmp Test::Test INTERFACE_LINK_LIBRARIES)
+            message("Target libs: ${tmp}")
+            """)
+        client.save({"conanfile.txt": conanfile, "CMakeLists.txt": cmakelists})
+        for build_type in ["Release", "Debug"]:
+            client.run("install conanfile.txt --build missing -s build_type=%s" % build_type)
+            client.run_command('cmake .. -DCMAKE_BUILD_TYPE={}'.format(build_type))
+            client.run_command('cmake --build .')
+
+            library_name = "sys1d" if build_type == "Debug" else "sys1"
+            self.assertIn("System deps: %s" % library_name, client.out)
+            self.assertIn("Libraries to Link: %s" % library_name, client.out)
+            self.assertIn("-- Library %s not found in package, might be system one" % library_name,
+                          client.out)
+            self.assertIn("Target libs: %s" % library_name, client.out)

conans/test/functional/generators/cmake_find_package_test.py

@@ -1,5 +1,6 @@
 import platform
 import six
+import textwrap
 import unittest
 
 from nose.plugins.attrib import attr
@@ -205,6 +206,54 @@ def cmake_find_package_test(self):
         self.assertIn("Conan: Using autogenerated FindHello1.cmake", client.out)
         self.assertIn("Version1: 0.1", client.out)
 
+    def cmake_find_package_system_libs_test(self):
+        conanfile = textwrap.dedent("""
+            from conans import ConanFile, tools
+
+            class Test(ConanFile):
+                name = "Test"
+                version = "0.1"
+
+                def package_info(self):
+                    self.cpp_info.system_libs.append("sys1")
+        """)
+        client = TestClient()
+        client.save({"conanfile.py": conanfile})
+        client.run("export .")
+
+        conanfile = textwrap.dedent("""
+            from conans import ConanFile, CMake
+
+            class Consumer(ConanFile):
+                name = "consumer"
+                version = "0.1"
+                requires = "Test/0.1"
+                generators = "cmake_find_package"
+                exports_sources = "CMakeLists.txt"
+                settings = "os", "arch", "compiler"
+
+                def build(self):
+                    cmake = CMake(self)
+                    cmake.configure()
+        """)
+        cmakelists = textwrap.dedent("""
+            cmake_minimum_required(VERSION 3.1)
+            project(consumer)
+            find_package(Test)
+            message("Libraries to Link: ${Test_LIBS}")
+            message("Version: ${Test_VERSION}")
+            message("System deps: ${Test_SYSTEM_LIBS}")
+            get_target_property(tmp Test::Test INTERFACE_LINK_LIBRARIES)
+            message("Target libs: ${tmp}")
+        """)
+        client.save({"conanfile.py": conanfile, "CMakeLists.txt": cmakelists})
+        client.run("create . user/channel --build missing")
+        self.assertIn("Libraries to Link: sys1", client.out)
+        self.assertIn("Version: 0.1", client.out)
+        self.assertIn("System deps: sys1", client.out)
+        self.assertIn("-- Library sys1 not found in package, might be system one", client.out)
+        self.assertIn("Target libs: sys1", client.out)
+
     @unittest.skipUnless(platform.system() == "Darwin", "Requires Apple Frameworks")
     def cmake_find_package_frameworks_test(self):
         conanfile = """from conans import ConanFile, tools

conans/test/functional/generators/cmake_multi_test.py

@@ -272,6 +272,48 @@ def cmake_multi_test(self):
             self.assertIn("Hello Release Hello0", client.out)
 
 
+class CMakeMultiSystemLibsTest(unittest.TestCase):
+
+    def system_libs_test(self):
+        mylib = textwrap.dedent("""
+            import os
+            from conans import ConanFile
+
+            class MyLib(ConanFile):
+
+                def package_info(self):
+                    self.cpp_info.debug.system_libs = ["sys1d"]
+                    self.cpp_info.release.system_libs = ["sys1"]
+                    self.cpp_info.libs = ["lib1"]
+                """)
+        consumer = textwrap.dedent("""
+            import os
+            from conans import ConanFile
+
+            class Consumer(ConanFile):
+                requires = "mylib/1.0@us/ch"
+                generators = "cmake"
+                """)
+        client = TestClient()
+        client.save({"conanfile_mylib.py": mylib, "conanfile_consumer.py": consumer})
+        client.run("create conanfile_mylib.py mylib/1.0@us/ch")
+        client.run("install conanfile_consumer.py")
+        content = load(os.path.join(client.current_folder, "conanbuildinfo.cmake"))
+        self.assertIn("set(CONAN_LIBS lib1 ${CONAN_LIBS})", content)
+        self.assertIn("set(CONAN_LIBS_DEBUG sys1d ${CONAN_LIBS_DEBUG})", content)
+        self.assertIn("set(CONAN_LIBS_RELEASE sys1 ${CONAN_LIBS_RELEASE})", content)
+        self.assertIn("set(CONAN_LIBS_MYLIB lib1)", content)
+        self.assertIn("set(CONAN_LIBS_MYLIB_RELEASE )", content)
+        self.assertIn("set(CONAN_LIBS_MYLIB_DEBUG )", content)
+
+        self.assertIn("set(CONAN_SYSTEM_LIBS  ${CONAN_SYSTEM_LIBS})", content)
+        self.assertIn("set(CONAN_SYSTEM_LIBS_DEBUG sys1d ${CONAN_SYSTEM_LIBS_DEBUG})", content)
+        self.assertIn("set(CONAN_SYSTEM_LIBS_RELEASE sys1 ${CONAN_SYSTEM_LIBS_RELEASE})", content)
+        self.assertIn("set(CONAN_SYSTEM_LIBS_MYLIB )", content)
+        self.assertIn("set(CONAN_SYSTEM_LIBS_MYLIB_RELEASE sys1)", content)
+        self.assertIn("set(CONAN_SYSTEM_LIBS_MYLIB_DEBUG sys1d)", content)
+
+
 class CMakeMultiSyntaxTest(unittest.TestCase):
 
     def setUp(self):