[clang] ODR violation with header modules and template conversion operator

[emaxx-google]

Reproducer:

// RUN: rm -rf %t
// RUN: mkdir %t
// RUN: split-file %s %t
//
// RUN: cd %t
//
// RUN: %clang_cc1 -fmodules -fno-implicit-modules -fmodule-name=//small \
// RUN:     -fmodule-map-file=module-small.cppmap -xc++ module-small.cppmap -emit-module -o module-small.pcm
// RUN: %clang_cc1 -fmodules -fno-implicit-modules -fmodule-name=//large \
// RUN:     -fmodule-map-file=module-large.cppmap -xc++ module-large.cppmap -emit-module -o module-large.pcm
// RUN: %clang_cc1 -fmodules -fno-implicit-modules \
// RUN:     -fmodule-map-file=module-small.cppmap -fmodule-map-file=module-large.cppmap \
// RUN:     -fmodule-file=module-small.pcm -fmodule-file=module-large.pcm -xc++ \
// RUN:     main.cc

//--- class-with-operator.h
#ifndef CLASS_WITH_OPERATOR_H
#define CLASS_WITH_OPERATOR_H

#include "func.h"

class Foo {
  template <class T>
  operator decltype(func<T>()) () {}
};

#endif

//--- func.h
#ifndef FUNC_H
#define FUNC_H

template <class T>
T func();

#endif

//--- main.cc
#include "class-with-operator.h"

//--- module-large.cppmap
module "//large" {
header "module-large.h"
}

//--- module-large.h
#include "unrelated-alias.h"
#include "class-with-operator.h"

//--- module-small.cppmap
module "//small" {
header "module-small.h"
}

//--- module-small.h
#include "class-with-operator.h"

//--- unrelated-alias.h
#ifndef UNRELATED_ALIAS_H
#define UNRELATED_ALIAS_H

#include "func.h"

template <class UnrelatedT>
using UnrelatedAlias = decltype(func<UnrelatedT>())();

#endif

This currently causes a compilation error:

In module '//small':
./class-with-operator.h:8:3: error: 'Foo' with definition in module '//small' has different definitions in different modules; first difference is this function template
    7 |   template <class T>
      |   ~~~~~~~~~~~~~~~~~~
    8 |   operator decltype(func<T>()) () {}
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
./class-with-operator.h:8:3: note: but in '//large' found different function template
    7 |   template <class T>
      |   ~~~~~~~~~~~~~~~~~~
    8 |   operator decltype(func<T>()) () {}
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[llvmbot]

@llvm/issue-subscribers-clang-modules

Author: Maksim Ivanov (emaxx-google)

Reproducer:

// RUN: rm -rf %t
// RUN: mkdir %t
// RUN: split-file %s %t
//
// RUN: cd %t
//
// RUN: %clang_cc1 -fmodules -fno-implicit-modules -fmodule-name=//small \
// RUN:     -fmodule-map-file=module-small.cppmap -xc++ module-small.cppmap -emit-module -o module-small.pcm
// RUN: %clang_cc1 -fmodules -fno-implicit-modules -fmodule-name=//large \
// RUN:     -fmodule-map-file=module-large.cppmap -xc++ module-large.cppmap -emit-module -o module-large.pcm
// RUN: %clang_cc1 -fmodules -fno-implicit-modules \
// RUN:     -fmodule-map-file=module-small.cppmap -fmodule-map-file=module-large.cppmap \
// RUN:     -fmodule-file=module-small.pcm -fmodule-file=module-large.pcm -xc++ \
// RUN:     main.cc

//--- class-with-operator.h
#ifndef CLASS_WITH_OPERATOR_H
#define CLASS_WITH_OPERATOR_H

#include "func.h"

class Foo {
  template <class T>
  operator decltype(func<T>()) () {}
};

#endif

//--- func.h
#ifndef FUNC_H
#define FUNC_H

template <class T>
T func();

#endif

//--- main.cc
#include "class-with-operator.h"

//--- module-large.cppmap
module "//large" {
header "module-large.h"
}

//--- module-large.h
#include "unrelated-alias.h"
#include "class-with-operator.h"

