Switch initialization of parameters in a call over to

InitializationSequence (when a FunctionDecl is present). This required
a few small fixes to initialization sequences:

  - Make sure to use the adjusted parameter type for initialization of
  function parameters.
  - Implement transparent union calling semantics in C

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@91902 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 181d6d1c8f8a24a4a8581f1d87a6a221e2b09bad..718d5ab577bdd4ca005a04e0a029d1fed23d1556 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -3182,8 +3182,20 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc,
         return true;
       
       // Pass the argument.
-      if (PerformCopyInitialization(Arg, ProtoArgType, AA_Passing))
-        return true;
+      if (FDecl && i < FDecl->getNumParams()) {
+        ParmVarDecl *Param = FDecl->getParamDecl(i);
+        InitializedEntity Entity =InitializedEntity::InitializeParameter(Param);
+        OwningExprResult ArgE = PerformCopyInitialization(Entity,
+                                                          SourceLocation(),
+                                                          Owned(Arg));
+        if (ArgE.isInvalid())
+          return true;
+
+        Arg = ArgE.takeAs<Expr>();
+      } else {
+        if (PerformCopyInitialization(Arg, ProtoArgType, AA_Passing))
+          return true;
+      }
       
       if (!ProtoArgType->isReferenceType())
         Arg = MaybeBindToTemporary(Arg).takeAs<Expr>();

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 80cfc3637e407caa00a83e537316ee8f287039df..f831b4151213da8c89d3e815172b5b20aec6a01e 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -1811,8 +1811,15 @@ InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
 void InitializedEntity::InitDeclLoc() {
   assert((Kind == EK_Variable || Kind == EK_Parameter || Kind == EK_Member) &&
          "InitDeclLoc cannot be used with non-declaration entities.");
-  
-  if (TypeSourceInfo *DI = VariableOrMember->getTypeSourceInfo()) {
+
+  ASTContext &Context = VariableOrMember->getASTContext();
+  if (Kind == EK_Parameter &&
+      !Context.hasSameUnqualifiedType(
+                     cast<ParmVarDecl>(VariableOrMember)->getOriginalType(),
+                     VariableOrMember->getType())) {
+    // For a parameter whose type has decayed, use the decayed type to
+    // build new source information.
+  } else if (TypeSourceInfo *DI = VariableOrMember->getTypeSourceInfo()) {
     TL = DI->getTypeLoc();
     return;
   }
@@ -1820,8 +1827,8 @@ void InitializedEntity::InitDeclLoc() {
   // FIXME: Once we've gone through the effort to create the fake 
   // TypeSourceInfo, should we cache it in the declaration?
   // (If not, we "leak" it).
-  TypeSourceInfo *DI = VariableOrMember->getASTContext()
-                             .CreateTypeSourceInfo(VariableOrMember->getType());
+  TypeSourceInfo *DI
+    = Context.CreateTypeSourceInfo(VariableOrMember->getType());
   DI->getTypeLoc().initialize(VariableOrMember->getLocation());
   TL = DI->getTypeLoc();
 }
@@ -3346,6 +3353,14 @@ InitializationSequence::Perform(Sema &S,
       QualType SourceType = CurInitExpr->getType();
       Sema::AssignConvertType ConvTy =
         S.CheckSingleAssignmentConstraints(Step->Type, CurInitExpr);
+
+      // If this is a call, allow conversion to a transparent union.
+      if (ConvTy != Sema::Compatible &&
+          Entity.getKind() == InitializedEntity::EK_Parameter &&
+          S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExpr)
+            == Sema::Compatible)
+        ConvTy = Sema::Compatible;
+
       if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
                                      Step->Type, SourceType,
                                      CurInitExpr, getAssignmentAction(Entity)))

diff --git a/test/SemaCXX/conditional-expr.cpp b/test/SemaCXX/conditional-expr.cpp
index 0f71b494661fe35448e66ffffa56d99da60acee3..0617cd5702c658a0bc7e64e5ae8dd78366ae8480 100644 (file)
--- a/test/SemaCXX/conditional-expr.cpp
+++ b/test/SemaCXX/conditional-expr.cpp
@@ -25,7 +25,7 @@ struct Derived : Base {
   void fn2();
 };
 struct Convertible { operator Base&(); };
-struct Priv : private Base {}; // expected-note 2 {{'private' inheritance specifier here}}
+struct Priv : private Base {}; // expected-note 4 {{'private' inheritance specifier here}}
 struct Mid : Base {};
 struct Fin : Mid, Derived {};
 typedef void (Derived::*DFnPtr)();
@@ -109,13 +109,12 @@ void test()
   (void)(i1 ? Base() : constder()); // expected-error {{incompatible operand types ('struct Base' and 'struct Derived const')}}
   (void)(i1 ? constder() : Base()); // expected-error {{incompatible operand types ('struct Derived const' and 'struct Base')}}
 
