Allow parsing of function types in expr position (#2273)

cwillmor · cwillmor · commit 02a6be6d0177 · 2016-04-22T21:53:26.000-07:00
Previously it was not possible to parse expressions of the form [Int -> Int]() because no Expr could represent the '->' token and be converted later into a FunctionTypeRepr. This commit introduces ArrowExpr which exists solely to be converted to FunctionTypeRepr later by simplifyTypeExpr. https://bugs.swift.org/browse/SR-502
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -94,6 +94,7 @@ class InfixData {
 namespace IntrinsicPrecedences {
   enum : unsigned char {
     MinPrecedence = 0,
+    ArrowExpr = 0, // ->
     IfExpr = 100, // ?:
     AssignExpr = 90, // =
     ExplicitCastExpr = 132, // 'is' and 'as'
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -611,6 +611,10 @@ ERROR(rethrows_after_function_result,none,
       "'rethrows' may only occur before '->'", ())
 ERROR(throw_in_function_type,none,
       "expected throwing specifier; did you mean 'throws'?", ())
+ERROR(expected_type_before_arrow,none,
+      "expected type before '->'", ())
+ERROR(expected_type_after_arrow,none,
+      "expected type after '->'", ())
 
 // Enum Types
 ERROR(expected_expr_enum_case_raw_value,PointsToFirstBadToken,
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -3490,6 +3490,47 @@ class CoerceExpr : public ExplicitCastExpr {
   }
 };
 
+/// \brief Represents two expressions joined by the arrow operator '->', which
+/// may be preceded by the 'throws' keyword. Currently this only exists to be
+/// transformed into a FunctionTypeRepr by simplifyTypeExpr() in Sema.
+class ArrowExpr : public Expr {
+  SourceLoc ThrowsLoc;
+  SourceLoc ArrowLoc;
+  Expr *Args;
+  Expr *Result;
+public:
+  ArrowExpr(Expr *Args, SourceLoc ThrowsLoc, SourceLoc ArrowLoc, Expr *Result)
+    : Expr(ExprKind::Arrow, /*implicit=*/false, Type()),
+      ThrowsLoc(ThrowsLoc), ArrowLoc(ArrowLoc), Args(Args), Result(Result)
+  { }
+
+  ArrowExpr(SourceLoc ThrowsLoc, SourceLoc ArrowLoc)
+    : Expr(ExprKind::Arrow, /*implicit=*/false, Type()),
+      ThrowsLoc(ThrowsLoc), ArrowLoc(ArrowLoc), Args(nullptr), Result(nullptr)
+  { }
+
+  Expr *getArgsExpr() const { return Args; }
+  void setArgsExpr(Expr *E) { Args = E; }
+  Expr *getResultExpr() const { return Result; }
+  void setResultExpr(Expr *E) { Result = E; }
+  SourceLoc getThrowsLoc() const { return ThrowsLoc; }
+  SourceLoc getArrowLoc() const { return ArrowLoc; }
+  bool isFolded() const { return Args != nullptr && Result != nullptr; }
+
+  SourceLoc getSourceLoc() const { return ArrowLoc; }
+  SourceLoc getStartLoc() const {
+    return isFolded() ? Args->getStartLoc() :
+           ThrowsLoc.isValid() ? ThrowsLoc : ArrowLoc;
+  }
+  SourceLoc getEndLoc() const {
+    return isFolded() ? Result->getEndLoc() : ArrowLoc;
+  }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::Arrow;
+  }
+};
+
 /// \brief Represents the rebinding of 'self' in a constructor that calls out
 /// to another constructor. The result of the subexpression is assigned to
 /// 'self', and the expression returns void.
diff --git a/include/swift/AST/ExprNodes.def b/include/swift/AST/ExprNodes.def
@@ -149,6 +149,7 @@ ABSTRACT_EXPR(ExplicitCast, Expr)
     EXPR_RANGE(CheckedCast, ForcedCheckedCast, Is)
   EXPR(Coerce, ExplicitCastExpr)
   EXPR_RANGE(ExplicitCast, ForcedCheckedCast, Coerce)
+UNCHECKED_EXPR(Arrow, Expr)
 EXPR(If, Expr)
 EXPR(Assign, Expr)
 EXPR(DefaultValue, Expr)
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1101,6 +1101,7 @@ class Parser {
   ParserResult<Expr> parseExprImpl(Diag<> ID, bool isExprBasic = false);
   ParserResult<Expr> parseExprIs();
   ParserResult<Expr> parseExprAs();
+  ParserResult<Expr> parseExprArrow();
   ParserResult<Expr> parseExprSequence(Diag<> ID,
                                        bool isExprBasic,
                                        bool isForConditionalDirective = false);
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -2123,6 +2123,13 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
   void visitCoerceExpr(CoerceExpr *E) {
     printExplicitCastExpr(E, "coerce_expr");
   }
+  void visitArrowExpr(ArrowExpr *E) {
+    printCommon(E, "arrow") << '\n';
+    printRec(E->getArgsExpr());
+    OS << '\n';
+    printRec(E->getResultExpr());
+    OS << ')';
+  }
   void visitRebindSelfInConstructorExpr(RebindSelfInConstructorExpr *E) {
     printCommon(E, "rebind_self_in_constructor_expr") << '\n';
     printRec(E->getSubExpr());
diff --git a/lib/AST/ASTWalker.cpp b/lib/AST/ASTWalker.cpp
@@ -709,6 +709,20 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return E;
   }
 
+  Expr *visitArrowExpr(ArrowExpr *E) {
+    if (Expr *Args = E->getArgsExpr()) {
+      Args = doIt(Args);
+      if (!Args) return nullptr;
+      E->setArgsExpr(Args);
+    }
+    if (Expr *Result = E->getResultExpr()) {
+      Result = doIt(Result);
+      if (!Result) return nullptr;
+      E->setResultExpr(Result);
+    }
+    return E;
+  }
+
   Expr *visitRebindSelfInConstructorExpr(RebindSelfInConstructorExpr *E) {
     Expr *Sub = doIt(E->getSubExpr());
     if (!Sub) return nullptr;
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -608,6 +608,7 @@ bool Expr::canAppendCallParentheses() const {
   case ExprKind::Coerce:
     return false;
 
+  case ExprKind::Arrow:
   case ExprKind::If:
   case ExprKind::Assign:
   case ExprKind::DefaultValue:
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -176,6 +176,29 @@ ParserResult<Expr> Parser::parseExprAs() {
   return makeParserResult(parsed);
 }
 
+/// parseExprArrow
+///
+///   expr-arrow:
+///     '->'
+///     'throws' '->'
+ParserResult<Expr> Parser::parseExprArrow() {
+  SourceLoc throwsLoc, arrowLoc;
+  if (Tok.is(tok::kw_throws)) {
+    throwsLoc = consumeToken(tok::kw_throws);
+    if (!Tok.is(tok::arrow)) {
+      diagnose(throwsLoc, diag::throws_after_function_result);
+      return nullptr;
+    }
+  }
+  arrowLoc = consumeToken(tok::arrow);
+  if (Tok.is(tok::kw_throws)) {
+    diagnose(Tok.getLoc(), diag::throws_after_function_result);
+    throwsLoc = consumeToken(tok::kw_throws);
+  }
+  auto arrow = new (Context) ArrowExpr(throwsLoc, arrowLoc);
+  return makeParserResult(arrow);
+}
+
 /// parseExprSequence
 ///
 ///   expr-sequence(Mode):
@@ -349,6 +372,15 @@ ParserResult<Expr> Parser::parseExprSequence(Diag<> Message,
       // Jump directly to parsing another operator.
       goto parse_operator;
     }
+
+    case tok::arrow:
+    case tok::kw_throws: {
+      ParserResult<Expr> arrow = parseExprArrow();
+      if (arrow.isNull() || arrow.hasCodeCompletion())
+        return arrow;
+      SequencedExprs.push_back(arrow.get());
+      break;
+    }
         
     default:
       // If the next token is not a binary operator, we're done.
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -2456,6 +2456,10 @@ namespace {
       llvm_unreachable("Expression wasn't parsed?");
     }
 
+    Expr *visitArrowExpr(ArrowExpr *expr) {
+      llvm_unreachable("Arrow expr wasn't converted to type?");
+    }
+
     Expr *visitIdentityExpr(IdentityExpr *expr) {
       expr->setType(expr->getSubExpr()->getType());
       return expr;
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -1713,6 +1713,12 @@ namespace {
       return Type();
     }
 
+    Type visitArrowExpr(ArrowExpr *expr) {
+      // If an ArrowExpr survived until CSGen, then there was an upstream
+      // error that was already reported.
+      return Type();
+    }
+
     Type visitIdentityExpr(IdentityExpr *expr) {
       expr->setType(expr->getSubExpr()->getType());
       return expr->getType();
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -21,6 +21,7 @@
 #include "MiscDiagnostics.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/TypeCheckerDebugConsumer.h"
@@ -676,8 +677,13 @@ namespace {
       ExprStack.pop_back();
 
       // Fold sequence expressions.
-      if (auto seqExpr = dyn_cast<SequenceExpr>(expr))
-        return TC.foldSequence(seqExpr, DC);
+      if (auto seqExpr = dyn_cast<SequenceExpr>(expr)) {
+        auto result = TC.foldSequence(seqExpr, DC);
+        if (auto typeResult = simplifyTypeExpr(result)) {
+          return typeResult;
+        }
+        return result;
+      }
 
       // Type check the type parameters in an UnresolvedSpecializeExpr.
       if (auto us = dyn_cast<UnresolvedSpecializeExpr>(expr)) {
@@ -1032,6 +1038,60 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
     return new (TC.Context) TypeExpr(TypeLoc(NewTypeRepr, Type()));
   }
 
+  // Reinterpret arrow expr T1 -> T2 as function type.
+  // FIXME: support 'inout', etc.
+  if (auto *AE = dyn_cast<ArrowExpr>(E)) {
+    if (!AE->isFolded()) return nullptr;
+    bool HadError = false;
+
+    TypeRepr *ArgsTypeRepr = nullptr;
+    if (auto TyE = dyn_cast<TypeExpr>(AE->getArgsExpr())) {
+      ArgsTypeRepr = TyE->getTypeRepr();
+    } else if (auto TE = dyn_cast<TupleExpr>(AE->getArgsExpr())) {
+      if (TE->getNumElements() == 0) {
+        ArgsTypeRepr = new (TC.Context) TupleTypeRepr({}, TE->getSourceRange(),
+            /*EllipsisLoc*/ SourceLoc(), /*EllipsisIdx*/ 0);
+      }
+    }
+    if (!ArgsTypeRepr) {
+      TC.diagnose(AE->getArgsExpr()->getLoc(),
+                  diag::expected_type_before_arrow);
+      HadError = true;
+    }
+
+    TypeRepr *ResultTypeRepr = nullptr;
+    if (auto TyE = dyn_cast<TypeExpr>(AE->getResultExpr())) {
+      ResultTypeRepr = TyE->getTypeRepr();
+    } else if (auto TE = dyn_cast<TupleExpr>(AE->getResultExpr())) {
+      if (TE->getNumElements() == 0) {
+        ResultTypeRepr = new (TC.Context) TupleTypeRepr({},
+            TE->getSourceRange(), /*EllipsisLoc*/ SourceLoc(),
+            /*EllipsisIdx*/ 0);
+      }
+    } else if (isa<ArrowExpr>(AE->getResultExpr())) {
+      // When simplifying a type expr like "Int -> Int -> Int" the RHS may have
+      // been folded at the same time; recursively simplify it first if
+      // necessary.
+      auto ResultTypeExpr = simplifyTypeExpr(AE->getResultExpr());
+      if (ResultTypeExpr) {
+        ResultTypeRepr = ResultTypeExpr->getTypeRepr();
+      }
+    }
+    if (!ResultTypeRepr) {
+      TC.diagnose(AE->getResultExpr()->getLoc(),
+                  diag::expected_type_after_arrow);
+      HadError = true;
+    }
+
+    if (HadError) return nullptr;
+
+    auto NewTypeRepr =
+      new (TC.Context) FunctionTypeRepr(nullptr, ArgsTypeRepr,
+                                        AE->getThrowsLoc(), AE->getArrowLoc(),
+                                        ResultTypeRepr);
+    return new (TC.Context) TypeExpr(TypeLoc(NewTypeRepr, Type()));
+  }
+
   return nullptr;
 }
 
diff --git a/lib/Sema/TypeCheckExpr.cpp b/lib/Sema/TypeCheckExpr.cpp
@@ -182,6 +182,12 @@ static InfixData getInfixData(TypeChecker &TC, DeclContext *DC, Expr *E) {
       return op->getInfixData();
   }
 
+  if (isa<ArrowExpr>(E)) {
+    return InfixData(IntrinsicPrecedences::ArrowExpr,
+                     Associativity::Right,
+                     /*assignment*/ false);
+  }
+
   // If E is already an ErrorExpr, then we've diagnosed it as invalid already,
   // otherwise emit an error.
   if (!isa<ErrorExpr>(E))
@@ -305,6 +311,14 @@ static Expr *makeBinOp(TypeChecker &TC, Expr *Op, Expr *LHS, Expr *RHS,
     as->setSubExpr(LHS);    
     return makeResultExpr(as);
   }
+
+  if (auto *arrow = dyn_cast<ArrowExpr>(Op)) {
+    // Resolve the '->' expression.
+    assert(!arrow->isFolded() && "already folded '->' expr in sequence?!");
+    arrow->setArgsExpr(LHS);
+    arrow->setResultExpr(RHS);
+    return makeResultExpr(arrow);
+  }
   
   // Build the argument to the operation.
   Expr *ArgElts[] = { LHS, RHS };
diff --git a/test/Parse/type_expr.swift b/test/Parse/type_expr.swift
@@ -170,3 +170,32 @@ func meta_metatypes() {
   _ = P.Protocol.Type.self
   _ = B.Type.self
 }
+
+// https://bugs.swift.org/browse/SR-502
+func testFunctionCollectionTypes() {
+  _ = [Int -> Int]()
+  _ = [(Int) -> Int]()
+  _ = [(Int, Int) -> Int]()
+  _ = [(x: Int, y: Int) -> Int]()
+  // Make sure associativity is correct
+  let a = [Int -> Int -> Int]()
+  let b: Int = a[0](5)(4)
+
+  _ = [String: Int -> Int]()
+  _ = [String: (Int, Int) -> Int]()
+
+  _ = [1 -> Int]() // expected-error{{expected type before '->'}}
+  _ = [Int -> 1]() // expected-error{{expected type after '->'}}
+
+  // Should parse () as void type when before or after arrow
+  _ = [() -> Int]()
+  _ = [Int -> ()]()
+
+  _ = [Int throws -> Int]()
+  _ = [Int -> throws Int]() // expected-error{{'throws' may only occur before '->'}}
+  _ = [Int throws Int]() // expected-error{{'throws' may only occur before '->'}}
+
+  let _ = Int -> Int // expected-error{{expected member name or constructor call after type name}} expected-note{{add arguments after the type to construct a value of the type}} expected-note{{use '.self' to reference the type object}}
+  let _ = 2 + () -> Int // expected-error{{expected type before '->'}}
+  let _ = () -> (Int, Int).2 // expected-error{{expected type after '->'}}
+}
