xxx

Author: hamishknight

include/swift/AST/ASTScope.h

@@ -955,6 +955,7 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
 
 protected:
   bool lookupLocalsOrMembers(DeclConsumer) const override;
+  bool isLabeledStmtLookupTerminator() const override;
 };
 
 /// The scope introduced by a conditional clause initializer in an

include/swift/AST/ASTTypeIDZone.def

@@ -26,6 +26,7 @@ SWIFT_TYPEID(Fingerprint)
 SWIFT_TYPEID(GenericSignature)
 SWIFT_TYPEID(ImplicitImportList)
 SWIFT_TYPEID(ImplicitMemberAction)
+SWIFT_TYPEID(IsSingleValueStmtResult)
 SWIFT_TYPEID(ParamSpecifier)
 SWIFT_TYPEID(PropertyWrapperAuxiliaryVariables)
 SWIFT_TYPEID(PropertyWrapperInitializerInfo)

include/swift/AST/ASTTypeIDs.h

@@ -41,6 +41,7 @@ class GenericParamList;
 class GenericSignature;
 class GenericTypeParamType;
 class InfixOperatorDecl;
+class IsSingleValueStmtResult;
 class IterableDeclContext;
 class ModuleDecl;
 struct ImplicitImportList;

include/swift/AST/DiagnosticsSema.def

@@ -1080,6 +1080,31 @@ ERROR(ternary_expr_cases_mismatch,none,
       "result values in '? :' expression have mismatching types %0 and %1",
       (Type, Type))
 
+ERROR(single_value_stmt_branches_mismatch,none,
+      "branches have mismatching types %0 and %1",
+      (Type, Type))
+
+ERROR(single_value_stmt_out_of_place,none,
+      "'%0' may only be used as expression in return, throw, coercion, or as "
+      "the source of an assignment",
+      (StmtKind))
+
+ERROR(single_value_stmt_must_be_unlabeled,none,
+      "'%0' cannot have a jump label when used as expression",
+      (StmtKind))
+
+ERROR(if_expr_must_be_syntactically_exhaustive,none,
+      "'if' must have an unconditional 'else' to be used as expression",
+      ())
+
+ERROR(single_value_stmt_branch_must_return_or_throw,none,
+      "non-expression branch of '%0' expression must end in "
+      "'return' or 'throw'", (StmtKind))
+
+ERROR(cannot_jump_in_single_value_stmt,none,
+      "cannot '%0' in '%1' when used as expression",
+      (StmtKind, StmtKind))
+
 ERROR(did_not_call_function_value,none,
       "function value was used as a property; add () to call it",
       ())
@@ -4353,6 +4378,10 @@ WARNING(trailing_closure_requires_parens,none,
         " statement; pass as a parenthesized argument to silence this warning",
         ())
 
+// Statements as expressions
+ERROR(non_single_value_stmt_as_expr,none,
+      "expected single expression branches for expression statement", ())
+
 ERROR(opaque_type_no_underlying_type_candidates,none,
       "function declares an opaque return type, but has no return statements "
       "in its body from which to infer an underlying type", ())

include/swift/AST/Expr.h

@@ -5935,6 +5935,55 @@ class KeyPathDotExpr : public Expr {
   }
 };
 
