[Sema] Don't allow applying address-of operator to a call to a function with __unknown_anytype return type

[ahatanak]

Summary

This patch fixes an assert in CodeGenFunction::EmitCallExprLValue that is triggered when the CallExpr's return type is not a reference type:

assert(E->getCallReturnType(getContext())->isReferenceType() &&

"Can't have a scalar return unless the return type is a "
"reference type!");

Alternatively, since it's legal to apply the address-of operator to a reference return, we can change the function return type to be a reference (in the test case, that would be double&) in RebuildUnknownAnyExpr::VisitUnaryAddrOf when compiling for C++ (but not when compiling for C).

[spyffe]

I think it's all right to be conservative here. The inference rules could get quite complicated if (for example) the use looked like this

extern void foo (double *bar);
extern __unknown_anytype func();
// ...
foo(&func());

One could come up with even more complicated cases. It's probably not worth making sure they all work.

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def err_unsupported_unknown_any_decl : Error<
   "%0 has unknown type, which is not supported for this kind of declaration">;
 def err_unsupported_unknown_any_expr : Error<
   "unsupported expression with unknown type">;
 def err_unsupported_unknown_any_call : Error<
   "call to unsupported expression with unknown type">;
 def err_unknown_any_addrof : Error<
   "the address of a declaration with unknown type "
   "can only be cast to a pointer type">;
+def err_unknown_any_addrof_call : Error<
+  "address-of operator cannot be applied to a call to a function with "
+  "unknown return type">;
 def err_unknown_any_var_function_type : Error<
   "variable %0 with unknown type cannot be given a function type">;
 def err_unknown_any_function : Error<
   "function %0 with unknown type must be given a function type">;
 
 def err_filter_expression_integral : Error<
   "filter expression type should be an integral value not %0">;
 

cfe/trunk/lib/Sema/SemaExpr.cpp

struct RebuildUnknownAnyExpr
 
     ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
       const PointerType *Ptr = DestType->getAs<PointerType>();
       if (!Ptr) {
         S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
           << E->getSourceRange();
         return ExprError();
       }
+
+      if (isa<CallExpr>(E->getSubExpr())) {
+        S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
+          << E->getSourceRange();
+        return ExprError();
+      }
+
       assert(E->getValueKind() == VK_RValue);
       assert(E->getObjectKind() == OK_Ordinary);
       E->setType(DestType);
 
       // Build the sub-expression as if it were an object of the pointee type.
       DestType = Ptr->getPointeeType();
       ExprResult SubResult = Visit(E->getSubExpr());
       if (SubResult.isInvalid()) return ExprError();

cfe/trunk/test/SemaCXX/unknown-anytype.cpp

namespace test5 {
   template<typename T> struct X; // expected-note{{template is declared here}}
 
   extern __unknown_anytype test0(...);
 
   void test() {
     (X<int>)test0(); // expected-error{{implicit instantiation of undefined template 'test5::X<int>'}}
   }
 }
+
+namespace test6 {
+  extern __unknown_anytype func();
+  extern __unknown_anytype var;
+  double *d;
+
+  void test() {
+    d = (double*)&func(); // expected-error{{address-of operator cannot be applied to a call to a function with unknown return type}}
+    d = (double*)&var;
+  }
+
+}