Address post-review feedback/revert

#138731 (comment)

A call expression might have been partially constructed,
in which case it will be a call-expressions (and its type
will not be that of a function)

To address that, we check that the expression might already be
a well-formed call

Author: cor3ntin

clang/lib/Sema/SemaExpr.cpp

@@ -6551,12 +6551,25 @@ ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
 }
 
 // Any type that could be used to form a callable expression
-static bool MayBeFunctionType(const ASTContext &Context, QualType T) {
-  return T == Context.BoundMemberTy || T == Context.UnknownAnyTy ||
-         T == Context.BuiltinFnTy || T == Context.OverloadTy ||
-         T->isFunctionType() || T->isFunctionReferenceType() ||
-         T->isMemberFunctionPointerType() || T->isFunctionPointerType() ||
-         T->isBlockPointerType() || T->isRecordType();
+static bool MayBeFunctionType(const ASTContext &Context, const Expr* E) {
+    QualType T = E->getType();
+    if(T->isDependentType())
+        return true;
+
+    if( T == Context.BoundMemberTy || T == Context.UnknownAnyTy ||
+        T == Context.BuiltinFnTy || T == Context.OverloadTy ||
+        T->isFunctionType() || T->isFunctionReferenceType() ||
+        T->isMemberFunctionPointerType() || T->isFunctionPointerType() ||
+        T->isBlockPointerType() || T->isRecordType())
+        return true;
+
+    return isa<CallExpr,
+               DeclRefExpr,
+               MemberExpr,
+               CXXPseudoDestructorExpr,
+               OverloadExpr,
+               UnresolvedMemberExpr,
+               UnaryOperator>(E);
 }
 
 ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
@@ -6615,8 +6628,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
         // If the type of the function itself is not dependent
         // check that it is a reasonable as a function, as type deduction
         // later assume the CallExpr has a sensible TYPE.
-        if (!Fn->getType()->isDependentType() &&
-            !MayBeFunctionType(Context, Fn->getType()))
+        if (!MayBeFunctionType(Context, Fn))
           return ExprError(
               Diag(LParenLoc, diag::err_typecheck_call_not_function)
               << Fn->getType() << Fn->getSourceRange());

clang/test/SemaTemplate/fun-template-def.cpp

@@ -33,7 +33,7 @@ T f1(T t1, U u1, int i1, T** tpp)
   i1 = t1[u1];
   i1 *= t1;
 
-  i1(u1, t1); // expected-error {{called object type 'int' is not a function or function pointer}}
+  i1(u1, t1);
   u1(i1, t1);
 
   U u2 = (T)i1;
@@ -108,4 +108,51 @@ auto k = c_<1>; // expected-note {{in instantiation of variable}}
 
 }
 
+namespace GH138731 {
+template <class...>
+using void_t = void;
+template <class...>
+using void_t = void;
+
+template <class T>
+T&& declval();
+
+struct S {
+  S();
+  static int f();
+  static int var;
+};
+
+namespace invoke_detail {
+
+template <typename F>
+struct traits {
+  template <typename... A>
+  using result = decltype(declval<F>()(declval<A>()...));
+};
+
+template <typename F, typename... A>
+using invoke_result_t = typename traits<F>::template result<A...>;
+
+template <typename Void, typename F, typename... A>
+inline constexpr bool is_invocable_v = false;
+
+template <typename F, typename... A>
+inline constexpr bool
+    is_invocable_v<void_t<invoke_result_t<F, A...>>, F, A...> = true;
+
+}
+
+template <typename F, typename... A>
+inline constexpr bool is_invocable_v =
+    invoke_detail::is_invocable_v<void, F, A...>;
+
+static_assert(!is_invocable_v<int>);
+static_assert(!is_invocable_v<int, int>);
+static_assert(!is_invocable_v<S>);
+static_assert(is_invocable_v<decltype(&S::f)>);
+static_assert(!is_invocable_v<decltype(&S::var)>);
+
+}
+
 #endif