Distinguish a function's result type in the interface vs. in the definition.

At present, this is a distinction without a difference. However, it's
a step toward detangling archetypes from the interface of a
polymorphic function.


Swift SVN r7405

Author: DougGregor

include/swift/AST/Expr.h

@@ -1688,6 +1688,11 @@ class FuncExpr : public CapturingExpr {
 
   TypeLoc FnRetType;
 
+  /// The result type as seen from the body of the function.
+  ///
+  /// \sa getBodyResultType()
+  Type BodyResultType;
+
   Pattern **getParamsBuffer() {
     return reinterpret_cast<Pattern**>(this+1);
   }
@@ -1843,9 +1848,29 @@ class FuncExpr : public CapturingExpr {
 
   TypeLoc &getBodyResultTypeLoc() { return FnRetType; }
 
-  /// \brief Retrieve the result type of this function.
+  /// Retrieve the result type of this function.
+  ///
+  /// \sa getBodyResultType
   Type getResultType(ASTContext &Ctx) const;
 
+  /// Retrieve the result type of this function for use within the function
+  /// definition.
+  ///
+  /// FIXME: The statement below is a wish, not reality.
+  /// The "body" result type will only differ from the result type within the
+  /// interface to the function for a polymorphic function, where the interface
+  /// may contain generic parameters while the definition will contain
+  /// the corresponding archetypes.
+  Type getBodyResultType() const { return BodyResultType; }
+
+  /// Set the result type as viewed from the function body.
+  ///
+  /// \sa getBodyResultType
+  void setBodyResultType(Type bodyResultType) {
+    assert(BodyResultType.isNull() && "Already set body result type");
+    BodyResultType = bodyResultType;
+  }
+
   static bool classof(const Expr *E) { return E->getKind() == ExprKind::Func; }
   static bool classof(const DeclContext *DC) {
     return isa<CapturingExpr>(DC) && classof(cast<CapturingExpr>(DC));

lib/ClangImporter/ImportDecl.cpp

@@ -791,6 +791,7 @@ namespace {
                                        argPatterns, bodyPatterns,
                                        TypeLoc::withoutLoc(resultTy), dc);
       funcExpr->setType(type);
+      funcExpr->setBodyResultType(resultTy);
       auto nameLoc = Impl.importSourceLoc(decl->getLocation());
       auto result = new (Impl.SwiftContext) FuncDecl(SourceLoc(), loc,
                                                      name, nameLoc,
@@ -961,7 +962,7 @@ namespace {
                                        argPatterns, bodyPatterns,
                                        TypeLoc::withoutLoc(resultTy), dc);
       funcExpr->setType(type);
-
+      funcExpr->setBodyResultType(resultTy);
       auto result = new (Impl.SwiftContext) FuncDecl(SourceLoc(), loc,
                                                      name, nameLoc,
                                                      /*GenericParams=*/0,
@@ -1438,6 +1439,7 @@ namespace {
                                        TypeLoc::withoutLoc(elementTy),
                                        getter->getDeclContext());
       funcExpr->setType(getterType);
+      funcExpr->setBodyResultType(elementTy);
       setVarDeclContexts(getterArgs, funcExpr);
 
       // Create the getter thunk.
@@ -1562,6 +1564,7 @@ namespace {
                               TypeLoc::withoutLoc(TupleType::getEmpty(context)),
                                        setter->getDeclContext());
       funcExpr->setType(setterType);
+      funcExpr->setBodyResultType(TupleType::getEmpty(context));
       setVarDeclContexts(setterArgs, funcExpr);
 
       // Create the setter thunk.
@@ -2530,6 +2533,7 @@ ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
                                    TypeLoc::withoutLoc(type),
                                    dc);
   funcExpr->setType(getterType);
+  funcExpr->setBodyResultType(type);
   setVarDeclContexts(getterArgs, funcExpr);
 
   // Create the getter function declaration.

lib/Sema/TypeCheckDecl.cpp

@@ -1035,6 +1035,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (!funcTy) {
       funcTy = TupleType::getEmpty(TC.Context);
     }
+    auto bodyResultType = funcTy;
 
     // FIXME: it would be nice to have comments explaining what this is all about.
     auto patterns = FE->getArgParamPatterns();
@@ -1069,6 +1070,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     }
     FE->setType(funcTy);
+    FE->setBodyResultType(bodyResultType);
   }
 
   /// Bind the given function declaration, which declares an operator, to

lib/Sema/TypeCheckREPL.cpp

@@ -532,6 +532,7 @@ static void generatePrintOfExpression(StringRef NameStr, Expr *E,
   Type FuncTy = FunctionType::get(ParamPat->getType(), TupleType::getEmpty(C),
                                   C);
   FE->setType(FuncTy);
+  FE->setBodyResultType(TupleType::getEmpty(C));
   Arg->setDeclContext(FE);
 
   // Convert the pattern to a string we can print.

lib/Sema/TypeCheckStmt.cpp

@@ -132,14 +132,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
 
   Type returnTypeOfFunc() {
     if (auto fe = TheFunc.dyn_cast<FuncExpr*>()) {
-      Type resultTy = fe->getType();
-      if (resultTy->is<ErrorType>())
-        return resultTy;
-      for (unsigned i = 0, e = fe->getNumParamPatterns();
-           i != e;
-           ++i)
-        resultTy = resultTy->castTo<AnyFunctionType>()->getResult();
-      return resultTy;
+      return fe->getBodyResultType();
     } else if (auto closure = TheFunc.dyn_cast<PipeClosureExpr *>()) {
       return closure->getResultType();
     } else