Address review comments, fix test.

- Rename `isValidDynamicallyCallMethod` to `isValidDynamicCallableMethod`.
- Add todo hint regarding `static func callAsFunction`, if it is to be supported.
- Restore `var origType2` before unwrapping optionality.
  - This fixes `expr/delayed-ident/static_var.swift`.

Author: dan-zheng

lib/Sema/CSApply.cpp

@@ -6753,7 +6753,7 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
 
 // Returns true if the given method and method type are a valid
 // `@dynamicCallable` required `func dynamicallyCall` method.
-static bool isValidDynamicallyCallMethod(FuncDecl *method,
+static bool isValidDynamicCallableMethod(FuncDecl *method,
                                          AnyFunctionType *methodType) {
   auto &ctx = method->getASTContext();
   if (method->getName() != ctx.Id_dynamicallyCall)
@@ -6815,7 +6815,7 @@ ExprRewriter::finishApplyDynamicCallable(ApplyExpr *apply,
     arg = TupleExpr::createImplicit(ctx, parenExpr->getSubExpr(), {});
 
   // Get resolved `dynamicallyCall` method and verify it.
-  assert(isValidDynamicallyCallMethod(method, methodType));
+  assert(isValidDynamicCallableMethod(method, methodType));
   auto params = methodType->getParams();
   auto argumentType = params[0].getParameterType();
 
@@ -7043,7 +7043,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
       if (method->isCallAsFunctionMethod())
         return finishApplyCallAsFunctionMethod(
             *this, apply, *selected, methodType, applyFunctionLoc);
-      if (methodType && isValidDynamicallyCallMethod(method, methodType))
+      if (methodType && isValidDynamicCallableMethod(method, methodType))
         return finishApplyDynamicCallable(
             apply, *selected, method, methodType, applyFunctionLoc);
     }

lib/Sema/CSSimplify.cpp

@@ -6012,15 +6012,16 @@ ConstraintSystem::simplifyApplicableFnConstraint(
     }
   }
 
-  // Before stripping lvalue-ness and optional types, save original type for
-  // handling `func callAsFunction` and `@dynamicCallable` applications.
-  // This supports the following cases:
+  // Before stripping lvalue-ness and optional types, save the original second
+  // type for handling `func callAsFunction` and `@dynamicCallable`
+  // applications. This supports the following cases:
   // - Generating constraints for `mutating func callAsFunction`. The nominal
   //   type (`type2`) should be an lvalue type.
   // - Extending `Optional` itself with `func callAsFunction` or
   //   `@dynamicCallable` functionality. Optional types are stripped below if
   //   `shouldAttemptFixes()` is true.
-  auto *origType2 = type2->getDesugaredType();
+  auto origLValueType2 =
+      getFixedTypeRecursive(type2, flags, /*wantRValue=*/false);
   // Drill down to the concrete type on the right hand side.
   type2 = getFixedTypeRecursive(type2, flags, /*wantRValue=*/true);
   auto desugar2 = type2->getDesugaredType();
@@ -6104,10 +6105,10 @@ ConstraintSystem::simplifyApplicableFnConstraint(
         outerLocator.withPathElement(ConstraintLocator::Member));
     // Add a `callAsFunction` member constraint, binding the member type to a
     // type variable.
-    auto memberTy = createTypeVariable(memberLoc, TVO_CanBindToLValue |
-                                                  TVO_CanBindToNoEscape |
-                                                  TVO_CanBindToInOut);
-    addValueMemberConstraint(origType2, DeclName(ctx.Id_callAsFunction),
+    auto memberTy = createTypeVariable(memberLoc, /*options=*/0);
+    // TODO: Revisit this if `static func callAsFunction` is to be supported.
+    // Static member constraint requires `FunctionRefKind::DoubleApply`.
+    addValueMemberConstraint(origLValueType2, DeclName(ctx.Id_callAsFunction),
                              memberTy, DC, FunctionRefKind::SingleApply,
                              /*outerAlternatives*/ {}, locator);
     // Add new applicable function constraint based on the member type
@@ -6117,6 +6118,8 @@ ConstraintSystem::simplifyApplicableFnConstraint(
     return SolutionKind::Solved;
   }
 
+  // Record the second type before unwrapping optionals.
+  auto origType2 = desugar2;
   unsigned unwrapCount = 0;
   if (shouldAttemptFixes()) {
     // If we have an optional type, try forcing it to see if that