[Sema] Introduce function reference conversion, NFC

[aaronpuchert]

Summary

Technically 'noexcept' isn't a qualifier, so this should be a separate conversion.

Also add a pure AST test for the conversion.

[aaronpuchert]

If anyone shares my feeling that the boolean output parameters of CompareReferenceRelationship should rather move to the return value, I would be happy to do that.

clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p4-ast.cpp

6

This is new.

16

This is also new.

[aaronpuchert]

Perhaps I should mention that this fixes an assertion failure.

[aaronpuchert]

In D67112#1655937, @aaronpuchert wrote:

If anyone shares my feeling that the boolean output parameters of CompareReferenceRelationship should rather move to the return value, I would be happy to do that.

I'll do that in a separate change and then rebase this on top.

[aaronpuchert]

Already fixed via D66437.

[aaronpuchert]

The diff between both changes might still be interesting.

[aaronpuchert]

Rebase on top of D66437.

[aaronpuchert]

@rsmith, what do you think about this?

[aaronpuchert]

Ping. Maybe this change is too silly, but I think it's better to be precise and not muddle qualification conversions together with casting away noexcept.

[aaronpuchert]

Ping.

[rsmith]

Looks fine as far as it goes, but it looks like we're also missing a cast in function pointer initialization via function conversion:

void f() noexcept;
void (*p)() = f;

results in

|-VarDecl 0x105143e8 <line:2:1, col:15> col:8 p 'void (*)()' cinit
| `-ImplicitCastExpr 0x10514498 <col:15> 'void (*)() noexcept' <FunctionToPointerDecay>
|   `-DeclRefExpr 0x10514450 <col:15> 'void () noexcept' lvalue Function 0x10514240 'f' 'void () noexcept'

[aaronpuchert]

In D67112#2398577, @rsmith wrote:

Looks fine as far as it goes, but it looks like we're also missing a cast in function pointer initialization via function conversion:
[...]

|-VarDecl 0x105143e8 <line:2:1, col:15> col:8 p 'void (*)()' cinit
| `-ImplicitCastExpr 0x10514498 <col:15> 'void (*)() noexcept' <FunctionToPointerDecay>
|   `-DeclRefExpr 0x10514450 <col:15> 'void () noexcept' lvalue Function 0x10514240 'f' 'void () noexcept'

It seems to depend on the standard, with -std=c++17:

|-VarDecl p 'void (*)()' cinit
| `-ImplicitCastExpr 'void (*)()' <NoOp>
|   `-ImplicitCastExpr 'void (*)() noexcept' <FunctionToPointerDecay>
|     `-DeclRefExpr 'void () noexcept' lvalue Function 'f' 'void () noexcept'

Perhaps because pre-C++17 noexcept is not part of the type, so we essentially ignore it?

[rsmith]

In D67112#2401110, @aaronpuchert wrote:

In D67112#2398577, @rsmith wrote:

Looks fine as far as it goes, but it looks like we're also missing a cast in function pointer initialization via function conversion:
[...]

|-VarDecl 0x105143e8 <line:2:1, col:15> col:8 p 'void (*)()' cinit
| `-ImplicitCastExpr 0x10514498 <col:15> 'void (*)() noexcept' <FunctionToPointerDecay>
|   `-DeclRefExpr 0x10514450 <col:15> 'void () noexcept' lvalue Function 0x10514240 'f' 'void () noexcept'

It seems to depend on the standard, with -std=c++17:

|-VarDecl p 'void (*)()' cinit
| `-ImplicitCastExpr 'void (*)()' <NoOp>
|   `-ImplicitCastExpr 'void (*)() noexcept' <FunctionToPointerDecay>
|     `-DeclRefExpr 'void () noexcept' lvalue Function 'f' 'void () noexcept'

Perhaps because pre-C++17 noexcept is not part of the type, so we essentially ignore it?

Oh, right, my bad. I forgot we still default to C++14 :)

clang/include/clang/AST/OperationKinds.def

 CAST_OPERATION(LValueToRValueBitCast)
 
 /// CK_LValueToRValue - A conversion which causes the extraction of
 /// an r-value from the operand gl-value.  The result of an r-value
 /// conversion is always unqualified.
 CAST_OPERATION(LValueToRValue)
 
 /// CK_NoOp - A conversion which does not affect the type other than
-/// (possibly) adding qualifiers.
+/// (possibly) adding qualifiers or removing noexcept.
 ///   int    -> int
 ///   char** -> const char * const *