//--- module-small.cppmap
module "//small" {
header "module-small.h"
}

//--- module-small.h
#include "class-with-operator.h"

//--- unrelated-alias.h
#ifndef UNRELATED_ALIAS_H
#define UNRELATED_ALIAS_H

#include "func.h"

template <class UnrelatedT>
using UnrelatedAlias = decltype(func<UnrelatedT>())();

#endif

This currently causes a compilation error:

In module '//small':
./class-with-operator.h:8:3: error: 'Foo' with definition in module '//small' has different definitions in different modules; first difference is this function template
    7 |   template <class T>
      |   ~~~~~~~~~~~~~~~~~~
    8 |   operator decltype(func<T>()) () {}
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
./class-with-operator.h:8:3: note: but in '//large' found different function template
    7 |   template <class T>
      |   ~~~~~~~~~~~~~~~~~~
    8 |   operator decltype(func<T>()) () {}
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[emaxx-google]

In the reproducer, the mere presence of the (otherwise unused) alias UnrelatedAlias = decltype(func<UnrelatedT>())() in one of the modules causes the ODR violation of the operator that uses the subexpression decltype(func<T>()).

Debugging shows that when compiling the large module, in Sema::GetNameFromUnqualifiedId() the original AST structure:

DecltypeType 0x11d57fd23b70 'decltype(func<T>())' dependent
`-CallExpr 0x11d57fd23b48 '<dependent type>'
  `-UnresolvedLookupExpr 0x11d57fd23ad0 '<dependent type>' lvalue (ADL) = 'func' 0x11d57fd233e8
    `-TemplateArgument type 'T'
      `-TemplateTypeParmType 0x11d57fd23a70 'T' dependent depth 0 index 0
        `-TemplateTypeParm 0x11d57fd23a20 'T'

gets replaced with a canonical type that's originating from the spelling used in the type alias:

DecltypeType 0x11d57fd23680 'decltype(func<type-parameter-0-0>())' dependent
`-CallExpr 0x11d57fd23660 '<dependent type>'
  `-UnresolvedLookupExpr 0x11d57fd235e8 '<dependent type>' lvalue (ADL) = 'func' 0x11d57fd233e8
    `-TemplateArgument type 'UnrelatedT'
      `-TemplateTypeParmType 0x11d57fd23570 'UnrelatedT' dependent depth 0 index 0
        `-TemplateTypeParm 0x11d57fd23518 'UnrelatedT'

This doesn't happen when compiling the small module - it doesn't have other usages of decltype(func<...>()) hence the canonicalization keeps using the T spelling of the template argument.

This discrepancy causes the ODR hash of the conversion operator to be different across modules small and large.

[emaxx-google]

I'm still unsure about the proper solution here... From the type canonicalization perspective, template <class T> ... decltype(func<T>()) is indeed the same as template <class UnrelatedT> ... decltype(func<UnrelatedT>()). And the necessity to canonicalize conversion operators (IK_ConversionFunctionId) in Sema::GetNameFromUnqualifiedId() seems to be crucial for properly looking up conversion operator calls. However these two contradict with the assumptions used for the ODR hash calculation, which becomes different depending on whether unused-but-similar types are present in a given module.

---

I've found that the decltype canonicalization seems to be done in a special way:

llvm-project/clang/lib/AST/ASTContext.cpp

Line 6437 in e4de74b

QualType ASTContext::getDecltypeType(Expr *E, QualType UnderlyingType) const {

where the comment says:

/// Unlike many "get<Type>" functions, we don't unique DecltypeType
/// nodes. This would never be helpful, since each such type has its own
/// expression, and would not give a significant memory saving, since there
/// is an Expr tree under each such type.

Does anyone know if changing the behavior here - actually creating unique nodes - would be viable?

[emaxx-google]

For what it's worth, when I tried reformulating the reproducer in terms of C++20 Module Header Units, I discovered that it reproduces the problem on Clang 19 but does NOT reproduce it on tip-of-the-tree. Investigation pointed to the following commit which, as it turns out, leaves ODR checks disabled there: #111160 [RFC][C++20][Modules] Relax ODR check in unnamed modules.