+/// An expression that may wrap a statement which produces a single value.
+class SingleValueStmtExpr : public Expr {
+public:
+  enum class Kind {
+    If, Switch
+  };
+
+private:
+  Stmt *S;
+  DeclContext *DC;
+
+  SingleValueStmtExpr(Stmt *S, DeclContext *DC)
+      : Expr(ExprKind::SingleValueStmt, /*isImplicit*/ true), S(S), DC(DC) {}
+
+public:
+  /// Creates a new SingleValueStmtExpr wrapping a statement.
+  static SingleValueStmtExpr *create(ASTContext &ctx, Stmt *S, DeclContext *DC);
+
+  /// Creates a new SingleValueStmtExpr wrapping a statement, and recursively
+  /// attempts to wrap any branches of that statement that can become a single
+  /// value statement expression. If \p forParse is true, branches will be
+  /// eagerly wrapped even if they may not be valid SingleValueStmtExprs.
+  static SingleValueStmtExpr *createWithWrappedBranches(ASTContext &ctx, Stmt *S,
+                                                        DeclContext *DC,
+                                                        bool forParse);
+  /// Retrieve the wrapped statement.
+  Stmt *getStmt() const { return S; }
+  void setStmt(Stmt *newS) { S = newS; }
+
+  /// Retrieve the kind of statement being wrapped.
+  Kind getStmtKind() const;
+
+  /// Retrieve the complete set of branches for the underlying statement.
+  ArrayRef<Stmt *> getBranches(SmallVectorImpl<Stmt *> &scratch) const;
+
+  /// Retrieve the single expression branches of the statement, excluding
+  /// branches that either have multiple expressions, or have statements.
+  ArrayRef<Expr *>
+  getSingleExprBranches(SmallVectorImpl<Expr *> &scratch) const;
+
+  DeclContext *getDeclContext() const { return DC; }
+
+  SourceRange getSourceRange() const;
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::SingleValueStmt;
+  }
+};
+
 /// Expression node that effects a "one-way" constraint in
 /// the constraint system, allowing type information to flow from the
 /// subexpression outward but not the other way.

include/swift/AST/ExprNodes.def

@@ -203,6 +203,7 @@ EXPR(LazyInitializer, Expr)
 EXPR(EditorPlaceholder, Expr)
 EXPR(ObjCSelector, Expr)
 EXPR(KeyPath, Expr)
+EXPR(SingleValueStmt, Expr)
 UNCHECKED_EXPR(KeyPathDot, Expr)
 UNCHECKED_EXPR(OneWay, Expr)
 EXPR(Tap, Expr)

include/swift/AST/Stmt.h

@@ -35,13 +35,15 @@ class ASTContext;
 class ASTWalker;
 class Decl;
 class DeclContext;
+class Evaluator;
 class Expr;
 class FuncDecl;
 class Pattern;
 class PatternBindingDecl;
 class VarDecl;
 class CaseStmt;
 class DoCatchStmt;
+class IsSingleValueStmtResult;
 class SwitchStmt;
 
 enum class StmtKind {
@@ -133,7 +135,12 @@ class alignas(8) Stmt : public ASTAllocated<Stmt> {
 
   SourceRange getSourceRange() const;
   SourceLoc TrailingSemiLoc;
-  
+
+  /// Whether the statement can produce a single value, and as such may be
+  /// treated as an expression.
+  IsSingleValueStmtResult mayProduceSingleValue(Evaluator &eval) const;
+  IsSingleValueStmtResult mayProduceSingleValue(ASTContext &ctx) const;
+
   /// isImplicit - Determines whether this statement was implicitly-generated,
   /// rather than explicitly written in the AST.
   bool isImplicit() const { return Bits.Stmt.Implicit; }
@@ -204,6 +211,8 @@ class BraceStmt final : public Stmt,
 
   ASTNode findAsyncNode();
 
+  Expr *getSingleExpressionBody() const;
+
   static bool classof(const Stmt *S) { return S->getKind() == StmtKind::Brace; }
 };
 
@@ -711,7 +720,14 @@ class IfStmt : public LabeledConditionalStmt {
 
   Stmt *getElseStmt() const { return Else; }
   void setElseStmt(Stmt *s) { Else = s; }
-  
+
+  /// Retrieve the complete set of branches for this if statement, including
+  /// else if statements.
+  ArrayRef<Stmt *> getBranches(SmallVectorImpl<Stmt *> &scratch) const;
+
+  /// Whether the if statement has an unconditional \c else.
+  bool isSyntacticallyExhaustive() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Stmt *S) { return S->getKind() == StmtKind::If; }
 };
@@ -1283,7 +1299,10 @@ class SwitchStmt final : public LabeledStmt,
   AsCaseStmtRange getCases() const {
     return AsCaseStmtRange(getRawCases(), AsCaseStmtWithSkippingNonCaseStmts());
   }
