Transform EditorPlaceholderExpr into trap if executed in playground

mode (take 2)

Allow untyped placeholder to take arbitrary type, but default to Void.
Add _undefined<T>() function, which is like fatalError() but has
arbitrary return type. In playground mode, merely warn about outstanding
placeholders instead of erroring out, and transform placeholders into
calls to _undefined(). This way, code with outstanding placeholders will
only crash when it attempts to evaluate such placeholders.

When generating constraints for an iterated sequence of type T, emit

    T convertible to $T1
    $T1 conforms to SequenceType

instead of

    T convertible to SequenceType

This ensures that an untyped placeholder in for-each sequence position
doesn't get inferred to have type SequenceType. (The conversion is still
necessary because the sequence may have IUO type.) The new constraint
system precipitates changes in CSSimplify and CSDiag, and ends up fixing
18741539 along the way.

(NOTE: There is a small regression in diagnosis of issues like the
following:

    class C {}
    class D: C {}
    func f(a: [C]!) { for _: D in a {} }

It complains that [C]! doesn't conform to SequenceType when it should be
complaining that C is not convertible to D.)

<rdar://problem/21167372>

(Originally Swift SVN r31481)

Author: cwillmor

include/swift/AST/ASTContext.h

@@ -481,6 +481,9 @@ class ASTContext {
   /// Retrieve the declaration of Swift._unimplemented_initializer.
   FuncDecl *getUnimplementedInitializerDecl(LazyResolver *resolver) const;
 
+  /// Retrieve the declaration of Swift._undefined.
+  FuncDecl *getUndefinedDecl(LazyResolver *resolver) const;
+
   // Retrieve the declaration of Swift._stdlib_isOSVersionAtLeast.
   FuncDecl *getIsOSVersionAtLeastDecl(LazyResolver *resolver) const;
 

include/swift/AST/DiagnosticsParse.def

@@ -132,6 +132,8 @@ ERROR(lex_unary_postfix_dot_is_reserved,lexing,none,
       "postfix '.' is reserved", ())
 ERROR(lex_editor_placeholder,lexing,none,
       "editor placeholder in source file", ())
+WARNING(lex_editor_placeholder_in_playground,lexing,none,
+        "editor placeholder in source file", ())
 
 //------------------------------------------------------------------------------
 // Declaration parsing diagnostics

include/swift/AST/DiagnosticsSema.def

@@ -832,6 +832,8 @@ NOTE(note_no_in_class_init_3plus,sema_tcd,none,
      (Identifier, Identifier, Identifier, bool))
 ERROR(missing_unimplemented_init_runtime,sema_tcd,none,
       "standard library error: missing _unimplemented_initializer", ())
+ERROR(missing_undefined_runtime,sema_tcd,none,
+      "standard library error: missing _undefined", ())
 WARNING(unsupported_synthesize_init_variadic,sema_tcd,none,
         "synthesizing a variadic inherited initializer for subclass %0 is "
         "unsupported",

include/swift/AST/Expr.h

@@ -3745,6 +3745,7 @@ class EditorPlaceholderExpr : public Expr {
   SourceLoc Loc;
   TypeLoc PlaceholderTy;
   TypeRepr *ExpansionTyR;
+  Expr *SemanticExpr;
 
 public:
   EditorPlaceholderExpr(Identifier Placeholder, SourceLoc Loc,
@@ -3753,7 +3754,8 @@ class EditorPlaceholderExpr : public Expr {
     : Expr(ExprKind::EditorPlaceholder, /*Implicit=*/false),
       Placeholder(Placeholder), Loc(Loc),
       PlaceholderTy(PlaceholderTy),
-      ExpansionTyR(ExpansionTyR) {
+      ExpansionTyR(ExpansionTyR),
+      SemanticExpr(nullptr) {
   }
 
   Identifier getPlaceholder() const { return Placeholder; }
@@ -3767,6 +3769,9 @@ class EditorPlaceholderExpr : public Expr {
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::EditorPlaceholder;
   }
+
+  Expr *getSemanticExpr() const { return SemanticExpr; }
+  void setSemanticExpr(Expr *SE) { SemanticExpr = SE; }
 };
 
 #undef SWIFT_FORWARD_SOURCE_LOCS_TO

include/swift/AST/ExprNodes.def

@@ -156,7 +156,7 @@ EXPR(Assign, Expr)
 EXPR(DefaultValue, Expr)
 EXPR(CodeCompletion, Expr)
 UNCHECKED_EXPR(UnresolvedPattern, Expr)
-UNCHECKED_EXPR(EditorPlaceholder, Expr)
+EXPR(EditorPlaceholder, Expr)
 
 #undef EXPR_RANGE
 #undef UNCHECKED_EXPR

lib/AST/ASTContext.cpp

@@ -177,6 +177,9 @@ struct ASTContext::Implementation {
   /// func _unimplemented_initializer(className: StaticString).
   FuncDecl *UnimplementedInitializerDecl = nullptr;
 
+  /// func _undefined<T>(msg: StaticString, file: StaticString, line: UInt) -> T
+  FuncDecl *UndefinedDecl = nullptr;
+
   /// func _stdlib_isOSVersionAtLeast(Builtin.Word,Builtin.Word, Builtin.word)
   //    -> Builtin.Int1
   FuncDecl *IsOSVersionAtLeastDecl = nullptr;
@@ -985,6 +988,21 @@ ASTContext::getUnimplementedInitializerDecl(LazyResolver *resolver) const {
   return decl;
 }
 
+FuncDecl *
+ASTContext::getUndefinedDecl(LazyResolver *resolver) const {
+  if (Impl.UndefinedDecl)
+    return Impl.UndefinedDecl;
+
+  // Look for the function.
+  CanType input, output;
+  auto decl = findLibraryIntrinsic(*this, "_undefined", resolver);
+  if (!decl)
+    return nullptr;
+
+  Impl.UndefinedDecl = decl;
+  return decl;
+}
+
 FuncDecl *ASTContext::getIsOSVersionAtLeastDecl(LazyResolver *resolver) const {
   if (Impl.IsOSVersionAtLeastDecl)
     return Impl.IsOSVersionAtLeastDecl;

lib/AST/ASTWalker.cpp

@@ -824,6 +824,7 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
   }
 
   Expr *visitEditorPlaceholderExpr(EditorPlaceholderExpr *E) {
+    HANDLE_SEMANTIC_EXPR(E);
     return E;
   }
 

lib/AST/Expr.cpp

@@ -286,6 +286,7 @@ void Expr::propagateLValueAccessKind(AccessKind accessKind,
     LEAF_LVALUE_EXPR(DiscardAssignment)
     LEAF_LVALUE_EXPR(DynamicLookup)
     LEAF_LVALUE_EXPR(OpaqueValue)
+    LEAF_LVALUE_EXPR(EditorPlaceholder)
 
     COMPLETE_PHYSICAL_LVALUE_EXPR(AnyTry, getSubExpr())
     PARTIAL_PHYSICAL_LVALUE_EXPR(BindOptional, getSubExpr())

lib/AST/Verifier.cpp

@@ -462,8 +462,8 @@ struct ASTNodeBase {};
               } while (!activeScope->isModuleScopeContext());
             }
 
-            Out << "AST verification error: archetype " << archetype
-                << " not allowed in this context\n";
+            Out << "AST verification error: archetype "
+                << archetype->getString() << " not allowed in this context\n";
 
             auto knownDC = Ctx.ArchetypeContexts.find(archetype);
             if (knownDC != Ctx.ArchetypeContexts.end()) {

lib/Parse/Lexer.cpp

@@ -1279,9 +1279,13 @@ void Lexer::tryLexEditorPlaceholder() {
     if (Ptr[0] == '<' && Ptr[1] == '#')
       break;
     if (Ptr[0] == '#' && Ptr[1] == '>') {
-      // Found it. Flag it as error for the rest of the compiler pipeline and
-      // lex it as an identifier.
-      diagnose(TokStart, diag::lex_editor_placeholder);
+      // Found it. Flag it as error (or warning, if in playground mode) for the
+      // rest of the compiler pipeline and lex it as an identifier.
+      if (LangOpts.Playground) {
+        diagnose(TokStart, diag::lex_editor_placeholder_in_playground);
+      } else {
+        diagnose(TokStart, diag::lex_editor_placeholder);
+      }
       CurPtr = Ptr+2;
       formToken(tok::identifier, TokStart);
       return;