+///   void () noexcept -> void ()
 CAST_OPERATION(NoOp)
 
 /// CK_BaseToDerived - A conversion from a C++ class pointer/reference
 /// to a derived class pointer/reference.
 ///   B *b = static_cast<B*>(a);
 CAST_OPERATION(BaseToDerived)
 
 /// CK_DerivedToBase - A conversion from a C++ class pointer

clang/include/clang/Sema/Initialization.h

enum StepKind {
     SK_QualificationConversionRValue,
 
     /// Perform a qualification conversion, producing an xvalue.
     SK_QualificationConversionXValue,
 
     /// Perform a qualification conversion, producing an lvalue.
     SK_QualificationConversionLValue,
 
+    /// Perform a function reference conversion, see [dcl.init.ref]p4.
+    SK_FunctionReferenceConversion,
+
     /// Perform a conversion adding _Atomic to a type.
     SK_AtomicConversion,
 
     /// Perform an implicit conversion sequence.
     SK_ConversionSequence,
 
     /// Perform an implicit conversion sequence without narrowing.
     SK_ConversionSequenceNoNarrowing,
void AddUserConversionStep(FunctionDecl *Function,
                              QualType T,
                              bool HadMultipleCandidates);
 
   /// Add a new step that performs a qualification conversion to the
   /// given type.
   void AddQualificationConversionStep(QualType Ty,
                                      ExprValueKind Category);
 
+  /// Add a new step that performs a function reference conversion to the
+  /// given type.
+  void AddFunctionReferenceConversionStep(QualType Ty);
+
   /// Add a new step that performs conversion from non-atomic to atomic
   /// type.
   void AddAtomicConversionStep(QualType Ty);
 
   /// Add a new step that applies an implicit conversion sequence.
   void AddConversionSequenceStep(const ImplicitConversionSequence &ICS,
                                  QualType T, bool TopLevelOfInitList = false);
 

clang/lib/Sema/SemaInit.cpp

void InitializationSequence::Step::Destroy() {
   case SK_BindReference:
   case SK_BindReferenceToTemporary:
   case SK_FinalCopy:
   case SK_ExtraneousCopyToTemporary:
   case SK_UserConversion:
   case SK_QualificationConversionRValue:
   case SK_QualificationConversionXValue:
   case SK_QualificationConversionLValue:
+  case SK_FunctionReferenceConversion:
   case SK_AtomicConversion:
   case SK_ListInitialization:
   case SK_UnwrapInitList:
   case SK_RewrapInitList:
   case SK_ConstructorInitialization:
   case SK_ConstructorInitializationFromList:
   case SK_ZeroInitialization:
   case SK_CAssignment:
void InitializationSequence::AddQualificationConversionStep(QualType Ty,
   case VK_LValue:
     S.Kind = SK_QualificationConversionLValue;
     break;
   }
   S.Type = Ty;
   Steps.push_back(S);
 }
 
+void InitializationSequence::AddFunctionReferenceConversionStep(QualType Ty) {
+  Step S;
+  S.Kind = SK_FunctionReferenceConversion;
+  S.Type = Ty;
+  Steps.push_back(S);
+}
+
 void InitializationSequence::AddAtomicConversionStep(QualType Ty) {
   Step S;
   S.Kind = SK_AtomicConversion;
   S.Type = Ty;
   Steps.push_back(S);
 }
 
