[mlir] Leverage CMake interface libraries for mlir python

[stella.stamenova]

Summary

This is already partially the case, but we can rely more heavily on interface libraries and how they are imported/exported in other to simplify the implementation of the mlir python functions in Cmake.

This change also makes a couple of other changes:

1. Add a new CMake function which handles "pure" sources. This was done inline previously
2. Moves the headers associated with CAPI libraries to the libraries themselves. These were previously managed in a separate source target. They can now be added directly to the CAPI libraries using DECLARED_HEADERS.
3. Cleanup some dependencies that showed up as an issue during the refactor

This is a big CMake change that should produce no impact on the build of mlir and on the produced *build tree*. However, this change fixes an issue with the *install tree* of mlir which was previously unusable for projects like torch-mlir because both the "pure" and "extension" targets were pointing to either the build or source trees.

[stellaraccident]

Thank you for this. As we discussed on Discord, I didn't know about the inheritable sources on interface libraries, and that simplifies things. A couple of comments for my own education, but otherwise looks good.

Have you happened to have tested this with a downstream yet?

mlir/cmake/modules/AddMLIRPython.cmake

79

Aha -- it never even occurred to me that CMake interface libraries also had inheritable sources. This does simplify things.

83

I'm a bit surprised that you also need to specify PRIVATE sources. Is this just some CMake thing that I should look past and not question too deeply?

mlir/python/CMakeLists.txt

505

Is this something that we need to instruct downstreams to adapt to or just a cleanup while you were here? If the former, can you leave some notes for downstreams in the commit description?

[stella.stamenova]

In D128230#3606600, @stellaraccident wrote:

Thank you for this. As we discussed on Discord, I didn't know about the inheritable sources on interface libraries, and that simplifies things. A couple of comments for my own education, but otherwise looks good.

Have you happened to have tested this with a downstream yet?

I made sure torch-mlir can build/test/install correctly both with a build and an install tree of mlir. I haven't tested other downstreams.

mlir/cmake/modules/AddMLIRPython.cmake

83

I tried to capture this in the comment in the cmake file, but let me know if you'd like me to add any more to it:

Basically, the reason we need the PRIVATE sources here is that BUILD_INTERFACE and INSTALL_INTERFACE expressions get evaluated at *build* time, but for the copying/symlinking of the source files all steps happen at *configuration* time, so the expressions are not evaluated yet and are useless. The PRIVATE sources, on the other hand, can be used at configuration time. When pointing to a build or an install mlir tree for downstream projects, both the generator expressions are evaluated correctly, so the interface sources work fine.

There are ways we could do away with the PRIVATE sources, but it would make the rest of the logic more complicated and I decided it wasn't worth it. Once we have FILE_SETs, this can be cleaned up somewhat if there's a need.

mlir/python/CMakeLists.txt

505

I'll add a bit more details to the commit description.

When I was going through this, I noticed that we declared the header sources in a separate target from the library that uses them, so I decided to make them depend on each other. This means that the CAPI libraries will always have any headers they need if they use the new DECLARED_HEADERS option. They don't have to, though, so downstreams can continue to do it differently if they want to. It would be better if they didn't, but it should work correctly in most cases regardless.

[stellaraccident]

In D128230#3608565, @stella.stamenova wrote:

In D128230#3606600, @stellaraccident wrote:

Thank you for this. As we discussed on Discord, I didn't know about the inheritable sources on interface libraries, and that simplifies things. A couple of comments for my own education, but otherwise looks good.

Have you happened to have tested this with a downstream yet?

I made sure torch-mlir can build/test/install correctly both with a build and an install tree of mlir. I haven't tested other downstreams.

Thanks - verifying torch-mlir should be enough. They all build off of that pattern. Good enough for me. Thanks.

mlir/cmake/modules/AddMLIRPython.cmake

83

Oh cmake. Thanks, i thinki get it now.

mlir/python/CMakeLists.txt

505

Ok, thanks for the explanation. I mainly want to ensure that if we change how downstreams need to do it that we document so they can adapt when they integrate.

[stellaraccident]

FYI - this patch has a minor bug in it when used as part of larger projects. Line 214 creates duplicate target names in some cases. It needs to be scoped (like is done for the target just below it).

set(_pure_sources_target "${modules_target}.sources.${sources_target}")