-  
+
+  /// Retrieve the complete set of branches for this switch statement.
+  ArrayRef<Stmt *> getBranches(SmallVectorImpl<Stmt *> &scratch) const;
+
   static bool classof(const Stmt *S) {
     return S->getKind() == StmtKind::Switch;
   }

include/swift/AST/TypeCheckRequests.h

@@ -3752,6 +3752,100 @@ class GetTypeWrapperInitializer
   bool isCached() const { return true; }
 };
 
+/// The result of the query for whether a statement can produce a single value.
+class IsSingleValueStmtResult {
+public:
+  enum class Kind {
+    Valid,
+    UnterminatedBranch,
+    NonExhaustiveIf,
+    NoExpressionBranches,
+    UnhandledStmt,
+    CircularReference,
+    InvalidJumps,
+    HasLabel
+  };
+
+private:
+  Kind TheKind;
+  Stmt *UnterminatedBranch;
+  std::vector<Stmt *> InvalidJumps;
+
+  IsSingleValueStmtResult(Kind kind)
+    : TheKind(kind), UnterminatedBranch(nullptr) {
+    assert(kind != Kind::UnterminatedBranch && kind != Kind::InvalidJumps);
+  }
+
+  IsSingleValueStmtResult(Kind kind, Stmt *unterminatedBranch)
+    : TheKind(kind), UnterminatedBranch(unterminatedBranch) {
+      assert(kind == Kind::UnterminatedBranch);
+    }
+
+  IsSingleValueStmtResult(Kind kind, std::vector<Stmt *> invalidJumps)
+    : TheKind(kind), InvalidJumps(std::move(invalidJumps)) {
+      assert(kind == Kind::InvalidJumps);
+    }
+
+public:
+  static IsSingleValueStmtResult valid() {
+    return IsSingleValueStmtResult(Kind::Valid);
+  }
+  static IsSingleValueStmtResult unterminatedBranch(Stmt *branch) {
+    return IsSingleValueStmtResult(Kind::UnterminatedBranch, branch);
+  }
+  static IsSingleValueStmtResult nonExhaustiveIf() {
+    return IsSingleValueStmtResult(Kind::NonExhaustiveIf);
+  }
+  static IsSingleValueStmtResult noExpressionBranches() {
+    return IsSingleValueStmtResult(Kind::NoExpressionBranches);
+  }
+  static IsSingleValueStmtResult unhandledStmt() {
+    return IsSingleValueStmtResult(Kind::UnhandledStmt);
+  }
+  static IsSingleValueStmtResult circularReference() {
+    return IsSingleValueStmtResult(Kind::CircularReference);
+  }
+  static IsSingleValueStmtResult invalidJumps(std::vector<Stmt *> jumps) {
+    return IsSingleValueStmtResult(Kind::InvalidJumps, std::move(jumps));
+  }
+  static IsSingleValueStmtResult hasLabel() {
+    return IsSingleValueStmtResult(Kind::HasLabel);
+  }
+
+  Kind getKind() const { return TheKind; }
+
+  Stmt *getUnterminatedBranch() const {
+    assert(TheKind == Kind::UnterminatedBranch);
+    return UnterminatedBranch;
+  }
+
+  const std::vector<Stmt *> &getInvalidJumps() const {
+    assert(TheKind == Kind::InvalidJumps);
+    return InvalidJumps;
+  }
+
+  explicit operator bool() const {
+    return TheKind == Kind::Valid;
+  }
+};
+
+class IsSingleValueStmtRequest
+    : public SimpleRequest<IsSingleValueStmtRequest,
+                           IsSingleValueStmtResult(const Stmt *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  IsSingleValueStmtResult
+  evaluate(Evaluator &evaluator, const Stmt *stmt) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Find the definition of a given macro.
 class MacroDefinitionRequest
     : public SimpleRequest<MacroDefinitionRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -443,6 +443,9 @@ SWIFT_REQUEST(TypeChecker, ContinueTargetRequest,
 SWIFT_REQUEST(TypeChecker, GetTypeWrapperInitializer,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsSingleValueStmtRequest,
+              IsSingleValueStmtResult(const Stmt *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, MacroDefinitionRequest,
               MacroDefinition(MacroDecl *),
               Cached, NoLocationInfo)

include/swift/Basic/Features.def

@@ -136,6 +136,9 @@ EXPERIMENTAL_FEATURE(ParserRoundTrip, false)
 /// Swift parser.
 EXPERIMENTAL_FEATURE(ParserValidation, false)
 
+/// Whether to allow 'if' and 'switch' statements to be treated as expressions.
+EXPERIMENTAL_FEATURE(StatementExpressions, false)
+
 /// Whether to fold sequence expressions in the syntax tree produced by the
 /// Swift Swift parser.
 EXPERIMENTAL_FEATURE(ParserSequenceFolding, false)

include/swift/Parse/Parser.h

@@ -50,6 +50,7 @@ namespace swift {
   class RequirementRepr;
   class SILParserStateBase;
   class ScopeInfo;
+  class SingleValueStmtExpr;
   class SourceManager;
   class TupleType;
   class TypeLoc;

include/swift/Sema/CompletionContextFinder.h

@@ -23,6 +23,7 @@ namespace swift {
 class CompletionContextFinder : public ASTWalker {
   enum class ContextKind {
     FallbackExpression,
+    SingleValueStmtExpr,
     StringInterpolation,
     SingleStmtClosure,
     MultiStmtClosure,
@@ -78,6 +79,10 @@ class CompletionContextFinder : public ASTWalker {
     return hasContext(ContextKind::StringInterpolation);
   }
 
+  bool locatedInSingleValueStmtExpr() const {
+    return hasContext(ContextKind::SingleValueStmtExpr);
+  }
+
   bool hasCompletionExpr() const {
     return CompletionNode.dyn_cast<CodeCompletionExpr *>() != nullptr;
   }

include/swift/Sema/ConstraintLocator.h

@@ -85,6 +85,16 @@ enum ContextualTypePurpose : uint8_t {
   CTP_ComposedPropertyWrapper, ///< Composed wrapper type expected to match
                                ///< former 'wrappedValue' type
 
+  CTP_SingleValueStmtBranch, ///< The contextual type for a branch in a single
+                             ///< value statement expression.
+
+  // FIXME: This is only really for closures...
+  CTP_SingleValueStmtBranchInSingleExprReturn, ///< The contextual type for a
+                                               ///< branch in a single value
+                                               ///< statement expression that's
+                                               ///< part of a single expression
+                                               ///< return.
+
   CTP_ExprPattern,      ///< `~=` operator application associated with expression
                         /// pattern.
 
@@ -292,6 +302,10 @@ class ConstraintLocator : public llvm::FoldingSetNode {
   /// Determine whether this locator is for a result builder body result type.
   bool isForResultBuilderBodyResult() const;
 
+  bool isForSingleValueStmtConjunction() const;
+
+  bool isForSingleValueStmtBranchInSingleExprReturn() const;
+
   /// Determine whether this locator points directly to a given expression.
   template <typename E> bool directlyAt() const {
     if (auto *expr = getAnchor().dyn_cast<Expr *>())
@@ -883,6 +897,22 @@ class LocatorPathElt::TernaryBranch final : public StoredIntegerElement<1> {
   }
 };
 
+/// The branch of a SingleValueStmtExpr. Note the stored index corresponds to
+/// the expression branches, i.e it skips statement branch indices.
+class LocatorPathElt::SingleValueStmtBranch final
+    : public StoredIntegerElement<1> {
+public:
+  SingleValueStmtBranch(unsigned exprIdx)
+      : StoredIntegerElement(ConstraintLocator::SingleValueStmtBranch,
+                             exprIdx) {}
+
+  unsigned getExprBranchIndex() const { return getValue(); }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == ConstraintLocator::SingleValueStmtBranch;
+  }
+};
+
 class LocatorPathElt::PatternMatch final : public StoredPointerElement<Pattern> {
 public:
   PatternMatch(Pattern *pattern)