 void InitializationSequence::AddConversionSequenceStep(
static OverloadingResult TryRefInitWithConversionFunction(
   Sequence.AddReferenceBindingStep(cv1T4, VK == VK_RValue);
   VK = IsLValueRef ? VK_LValue : VK_XValue;
 
   if (RefConv & Sema::ReferenceConversions::DerivedToBase)
     Sequence.AddDerivedToBaseCastStep(cv1T1, VK);
   else if (RefConv & Sema::ReferenceConversions::ObjC)
     Sequence.AddObjCObjectConversionStep(cv1T1);
   else if (RefConv & Sema::ReferenceConversions::Function)
-    Sequence.AddQualificationConversionStep(cv1T1, VK);
+    Sequence.AddFunctionReferenceConversionStep(cv1T1);
   else if (RefConv & Sema::ReferenceConversions::Qualification) {
     if (!S.Context.hasSameType(cv1T4, cv1T1))
       Sequence.AddQualificationConversionStep(cv1T1, VK);
   }
 
   return OR_Success;
 }
 
if (InitCategory.isLValue() && !isNonReferenceableGLValue(Initializer) &&
         if (RefConv & (Sema::ReferenceConversions::Qualification))
           Sequence.AddQualificationConversionStep(
               S.Context.getQualifiedType(T2, T1Quals),
               Initializer->getValueKind());
         if (RefConv & Sema::ReferenceConversions::DerivedToBase)
           Sequence.AddDerivedToBaseCastStep(cv1T1, VK_LValue);
         else
           Sequence.AddObjCObjectConversionStep(cv1T1);
-      } else if (RefConv & (Sema::ReferenceConversions::Qualification |
-                            Sema::ReferenceConversions::Function)) {
+      } else if (RefConv & Sema::ReferenceConversions::Qualification) {
         // Perform a (possibly multi-level) qualification conversion.
-        // FIXME: Should we use a different step kind for function conversions?
         Sequence.AddQualificationConversionStep(cv1T1,
                                                 Initializer->getValueKind());
+      } else if (RefConv & Sema::ReferenceConversions::Function) {
+        Sequence.AddFunctionReferenceConversionStep(cv1T1);
       }
 
       // We only create a temporary here when binding a reference to a
       // bit-field or vector element. Those cases are't supposed to be
       // handled by this bullet, but the outcome is the same either way.
       Sequence.AddReferenceBindingStep(cv1T1, false);
       return;
     }
ExprResult InitializationSequence::Perform(Sema &S,
   case SK_BindReference:
   case SK_BindReferenceToTemporary:
   case SK_FinalCopy:
   case SK_ExtraneousCopyToTemporary:
   case SK_UserConversion:
   case SK_QualificationConversionLValue:
   case SK_QualificationConversionXValue:
   case SK_QualificationConversionRValue:
+  case SK_FunctionReferenceConversion:
   case SK_AtomicConversion:
   case SK_ConversionSequence:
   case SK_ConversionSequenceNoNarrowing:
   case SK_ListInitialization:
   case SK_UnwrapInitList:
   case SK_RewrapInitList:
   case SK_CAssignment:
   case SK_StringInit:
case SK_QualificationConversionRValue: {
           Step->Kind == SK_QualificationConversionLValue
               ? VK_LValue
               : (Step->Kind == SK_QualificationConversionXValue ? VK_XValue
                                                                 : VK_RValue);
       CurInit = S.PerformQualificationConversion(CurInit.get(), Step->Type, VK);
       break;
     }
 
+    case SK_FunctionReferenceConversion:
+      assert(CurInit.get()->isLValue() &&
+             "function reference should be lvalue");
+      CurInit =
+          S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK_LValue);
+      break;
+
     case SK_AtomicConversion: {
       assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
                                     CK_NonAtomicToAtomic, VK_RValue);
       break;
     }
 
     case SK_ConversionSequence:
for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
     case SK_QualificationConversionXValue:
       OS << "qualification conversion (xvalue)";
       break;
 
     case SK_QualificationConversionLValue:
       OS << "qualification conversion (lvalue)";
       break;
 
+    case SK_FunctionReferenceConversion:
+      OS << "function reference conversion";
+      break;
+
     case SK_AtomicConversion:
       OS << "non-atomic-to-atomic conversion";
       break;
 
     case SK_ConversionSequence:
       OS << "implicit conversion sequence (";
       S->ICS->dump(); // FIXME: use OS
       OS << ")";

clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p4-ast.cpp

+// RUN: %clang_cc1 -std=c++17 -ast-dump %s | FileCheck %s
+
+void f() noexcept;
+
+// CHECK: VarDecl {{.*}} ref 'void (&)()' cinit
+// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void ()':'void ()' lvalue <NoOp>
+// CHECK-NEXT: DeclRefExpr {{.*}} 'void () noexcept' lvalue Function {{.*}} 'f' 'void () noexcept'
+void (&ref)() = f;
+
+struct X {
+  typedef void (&ref)() noexcept;
+  operator ref();
+} x;
+
+// CHECK: VarDecl {{.*}} xp 'void (&)()' cinit
+// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void ()':'void ()' lvalue <NoOp>
+// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void () noexcept':'void () noexcept' lvalue <UserDefinedConversion>
+void (&xp)() = x;

clang/test/CodeGenCXX/implicit-function-conversion.cpp

-// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-unknown-linux -std=c++17 | FileCheck %s
-
-double a(double) noexcept;
-int b(double (&)(double));
-
-// CHECK: call i32 @_Z1bRFddE(double (double)* nonnull @_Z1ad)
-int c = b(a);