-  // FIXME: these are invalid hierarchy conversions
   Priv priv;
   Fin fin;
-  (void)(i1 ? Base() : Priv()); // xpected-error private base
-  (void)(i1 ? Priv() : Base()); // xpected-error private base
-  (void)(i1 ? Base() : Fin()); // xpected-error ambiguous base
-  (void)(i1 ? Fin() : Base()); // xpected-error ambiguous base
+  (void)(i1 ? Base() : Priv()); // expected-error{{conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
+  (void)(i1 ? Priv() : Base()); // expected-error{{error: conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
+  (void)(i1 ? Base() : Fin()); // expected-error{{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
+  (void)(i1 ? Fin() : Base()); // expected-error{{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
   (void)(i1 ? base : priv); // expected-error {{conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
   (void)(i1 ? priv : base); // expected-error {{conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
   (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}

diff --git a/test/SemaCXX/elaborated-type-specifier.cpp b/test/SemaCXX/elaborated-type-specifier.cpp
index 40816d8823e14de06e9ebe0f5a9d19af680cb85f..8d2d67f705cdbb545479c44004fa8ddc266c20fd 100644 (file)
--- a/test/SemaCXX/elaborated-type-specifier.cpp
+++ b/test/SemaCXX/elaborated-type-specifier.cpp
@@ -27,7 +27,7 @@ namespace NS {
 
 void test_X_elab(NS::X x) {
   struct S4 *s4 = 0;
-  x.test_elab2(s4); // expected-error{{incompatible type passing 'struct S4 *', expected 'struct NS::S4 *'}}
+  x.test_elab2(s4); // expected-error{{cannot initialize a parameter of type 'struct NS::S4 *' with an lvalue of type 'struct S4 *'}}
 }
 
 namespace NS {

diff --git a/test/SemaCXX/member-location.cpp b/test/SemaCXX/member-location.cpp
index 42e7c799a83b2fa451c497798cb01840c2a0dfe8..c3099d25e0e1b46504a331284c9b2e3019764a30 100644 (file)
--- a/test/SemaCXX/member-location.cpp
+++ b/test/SemaCXX/member-location.cpp
@@ -1,5 +1,5 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // PR4103: Make sure we have a location for the error
 class A { float a(int *); int b(); };
-int A::b() { return a(a((int*)0)); } // expected-error {{incompatible type}}
+int A::b() { return a(a((int*)0)); } // expected-error {{cannot initialize a parameter of type 'int *' with an rvalue of type 'float'}}
 

diff --git a/test/SemaObjCXX/blocks.mm b/test/SemaObjCXX/blocks.mm
index 8dcf8089d321cec54e1ac75718bf21e6ca4f58b7..72de17133617b8849670839d43dcf7d84e4a5277 100644 (file)
--- a/test/SemaObjCXX/blocks.mm
+++ b/test/SemaObjCXX/blocks.mm
@@ -3,12 +3,12 @@
 
 void bar(id(^)(void));
 void foo(id <NSObject>(^objectCreationBlock)(void)) {
-    return bar(objectCreationBlock); // expected-warning{{incompatible pointer types passing 'id (^)()', expected 'id<NSObject> (^)()'}}
+    return bar(objectCreationBlock); // expected-warning{{incompatible pointer types converting 'id (^)()', expected 'id<NSObject> (^)()'}}
 }
 
 void bar2(id(*)(void));
 void foo2(id <NSObject>(*objectCreationBlock)(void)) {
-    return bar2(objectCreationBlock); // expected-warning{{incompatible pointer types passing 'id (*)()', expected 'id<NSObject> (*)()'}}
+    return bar2(objectCreationBlock); // expected-warning{{incompatible pointer types converting 'id (*)()', expected 'id<NSObject> (*)()'}}
 }
 
 void bar3(id(*)()); // expected-note{{candidate function}}

diff --git a/test/SemaTemplate/instantiate-member-template.cpp b/test/SemaTemplate/instantiate-member-template.cpp
index 2b5ba5c891ee1e4243325be736e980cc56c5009f..b4f0a9c6509df8aa6bee41df656a562c267607b6 100644 (file)
--- a/test/SemaTemplate/instantiate-member-template.cpp
+++ b/test/SemaTemplate/instantiate-member-template.cpp
@@ -90,7 +90,7 @@ void test_X1(int *ip, int i, double *dp) {
   
   X1<int*>::Inner3<int> id3;
   id3.f0(ip, i);
-  id3.f0(dp, i); // expected-error{{incompatible type}}
+  id3.f0(dp, i); // expected-error{{cannot initialize a parameter of type 'int *' with an lvalue of type 'double *'}}
   id3.f1(ip, i, ip);
   id3.f1(ip, i, dp); // expected-note{{instantiation}}