Since this seems very specific to some tricky downstreams that are debugged ins-situ, I'm just going to push a quick fix.

[stellaraccident]

Fixed in https://reviews.llvm.org/rGaa78c5298ea37f2ca8150dc0a1c880be7ec438f4

[stella.stamenova]

In D128230#3628363, @stellaraccident wrote:

FYI - this patch has a minor bug in it when used as part of larger projects. Line 214 creates duplicate target names in some cases. It needs to be scoped (like is done for the target just below it).

set(_pure_sources_target "${modules_target}.sources.${sources_target}")

Since this seems very specific to some tricky downstreams that are debugged ins-situ, I'm just going to push a quick fix.

Thanks!

[stellaraccident]

FYI - Another downstream issue fixed: https://reviews.llvm.org/D129434

mlir/cmake/modules/AddMLIRPython.cmake

 #     For relocatable sources, this will point deeper into the directory that
 #     can be relocated. For generated sources, can be relative to
 #     CMAKE_CURRENT_BINARY_DIR. Generated and non generated sources cannot be
 #     mixed.
 #   ADD_TO_PARENT: Adds this source grouping to a previously declared source
 #     grouping. Source groupings form a DAG.
 #   SOURCES: List of specific source files relative to ROOT_DIR to include.
 #   SOURCES_GLOB: List of glob patterns relative to ROOT_DIR to include.
