From: Douglas Gregor <dgregor@apple.com>
Date: Tue, 31 Aug 2010 00:26:14 +0000 (+0000)
Subject: When instantiating a function type, instantiate the return type before
X-Git-Tag: llvmorg-2.8.0-rc0~437
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=4afc236cee0cea69412bfe334f6c62d4920f1c2b;p=platform%2Fupstream%2Fllvm.git

When instantiating a function type, instantiate the return type before
instantiating the parameters. In a perfect world, this wouldn't
matter, and compilers are free to instantiate in any order they
want. However, every other compiler seems to instantiate the return
type first, and some code (in this case, Boost.Polygon) depends on
this and SFINAE to avoid instantiating something that shouldn't be
instantiated.

We could fight this battle, and insist that Clang is allowed to do
what it does, but it's not beneficial: it's more predictable to
instantiate this way, in source order. When we implement
late-specified return types, we'll need to instantiate the return type
last when it was late-specified, hence the FIXME.

We now compile Boost.Polygon properly.

llvm-svn: 112561
---

diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 08cfd68d663e..db5c67a2e093 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -2903,18 +2903,25 @@ QualType
 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
                                                    FunctionProtoTypeLoc TL,
                                                    QualType ObjectType) {
-  // Transform the parameters. We do this first for the benefit of template
-  // instantiations, so that the ParmVarDecls get/ placed into the template
-  // instantiation scope before we transform the function type.
+  // Transform the parameters and return type.
+  //
+  // We instantiate in source order, with the return type first followed by
+  // the parameters, because users tend to expect this (even if they shouldn't
+  // rely on it!).
+  //
+  // FIXME: When we implement late-specified return types, we'll need to
+  // instantiate the return tpe *after* the parameter types in that case,
+  // since the return type can then refer to the parameters themselves (via
+  // decltype, sizeof, etc.).
   llvm::SmallVector<QualType, 4> ParamTypes;
   llvm::SmallVector<ParmVarDecl*, 4> ParamDecls;
-  if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls))
-    return QualType();
-  
   FunctionProtoType *T = TL.getTypePtr();
   QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
   if (ResultType.isNull())
     return QualType();
+
+  if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls))
+    return QualType();  
   
   QualType Result = TL.getType();
   if (getDerived().AlwaysRebuild() ||
diff --git a/clang/test/CXX/temp/temp.fct.spec/temp.deduct/sfinae-1.cpp b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/sfinae-1.cpp
index f6121b373e13..6481485b2a08 100644
--- a/clang/test/CXX/temp/temp.fct.spec/temp.deduct/sfinae-1.cpp
+++ b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/sfinae-1.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 %s
+// RUN: %clang_cc1 -verify %s
 
 typedef char one_byte;
 struct two_bytes { char data[2]; };
@@ -15,3 +15,28 @@ struct X { };
 int array0[is_class<X>::value? 1 : -1];
 int array1[is_class<int>::value? -1 : 1];
 int array2[is_class<char[3]>::value? -1 : 1];
+
+namespace instantiation_order1 {
+  template<typename T>
+  struct it_is_a_trap { 
+    typedef typename T::trap type;
+  };
+
+  template<bool, typename T = void>
+  struct enable_if {
+    typedef T type;
+  };
+
+  template<typename T>
+  struct enable_if<false, T> { };
+
+  template<typename T>
+  typename enable_if<sizeof(T) == 17>::type 
+  f(const T&, typename it_is_a_trap<T>::type* = 0);
+
+  void f(...);
+
+  void test_f() {
+    f('a');
+  }
+}