Hide the TypeExpr in ClosureExpr

Author: CodaFi

include/swift/AST/Expr.h

@@ -3769,17 +3769,11 @@ class ClosureExpr : public AbstractClosureExpr {
     return ThrowsLoc;
   }
 
-  /// Retrieve the explicit result type location information.
-  TypeExpr *getExplicitResultTypeExpr() const {
-    assert(hasExplicitResultType() && "No explicit result type");
-    return ExplicitResultType;
-  }
-
-  void setExplicitResultTypeExpr(TypeExpr *NewResultType) {
-    assert(hasExplicitResultType() && "No explicit result type");
-    ExplicitResultType = NewResultType;
+  Type getExplicitResultType() const {
     assert(hasExplicitResultType() && "No explicit result type");
+    return ExplicitResultType->getInstanceType();
   }
+  void setExplicitResultType(Type ty);
 
   TypeRepr *getExplicitResultTypeRepr() const {
     assert(hasExplicitResultType() && "No explicit result type");

lib/AST/ASTWalker.cpp

@@ -811,9 +811,8 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     visit(expr->getParameters());
 
     if (expr->hasExplicitResultType()) {
-      Expr *result = doIt(expr->getExplicitResultTypeExpr());
-      if (!result) return nullptr;
-      expr->setExplicitResultTypeExpr(cast<TypeExpr>(result));
+      if (doIt(expr->getExplicitResultTypeRepr()))
+        return nullptr;
     }
 
     // Handle single-expression closures.

lib/AST/Expr.cpp

@@ -1861,6 +1861,11 @@ bool ClosureExpr::capturesSelfEnablingImplictSelf() const {
   return false;
 }
 
+void ClosureExpr::setExplicitResultType(Type ty) {
+  assert(ty && !ty->hasTypeVariable());
+  ExplicitResultType->setType(MetatypeType::get(ty));
+}
+
 FORWARD_SOURCE_LOCS_TO(AutoClosureExpr, Body)
 
 void AutoClosureExpr::setBody(Expr *E) {

lib/IDE/ExprContextAnalysis.cpp

@@ -211,7 +211,7 @@ Type swift::ide::getReturnTypeFromContext(const DeclContext *DC) {
       return ACE->getResultType();
     if (auto CE = dyn_cast<ClosureExpr>(ACE)) {
       if (CE->hasExplicitResultType()) {
-        if (auto ty = CE->getExplicitResultTypeExpr()->getInstanceType()) {
+        if (auto ty = CE->getExplicitResultType()) {
           return ty;
         }
 

lib/IDE/SyntaxModel.cpp

@@ -663,7 +663,7 @@ std::pair<bool, Expr *> ModelASTWalker::walkToExprPre(Expr *E) {
     SN.BodyRange = innerCharSourceRangeFromSourceRange(SM, E->getSourceRange());
     if (Closure->hasExplicitResultType())
       SN.TypeRange = charSourceRangeFromSourceRange(SM,
-                          Closure->getExplicitResultTypeExpr()->getSourceRange());
+                          Closure->getExplicitResultTypeRepr()->getSourceRange());
 
     pushStructureNode(SN, Closure);
 

lib/Sema/CSApply.cpp

@@ -7696,6 +7696,10 @@ namespace {
         auto *params = closure->getParameters();
         TypeChecker::coerceParameterListToType(params, closure, fnType);
 
+        if (closure->hasExplicitResultType()) {
+          closure->setExplicitResultType(fnType->getResult());
+        }
+
         if (auto transform =
                        Rewriter.getAppliedBuilderTransform(closure)) {
           // Apply the function builder to the closure. We want to be in the

lib/Sema/CSGen.cpp

@@ -2182,8 +2182,7 @@ namespace {
           return Type();
         }
 
-        auto *resultExpr = closure->getExplicitResultTypeExpr();
-        if (auto declaredTy = resultExpr->getInstanceType()) {
+        if (auto declaredTy = closure->getExplicitResultType()) {
           return declaredTy;
         }
 
@@ -2218,11 +2217,6 @@ namespace {
         }
       }
 
-      if (closure->hasExplicitResultType()) {
-        CS.setType(closure->getExplicitResultTypeExpr(),
-                   MetatypeType::get(resultTy));
-      }
-
       return FunctionType::get(closureParams, resultTy, extInfo);
     }
 

lib/Sema/MiscDiagnostics.cpp

@@ -537,13 +537,6 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
             isa<SubscriptExpr>(ParentExpr)) {
           return;
         }
-
-        if (auto *CE = dyn_cast<ClosureExpr>(ParentExpr)) {
-          if (CE->hasExplicitResultType() &&
-              CE->getExplicitResultTypeExpr() == E) {
-            return;
-          }
-        }
       }
 
       // Is this a protocol metatype?