-#   DEST_PREFIX: Destination prefix to prepend to files in the python
-#     package directory namespace.
 function(declare_mlir_python_sources name)
   cmake_parse_arguments(ARG
     ""
-    "ROOT_DIR;ADD_TO_PARENT;DEST_PREFIX"
+    "ROOT_DIR;ADD_TO_PARENT"
     "SOURCES;SOURCES_GLOB"
     ${ARGN})
 
   if(NOT ARG_ROOT_DIR)
     set(ARG_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
   endif()
   set(_install_destination "src/python/${name}")
 
   # Process the glob.
   set(_glob_sources)
   if(ARG_SOURCES_GLOB)
     set(_glob_spec ${ARG_SOURCES_GLOB})
     list(TRANSFORM _glob_spec PREPEND "${ARG_ROOT_DIR}/")
     file(GLOB_RECURSE _glob_sources
       RELATIVE "${ARG_ROOT_DIR}"
       ${_glob_spec}
     )
     list(APPEND ARG_SOURCES ${_glob_sources})
   endif()
 
   # We create a custom target to carry properties and dependencies for
   # generated sources.
   add_library(${name} INTERFACE)
-  set(_file_depends "${ARG_SOURCES}")
-  list(TRANSFORM _file_depends PREPEND "${ARG_ROOT_DIR}/")
   set_target_properties(${name} PROPERTIES
     # Yes: Leading-lowercase property names are load bearing and the recommended
     # way to do this: https://gitlab.kitware.com/cmake/cmake/-/issues/19261
-    # Note that ROOT_DIR and FILE_DEPENDS are not exported because they are
-    # only relevant to in-tree uses.
-    EXPORT_PROPERTIES "mlir_python_SOURCES_TYPE;mlir_python_DEST_PREFIX;mlir_python_ROOT_DIR;mlir_python_SOURCES;mlir_python_DEPENDS"
+    EXPORT_PROPERTIES "mlir_python_SOURCES_TYPE;mlir_python_DEPENDS"
     mlir_python_SOURCES_TYPE pure
-    mlir_python_ROOT_DIR "${ARG_ROOT_DIR}"
-    mlir_python_DEST_PREFIX "${ARG_DEST_PREFIX}"
-    mlir_python_SOURCES "${ARG_SOURCES}"
-    mlir_python_FILE_DEPENDS "${_file_depends}"
     mlir_python_DEPENDS ""
   )
-  # Note that an "include" directory has no meaning to such faux targets,
-  # but it is a CMake supported way to specify a directory search list in a
-  # way that works both in-tree and out. It has some super powers which are
-  # not possible to emulate with custom properties (because of the prohibition
-  # on using generator expressions in exported custom properties and the
-  # special dispensation for $<INSTALL_PREFIX>).
+
+  # Use the interface include directories and sources on the target to carry the
+  # properties we would like to export. These support generator expressions and
+  # allow us to properly specify paths in both the local build and install scenarios.
+  # The one caveat here is that because we don't directly build against the interface
+  # library, we need to specify the INCLUDE_DIRECTORIES and SOURCES properties as well
+  # via private properties because the evaluation would happen at configuration time
+  # instead of build time.
+  # Eventually this could be done using a FILE_SET simplifying the logic below.
+  # FILE_SET is available in cmake 3.23+, so it is not an option at the moment.
   target_include_directories(${name} INTERFACE
     "$<BUILD_INTERFACE:${ARG_ROOT_DIR}>"
     "$<INSTALL_INTERFACE:${_install_destination}>"
   )
+  set_property(TARGET ${name} PROPERTY INCLUDE_DIRECTORIES ${ARG_ROOT_DIR})
+
+  if(ARG_SOURCES)
+    list(TRANSFORM ARG_SOURCES PREPEND "${ARG_ROOT_DIR}/" OUTPUT_VARIABLE _build_sources)
+    list(TRANSFORM ARG_SOURCES PREPEND "${_install_destination}/" OUTPUT_VARIABLE _install_sources)
+    target_sources(${name}
+      INTERFACE
+        "$<INSTALL_INTERFACE:${_install_sources}>"
+        "$<BUILD_INTERFACE:${_build_sources}>"
+      PRIVATE ${_build_sources}
+    )
+  endif()
 
   # Add to parent.
   if(ARG_ADD_TO_PARENT)
     set_property(TARGET ${ARG_ADD_TO_PARENT} APPEND PROPERTY mlir_python_DEPENDS ${name})
   endif()
 
   # Install.
   set_property(GLOBAL APPEND PROPERTY MLIR_EXPORTS ${name})
if(NOT ARG_ROOT_DIR)
     set(ARG_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
   endif()
   set(_install_destination "src/python/${name}")
 
   add_library(${name} INTERFACE)
   set_target_properties(${name} PROPERTIES
     # Yes: Leading-lowercase property names are load bearing and the recommended
     # way to do this: https://gitlab.kitware.com/cmake/cmake/-/issues/19261
-    # Note that ROOT_DIR and FILE_DEPENDS are not exported because they are
-    # only relevant to in-tree uses.
-    EXPORT_PROPERTIES "mlir_python_SOURCES_TYPE;mlir_python_ROOT_DIR;mlir_python_EXTENSION_MODULE_NAME;mlir_python_CPP_SOURCES;mlir_python_PRIVATE_LINK_LIBS;mlir_python_EMBED_CAPI_LINK_LIBS;mlir_python_DEPENDS"
+    EXPORT_PROPERTIES "mlir_python_SOURCES_TYPE;mlir_python_EXTENSION_MODULE_NAME;mlir_python_EMBED_CAPI_LINK_LIBS;mlir_python_DEPENDS"
     mlir_python_SOURCES_TYPE extension
-    mlir_python_ROOT_DIR "${ARG_ROOT_DIR}"
     mlir_python_EXTENSION_MODULE_NAME "${ARG_MODULE_NAME}"
-    mlir_python_CPP_SOURCES "${ARG_SOURCES}"
-    mlir_python_PRIVATE_LINK_LIBS "${ARG_PRIVATE_LINK_LIBS}"
     mlir_python_EMBED_CAPI_LINK_LIBS "${ARG_EMBED_CAPI_LINK_LIBS}"
-    mlir_python_FILE_DEPENDS ""
     mlir_python_DEPENDS ""
   )
-  # Note that an "include" directory has no meaning to such faux targets,
-  # but it is a CMake supported way to specify an install-prefix relative
-  # directory. It has some super powers which are not possible to emulate
-  # with custom properties (because of the prohibition on using generator
-  # expressions in exported custom properties and the special dispensation
-  # for $<INSTALL_PREFIX> and $<INSTALL_INTERFACE>). On imported targets,
-  # this is used as a single value, not as a list, so it must only have one
-  # item in it.
-  target_include_directories(${name} INTERFACE
-    "$<INSTALL_INTERFACE:${_install_destination}>"
+
+  # Set the interface source and link_libs properties of the target
+  # These properties support generator expressions and are automatically exported
+  list(TRANSFORM ARG_SOURCES PREPEND "${ARG_ROOT_DIR}/" OUTPUT_VARIABLE _build_sources)
+  list(TRANSFORM ARG_SOURCES PREPEND "${_install_destination}/" OUTPUT_VARIABLE _install_sources)
+  target_sources(${name} INTERFACE
+    "$<BUILD_INTERFACE:${_build_sources}>"
+    "$<INSTALL_INTERFACE:${_install_sources}>"
+  )
+  target_link_libraries(${name} INTERFACE
+    ${ARG_PRIVATE_LINK_LIBS}
   )
 
   # Add to parent.
   if(ARG_ADD_TO_PARENT)
     set_property(TARGET ${ARG_ADD_TO_PARENT} APPEND PROPERTY mlir_python_DEPENDS ${name})
   endif()
 
   # Install.
   set_property(GLOBAL APPEND PROPERTY MLIR_EXPORTS ${name})
   if(NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     _mlir_python_install_sources(
-      ${name} "${ARG_ROOT_DIR}" "src/python/${name}"
+      ${name} "${ARG_ROOT_DIR}" "${_install_destination}"
       ${ARG_SOURCES}
     )
   endif()
 endfunction()
 
 function(_mlir_python_install_sources name source_root_dir destination)
   foreach(source_relative_path ${ARGN})
     # Transform "a/b/c.py" -> "${install_prefix}/a/b" for installation.
     get_filename_component(
-      dest_relative_path "${source_relative_path}" DIRECTORY
+      dest_relative_dir "${source_relative_path}" DIRECTORY
       BASE_DIR "${source_root_dir}"
     )
     install(
       FILES "${source_root_dir}/${source_relative_path}"
-      DESTINATION "${destination}/${dest_relative_path}"
+      DESTINATION "${destination}/${dest_relative_dir}"
       COMPONENT "${name}"
     )
   endforeach()
   get_target_export_arg(${name} MLIR export_to_mlirtargets UMBRELLA mlir-libraries)
   install(TARGETS ${name}
     COMPONENT ${name}
     ${export_to_mlirtargets}
   )
cmake_parse_arguments(ARG
     ""
     "ROOT_PREFIX;INSTALL_PREFIX;COMMON_CAPI_LINK_LIBS"
     "DECLARED_SOURCES"
     ${ARGN})
   # Helper to process an individual target.
   function(_process_target modules_target sources_target)
     get_target_property(_source_type ${sources_target} mlir_python_SOURCES_TYPE)
 
-    get_target_property(_python_root_dir ${sources_target} mlir_python_ROOT_DIR)
-    if(NOT _python_root_dir)
-      message(FATAL_ERROR "Target ${sources_target} lacks mlir_python_ROOT_DIR property")
-    endif()
-
     if(_source_type STREQUAL "pure")
       # Pure python sources to link into the tree.
-      get_target_property(_python_sources ${sources_target} mlir_python_SOURCES)
-      get_target_property(_specified_dest_prefix ${sources_target} mlir_python_DEST_PREFIX)
-      foreach(_source_relative_path ${_python_sources})
-        set(_dest_relative_path "${_source_relative_path}")
-        if(_specified_dest_prefix)
-          set(_dest_relative_path "${_specified_dest_prefix}/${_dest_relative_path}")
-        endif()
-        set(_src_path "${_python_root_dir}/${_source_relative_path}")
-        set(_dest_path "${ARG_ROOT_PREFIX}/${_dest_relative_path}")
-
-        get_filename_component(_dest_dir "${_dest_path}" DIRECTORY)
-        get_filename_component(_install_path "${ARG_INSTALL_PREFIX}/${_dest_relative_path}" DIRECTORY)
-
-        file(MAKE_DIRECTORY "${_dest_dir}")
-
-        # On Windows create_symlink requires special permissions. Use copy_if_different instead.
-        if(CMAKE_HOST_WIN32)
-          set(_link_or_copy copy_if_different)
-        else()
-          set(_link_or_copy create_symlink)
-        endif()
-
-        add_custom_command(
-          TARGET ${modules_target} PRE_BUILD
-          COMMENT "Copying python source ${_src_path} -> ${_dest_path}"
-          DEPENDS "${_src_path}"
-          BYPRODUCTS "${_dest_path}"
-          COMMAND "${CMAKE_COMMAND}" -E ${_link_or_copy}
-              "${_src_path}" "${_dest_path}"
-        )
-        install(
-          FILES "${_src_path}"
-          DESTINATION "${_install_path}"
-          COMPONENT ${modules_target}
-        )
-      endforeach()
+      set(_pure_sources_target "${sources_target}.sources")
+      add_mlir_python_sources_target(${_pure_sources_target}
+        INSTALL_COMPONENT ${modules_target}
+        INSTALL_DIR ${ARG_INSTALL_PREFIX}
+        OUTPUT_DIRECTORY ${ARG_ROOT_PREFIX}
+        SOURCES_TARGETS ${sources_target}
+      add_dependencies(${modules_target} ${_pure_sources_target})
     elseif(_source_type STREQUAL "extension")
       # Native CPP extension.
       get_target_property(_module_name ${sources_target} mlir_python_EXTENSION_MODULE_NAME)
-      get_target_property(_cpp_sources ${sources_target} mlir_python_CPP_SOURCES)
-      get_target_property(_private_link_libs ${sources_target} mlir_python_PRIVATE_LINK_LIBS)
       # Transform relative source to based on root dir.
-      list(TRANSFORM _cpp_sources PREPEND "${_python_root_dir}/")
-      set(_extension_target "${name}.extension.${_module_name}.dso")
+      set(_extension_target "${modules_target}.extension.${_module_name}.dso")
       add_mlir_python_extension(${_extension_target} "${_module_name}"
         INSTALL_COMPONENT ${modules_target}
         INSTALL_DIR "${ARG_INSTALL_PREFIX}/_mlir_libs"
         OUTPUT_DIRECTORY "${ARG_ROOT_PREFIX}/_mlir_libs"
-        SOURCES ${_cpp_sources}
         LINK_LIBS PRIVATE
-          ${_private_link_libs}
+          ${sources_target}
           ${ARG_COMMON_CAPI_LINK_LIBS}
       )
-      add_dependencies(${name} ${_extension_target})
+      add_dependencies(${modules_target} ${_extension_target})
       mlir_python_setup_extension_rpath(${_extension_target})
     else()
       message(SEND_ERROR "Unrecognized source type '${_source_type}' for python source target ${sources_target}")
       return()
     endif()
   endfunction()
 
-  _flatten_mlir_python_targets(_flat_targets ${ARG_DECLARED_SOURCES})
-  # Collect dependencies.
-  set(_depends)
-  foreach(sources_target ${_flat_targets})
-    get_target_property(_local_depends ${sources_target} mlir_python_FILE_DEPENDS)
-    if(_local_depends)
-      list(APPEND _depends ${_local_depends})
-    endif()
-  endforeach()
-
   # Build the modules target.
-  add_custom_target(${name} ALL DEPENDS ${_depends})
+  add_custom_target(${name} ALL)
+  _flatten_mlir_python_targets(_flat_targets ${ARG_DECLARED_SOURCES})
   foreach(sources_target ${_flat_targets})
     _process_target(${name} ${sources_target})
   endforeach()
 
   # Create an install target.
   if(NOT LLVM_ENABLE_IDE)
     add_llvm_install_targets(
       install-${name}
declare_mlir_python_sources(${_dialect_target}
     ROOT_DIR "${ARG_ROOT_DIR}"
     ADD_TO_PARENT "${ARG_ADD_TO_PARENT}"
     SOURCES "${ARG_SOURCES}"
     SOURCES_GLOB "${ARG_SOURCES_GLOB}"
   )
 
   # Tablegen
   if(ARG_TD_FILE)
-    set(tblgen_target "${ARG_ADD_TO}.${ARG_DIALECT_NAME}.tablegen")
+    set(tblgen_target "${_dialect_target}.tablegen")
     set(td_file "${ARG_ROOT_DIR}/${ARG_TD_FILE}")
     get_filename_component(relative_td_directory "${ARG_TD_FILE}" DIRECTORY)
     file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${relative_td_directory}")
     set(dialect_filename "${relative_td_directory}/_${ARG_DIALECT_NAME}_ops_gen.py")
     set(LLVM_TARGET_DEFINITIONS ${td_file})
-    mlir_tablegen("${dialect_filename}" -gen-python-op-bindings
-                  -bind-dialect=${ARG_DIALECT_NAME})
+    mlir_tablegen("${dialect_filename}"
+      -gen-python-op-bindings -bind-dialect=${ARG_DIALECT_NAME}
+      DEPENDS ${ARG_DEPENDS}
+    )
     add_public_tablegen_target(${tblgen_target})
-    if(ARG_DEPENDS)
-      add_dependencies(${tblgen_target} ${ARG_DEPENDS})
-    endif()
 
     # Generated.
-    declare_mlir_python_sources("${ARG_ADD_TO_PARENT}.${ARG_DIALECT_NAME}.ops_gen"
+    declare_mlir_python_sources("${_dialect_target}.ops_gen"
       ROOT_DIR "${CMAKE_CURRENT_BINARY_DIR}"
       ADD_TO_PARENT "${_dialect_target}"
       SOURCES "${dialect_filename}"
     )
   endif()
 endfunction()
 
 # Function: declare_mlir_dialect_extension_python_bindings

 #   INSTALL_COMPONENT: Name of the install component. Typically same as the
 #     target name passed to add_mlir_python_modules().
 #   INSTALL_DESTINATION: Prefix into the install tree in which to install the
 #     library.
 #   OUTPUT_DIRECTORY: Full path in the build tree in which to create the
 #     library. Typically, this will be the common _mlir_libs directory where
 #     all extensions are emitted.
 #   RELATIVE_INSTALL_ROOT: See mlir_python_setup_extension_rpath().
+#   DECLARED_HEADERS: Source groups from which to discover headers that belong
+#     to the library and should be installed with it.
 #   DECLARED_SOURCES: Source groups from which to discover dependent
 #     EMBED_CAPI_LINK_LIBS.
 #   EMBED_LIBS: Additional libraries to embed (must be built with OBJECTS and
 #     have an "obj.${name}" object library associated).
 function(add_mlir_python_common_capi_library name)
   cmake_parse_arguments(ARG
     ""
     "INSTALL_COMPONENT;INSTALL_DESTINATION;OUTPUT_DIRECTORY;RELATIVE_INSTALL_ROOT"
-    "DECLARED_SOURCES;EMBED_LIBS"
+    "DECLARED_HEADERS;DECLARED_SOURCES;EMBED_LIBS"
     ${ARGN})
   # Collect all explicit and transitive embed libs.
   set(_embed_libs ${ARG_EMBED_LIBS})
   _flatten_mlir_python_targets(_all_source_targets ${ARG_DECLARED_SOURCES})
   foreach(t ${_all_source_targets})
     get_target_property(_local_embed_libs ${t} mlir_python_EMBED_CAPI_LINK_LIBS)
     if(_local_embed_libs)
       list(APPEND _embed_libs ${_local_embed_libs})
     endif()
   endforeach()
   list(REMOVE_DUPLICATES _embed_libs)
 
   # Generate the aggregate .so that everything depends on.
   add_mlir_aggregate(${name}
     SHARED
     DISABLE_INSTALL
     EMBED_LIBS ${_embed_libs}
   )
 
+  # Process any headers associated with the library
+  _flatten_mlir_python_targets(_flat_header_targets ${ARG_DECLARED_HEADERS})
+  set(_header_sources_target "${name}.sources")
+  add_mlir_python_sources_target(${_header_sources_target}
+    INSTALL_COMPONENT ${ARG_INSTALL_COMPONENT}
+    INSTALL_DIR "${ARG_INSTALL_DESTINATION}/include"
+    OUTPUT_DIRECTORY "${ARG_OUTPUT_DIRECTORY}/include"
+    SOURCES_TARGETS ${_flat_header_targets}
+  )
+  add_dependencies(${name} ${_header_sources_target})
+
   if(MSVC)
     set_property(TARGET ${name} PROPERTY WINDOWS_EXPORT_ALL_SYMBOLS ON)
   endif()
   set_target_properties(${name} PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${ARG_OUTPUT_DIRECTORY}"
     BINARY_OUTPUT_DIRECTORY "${ARG_OUTPUT_DIRECTORY}"
     # Needed for windows (and don't hurt others).
     RUNTIME_OUTPUT_DIRECTORY "${ARG_OUTPUT_DIRECTORY}"
     ARCHIVE_OUTPUT_DIRECTORY "${ARG_OUTPUT_DIRECTORY}"
   )
   mlir_python_setup_extension_rpath(${name}
     RELATIVE_INSTALL_ROOT "${ARG_RELATIVE_INSTALL_ROOT}"
   )
   install(TARGETS ${name}
     COMPONENT ${ARG_INSTALL_COMPONENT}
     LIBRARY DESTINATION "${ARG_INSTALL_DESTINATION}"
     RUNTIME DESTINATION "${ARG_INSTALL_DESTINATION}"
   )
-
 endfunction()
 
 function(_flatten_mlir_python_targets output_var)
   set(_flattened)
   foreach(t ${ARGN})
     get_target_property(_source_type ${t} mlir_python_SOURCES_TYPE)
     get_target_property(_depends ${t} mlir_python_DEPENDS)
     if(_source_type)
       list(APPEND _flattened "${t}")
       if(_depends)
         _flatten_mlir_python_targets(_local_flattened ${_depends})
         list(APPEND _flattened ${_local_flattened})
       endif()
     endif()
   endforeach()
   list(REMOVE_DUPLICATES _flattened)
   set(${output_var} "${_flattened}" PARENT_SCOPE)
 endfunction()
 
+# Function: add_mlir_python_sources_target
+# Adds a target corresponding to an interface target that carries source
+# information. This target is responsible for "building" the sources by
+# placing them in the correct locations in the build and install trees.
+# Arguments:
+#   INSTALL_COMPONENT: Name of the install component. Typically same as the
+#     target name passed to add_mlir_python_modules().
+#   INSTALL_DESTINATION: Prefix into the install tree in which to install the
+#     library.
+#   OUTPUT_DIRECTORY: Full path in the build tree in which to create the
+#     library. Typically, this will be the common _mlir_libs directory where
+#     all extensions are emitted.
+#   SOURCES_TARGETS: List of interface libraries that carry source information.
+function(add_mlir_python_sources_target name)
+  cmake_parse_arguments(ARG
+  ""
+  "INSTALL_COMPONENT;INSTALL_DIR;OUTPUT_DIRECTORY"
+  "SOURCES_TARGETS"
+  ${ARGN})
+
+  if(ARG_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unhandled arguments to add_mlir_python_sources_target(${name}, ... : ${ARG_UNPARSED_ARGUMENTS}")
+  endif()
+
+  add_custom_target(${name})
+
+  # On Windows create_symlink requires special permissions. Use copy_if_different instead.
+  if(CMAKE_HOST_WIN32)
+    set(_link_or_copy copy_if_different)
+  else()
+    set(_link_or_copy create_symlink)
+  endif()
+
+  foreach(_sources_target ${ARG_SOURCES_TARGETS})
+    add_dependencies(${name} ${_sources_target})
+
+    get_target_property(_src_paths ${_sources_target} SOURCES)
+    if(NOT _src_paths)
+      get_target_property(_src_paths ${_sources_target} INTERFACE_SOURCES)
+      if(NOT _src_paths)
+        break()
+      endif()
+    endif()
+
+    get_target_property(_root_dir ${_sources_target} INCLUDE_DIRECTORIES)
+    if(NOT _root_dir)
+      get_target_property(_root_dir ${_sources_target} INTERFACE_INCLUDE_DIRECTORIES)
+    endif()
+
+    foreach(_src_path ${_src_paths})
+      file(RELATIVE_PATH _source_relative_path "${_root_dir}" "${_src_path}")
+      set(_dest_path "${ARG_OUTPUT_DIRECTORY}/${_source_relative_path}")
+
+      get_filename_component(_dest_dir "${_dest_path}" DIRECTORY)
+      file(MAKE_DIRECTORY "${_dest_dir}")
+
+      add_custom_command(
+        TARGET ${name} PRE_BUILD
+        COMMENT "Copying python source ${_src_path} -> ${_dest_path}"
+        DEPENDS "${_src_path}"
+        BYPRODUCTS "${_dest_path}"
+        COMMAND "${CMAKE_COMMAND}" -E ${_link_or_copy}
+            "${_src_path}" "${_dest_path}"
+      )
+    endforeach()
+
+    if(ARG_INSTALL_DIR)
+      install(
+        FILES ${_src_paths}
+        DESTINATION "${ARG_INSTALL_DIR}"
+        COMPONENT ${ARG_INSTALL_COMPONENT}
+      )
+    endif()
+  endforeach()
+endfunction()
+
 ################################################################################
 # Build python extension
 ################################################################################
 function(add_mlir_python_extension libname extname)
   cmake_parse_arguments(ARG
   ""
   "INSTALL_COMPONENT;INSTALL_DIR;OUTPUT_DIRECTORY"
   "SOURCES;LINK_LIBS"
   ${ARGN})
   if(ARG_UNPARSED_ARGUMENTS)
-    message(FATAL_ERROR " Unhandled arguments to add_mlir_python_extension(${libname}, ... : ${ARG_UNPARSED_ARGUMENTS}")
+    message(FATAL_ERROR "Unhandled arguments to add_mlir_python_extension(${libname}, ... : ${ARG_UNPARSED_ARGUMENTS}")
   endif()
-  if("${ARG_SOURCES}" STREQUAL "")
-    message(FATAL_ERROR " Missing SOURCES argument to add_mlir_python_extension(${libname}, ...")
-  endif()
 
   # The actual extension library produces a shared-object or DLL and has
   # sources that must be compiled in accordance with pybind11 needs (RTTI and
   # exceptions).
   pybind11_add_module(${libname}
     ${ARG_SOURCES}
   )
 

mlir/lib/Dialect/Affine/Analysis/CMakeLists.txt

 add_mlir_dialect_library(MLIRAffineAnalysis
   AffineAnalysis.cpp
   AffineStructures.cpp
   LoopAnalysis.cpp
   NestedMatcher.cpp
   Utils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine
 
-  DEPENDS
-  mlir-headers
-
   LINK_LIBS PUBLIC
   MLIRAffineDialect
   MLIRAnalysis
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIRInferTypeOpInterface
   MLIRPresburger
   MLIRSCFDialect
   )

mlir/python/CMakeLists.txt

declare_mlir_python_sources(MLIRPythonSources.Passes
   ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir"
   ADD_TO_PARENT MLIRPythonSources
   SOURCES_GLOB
     all_passes_registration/*.py
     conversions/*.py
     transforms/*.py
 )
 
-declare_mlir_python_sources(MLIRPythonCAPIHeaderSources
-  ROOT_DIR "${MLIR_SOURCE_DIR}/include"
+declare_mlir_python_sources(MLIRPythonCAPI.HeaderSources
+  ROOT_DIR "${MLIR_MAIN_INCLUDE_DIR}"
   SOURCES_GLOB "mlir-c/*.h"
-  DEST_PREFIX "_mlir_libs/include"
 )
 
 ################################################################################
 # Dialect bindings
 ################################################################################
 
 declare_mlir_dialect_python_bindings(
   ADD_TO_PARENT MLIRPythonSources.Dialects

 # once ready.
 ################################################################################
 
 add_mlir_python_common_capi_library(MLIRPythonCAPI
   INSTALL_COMPONENT MLIRPythonModules
   INSTALL_DESTINATION python_packages/mlir_core/mlir/_mlir_libs
   OUTPUT_DIRECTORY "${MLIR_BINARY_DIR}/python_packages/mlir_core/mlir/_mlir_libs"
   RELATIVE_INSTALL_ROOT "../../../.."
+  DECLARED_HEADERS
+    MLIRPythonCAPI.HeaderSources
   DECLARED_SOURCES
     MLIRPythonSources
     MLIRPythonExtension.AllPassesRegistration
     ${_ADDL_TEST_SOURCES}
 )
 
 ################################################################################
 # The fully assembled package of modules.
 # This must come last.
 ################################################################################
 
 add_mlir_python_modules(MLIRPythonModules
   ROOT_PREFIX "${MLIR_BINARY_DIR}/python_packages/mlir_core/mlir"
   INSTALL_PREFIX "python_packages/mlir_core/mlir"
   DECLARED_SOURCES
     MLIRPythonSources
     MLIRPythonExtension.AllPassesRegistration
-    MLIRPythonCAPIHeaderSources
     ${_ADDL_TEST_SOURCES}
   COMMON_CAPI_LINK_LIBS
     MLIRPythonCAPI
-  )