[NFC] Strip ClosureExpr of its TypeLoc

Author: CodaFi

include/swift/AST/Expr.h

@@ -3706,15 +3706,15 @@ class ClosureExpr : public AbstractClosureExpr {
   SourceLoc InLoc;
 
   /// The explicitly-specified result type.
-  TypeLoc ExplicitResultType;
+  TypeExpr *ExplicitResultType;
 
   /// The body of the closure, along with a bit indicating whether it
   /// was originally just a single expression.
   llvm::PointerIntPair<BraceStmt *, 1, bool> Body;
 public:
   ClosureExpr(SourceRange bracketRange, VarDecl *capturedSelfDecl,
               ParameterList *params, SourceLoc throwsLoc, SourceLoc arrowLoc,
-              SourceLoc inLoc, TypeLoc explicitResultType,
+              SourceLoc inLoc, TypeExpr *explicitResultType,
               unsigned discriminator, DeclContext *parent)
     : AbstractClosureExpr(ExprKind::Closure, Type(), /*Implicit=*/false,
                           discriminator, parent),
@@ -3774,11 +3774,17 @@ class ClosureExpr : public AbstractClosureExpr {
   }
 
   /// Retrieve the explicit result type location information.
-  TypeLoc &getExplicitResultTypeLoc() {
+  TypeExpr *getExplicitResultTypeExpr() const {
     assert(hasExplicitResultType() && "No explicit result type");
     return ExplicitResultType;
   }
 
+  void setExplicitResultTypeExpr(TypeExpr *NewResultType) {
+    assert(hasExplicitResultType() && "No explicit result type");
+    ExplicitResultType = NewResultType;
+    assert(hasExplicitResultType() && "No explicit result type");
+  }
+
   TypeRepr *getExplicitResultTypeRepr() const {
     assert(hasExplicitResultType() && "No explicit result type");
     return ExplicitResultType->getTypeRepr();

include/swift/Parse/Parser.h

@@ -1551,7 +1551,7 @@ class Parser {
           ParameterList *&params,
           SourceLoc &throwsLoc,
           SourceLoc &arrowLoc,
-          TypeRepr *&explicitResultType,
+          TypeExpr *&explicitResultType,
           SourceLoc &inLoc);
 
   Expr *parseExprAnonClosureArg();

lib/AST/ASTWalker.cpp

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

lib/IDE/ExprContextAnalysis.cpp

@@ -29,6 +29,7 @@
 #include "swift/Basic/SourceManager.h"
 #include "swift/IDE/CodeCompletion.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "swift/Subsystems.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 
@@ -209,10 +210,23 @@ Type swift::ide::getReturnTypeFromContext(const DeclContext *DC) {
     if (ACE->getType() && !ACE->getType()->hasError())
       return ACE->getResultType();
     if (auto CE = dyn_cast<ClosureExpr>(ACE)) {
-      if (CE->hasExplicitResultType())
-        return const_cast<ClosureExpr *>(CE)
-            ->getExplicitResultTypeLoc()
-            .getType();
+      if (CE->hasExplicitResultType()) {
+        if (auto ty = CE->getExplicitResultTypeExpr()->getInstanceType()) {
+          return ty;
+        }
+
+        auto typeLoc = TypeLoc{CE->getExplicitResultTypeRepr()};
+        if (swift::performTypeLocChecking(DC->getASTContext(),
+                                          typeLoc,
+                                          /*isSILMode*/ false,
+                                          /*isSILType*/ false,
+                                          DC->getGenericEnvironmentOfContext(),
+                                          const_cast<DeclContext *>(DC),
+                                          /*diagnostics*/ false)) {
+          return Type();
+        }
+        return typeLoc.getType();
+      }
     }
   }
   return Type();

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->getExplicitResultTypeLoc().getSourceRange());
+                          Closure->getExplicitResultTypeExpr()->getSourceRange());
 
     pushStructureNode(SN, Closure);
 

lib/Parse/ParseExpr.cpp

@@ -2422,7 +2422,7 @@ parseClosureSignatureIfPresent(SourceRange &bracketRange,
                                VarDecl *&capturedSelfDecl,
                                ParameterList *&params, SourceLoc &throwsLoc,
                                SourceLoc &arrowLoc,
-                               TypeRepr *&explicitResultType, SourceLoc &inLoc){
+                               TypeExpr *&explicitResultType, SourceLoc &inLoc){
   // Clear out result parameters.
   bracketRange = SourceRange();
   capturedSelfDecl = nullptr;
@@ -2686,12 +2686,14 @@ parseClosureSignatureIfPresent(SourceRange &bracketRange,
       arrowLoc = consumeToken();
 
       // Parse the type.
-      explicitResultType =
+      auto *explicitResultTypeRepr =
           parseType(diag::expected_closure_result_type).getPtrOrNull();
-      if (!explicitResultType) {
+      if (!explicitResultTypeRepr) {
         // If we couldn't parse the result type, clear out the arrow location.
         arrowLoc = SourceLoc();
         invalid = true;
+      } else {
+        explicitResultType = new (Context) TypeExpr(explicitResultTypeRepr);
       }
     }
   }
@@ -2791,7 +2793,7 @@ ParserResult<Expr> Parser::parseExprClosure() {
   ParameterList *params = nullptr;
   SourceLoc throwsLoc;
   SourceLoc arrowLoc;
-  TypeRepr *explicitResultType;
+  TypeExpr *explicitResultType;
   SourceLoc inLoc;
   parseClosureSignatureIfPresent(bracketRange, captureList,
                                  capturedSelfDecl, params, throwsLoc,

lib/Sema/CSGen.cpp

@@ -2177,14 +2177,25 @@ namespace {
       // parameter or return type is omitted, a fresh type variable is used to
       // stand in for that parameter or return type, allowing it to be inferred
       // from context.
+      auto getExplicitResultType = [&]() -> Type {
+        if (!closure->hasExplicitResultType()) {
+          return Type();
+        }
+
+        auto *resultExpr = closure->getExplicitResultTypeExpr();
+        if (auto declaredTy = resultExpr->getInstanceType()) {
+          return declaredTy;
+        }
+
+        return resolveTypeReferenceInExpression(closure->getExplicitResultTypeRepr());
+      };
+
       Type resultTy;
-      if (closure->hasExplicitResultType() &&
-          closure->getExplicitResultTypeLoc().getType()) {
-        resultTy = closure->getExplicitResultTypeLoc().getType();
-      } else {
-        auto *resultLoc =
+      auto *resultLoc =
             CS.getConstraintLocator(closure, ConstraintLocator::ClosureResult);
-
+      if (auto explicityTy = getExplicitResultType()) {
+        resultTy = explicityTy;
+      } else {
         auto getContextualResultType = [&]() -> Type {
           if (auto contextualType = CS.getContextualType(closure)) {
             if (auto fnType = contextualType->getAs<FunctionType>())
@@ -2207,6 +2218,11 @@ namespace {
         }
       }
 
+      if (closure->hasExplicitResultType()) {
+        CS.setType(closure->getExplicitResultTypeExpr(),
+                   MetatypeType::get(resultTy));
+      }
+
       return FunctionType::get(closureParams, resultTy, extInfo);
     }
 

lib/Sema/CSSimplify.cpp

@@ -7078,14 +7078,11 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
         closureType->getResult(),
         getConstraintLocator(closure, LocatorPathElt::ClosureBody(hasReturn)));
   } else if (!hasReturn) {
-    bool hasExplicitResult = closure->hasExplicitResultType() &&
-                             closure->getExplicitResultTypeLoc().getType();
-
     // If this closure has an empty body and no explicit result type
     // let's bind result type to `Void` since that's the only type empty body
     // can produce. Otherwise, if (multi-statement) closure doesn't have
     // an explicit result (no `return` statements) let's default it to `Void`.
-    auto constraintKind = (closure->hasEmptyBody() && !hasExplicitResult)
+    auto constraintKind = (closure->hasEmptyBody() && !closure->hasExplicitResultType())
                               ? ConstraintKind::Bind
                               : ConstraintKind::Defaultable;
     addConstraint(

lib/Sema/DebuggerTestingTransform.cpp

@@ -226,7 +226,7 @@ class DebuggerTestingTransform : public ASTWalker {
     auto *Params = ParameterList::createEmpty(Ctx);
     auto *Closure = new (Ctx)
         ClosureExpr(SourceRange(), nullptr, Params, SourceLoc(), SourceLoc(),
-                    SourceLoc(), TypeLoc(), DF.getNextDiscriminator(),
+                    SourceLoc(), nullptr, DF.getNextDiscriminator(),
                     getCurrentDeclContext());
     Closure->setImplicit(true);
 

lib/Sema/MiscDiagnostics.cpp

@@ -537,6 +537,13 @@ 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?