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;

lib/SILGen/SILGenExpr.cpp

@@ -196,6 +196,7 @@ namespace {
     RValue visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E,
                                               SGFContext C);
     RValue visitObjectLiteralExpr(ObjectLiteralExpr *E, SGFContext C);
+    RValue visitEditorPlaceholderExpr(EditorPlaceholderExpr *E, SGFContext C);
     RValue visitMagicIdentifierLiteralExpr(MagicIdentifierLiteralExpr *E,
                                            SGFContext C);
     RValue visitCollectionExpr(CollectionExpr *E, SGFContext C);
@@ -1956,6 +1957,11 @@ visitObjectLiteralExpr(ObjectLiteralExpr *E, SGFContext C) {
   return visit(E->getSemanticExpr(), C);
 }
 
+RValue RValueEmitter::
+visitEditorPlaceholderExpr(EditorPlaceholderExpr *E, SGFContext C) {
+  return visit(E->getSemanticExpr(), C);
+}
+
 static StringRef
 getMagicFunctionString(SILGenFunction &gen) {
   assert(gen.MagicFunctionName

lib/Sema/CSApply.cpp

@@ -3247,6 +3247,29 @@ namespace {
     }
 
     Expr *visitEditorPlaceholderExpr(EditorPlaceholderExpr *E) {
+      Type valueType = simplifyType(E->getType());
+      E->setType(valueType);
+
+      auto &tc = cs.getTypeChecker();
+      auto &ctx = tc.Context;
+      // Synthesize a call to _undefined() of appropriate type.
+      FuncDecl *undefinedDecl = ctx.getUndefinedDecl(&tc);
+      if (!undefinedDecl) {
+        tc.diagnose(E->getLoc(), diag::missing_undefined_runtime);
+        return nullptr;
+      }
+      DeclRefExpr *fnRef = new (ctx) DeclRefExpr(undefinedDecl, SourceLoc(),
+                                                 /*Implicit=*/true);
+      StringRef msg = "attempt to evaluate editor placeholder";
+      Expr *argExpr = new (ctx) StringLiteralExpr(msg, E->getLoc(),
+                                                  /*implicit*/true);
+      argExpr = new (ctx) ParenExpr(E->getLoc(), argExpr, E->getLoc(),
+                                    /*hasTrailingClosure*/false);
+      Expr *callExpr = new (ctx) CallExpr(fnRef, argExpr, /*implicit*/true);
+      bool invalid = tc.typeCheckExpression(callExpr, cs.DC, valueType,
+                                            CTP_CannotFail);
+      assert(!invalid && "conversion cannot fail");
+      E->setSemanticExpr(callExpr);
       return E;
     }
 

lib/Sema/CSDiag.cpp

@@ -2014,14 +2014,16 @@ static bool isConversionConstraint(const Constraint *C) {
 /// low that we would only like to issue an error message about it if there is
 /// nothing else interesting we can scrape out of the constraint system.
 static bool isLowPriorityConstraint(Constraint *C) {
-  // If the member constraint is a ".Element" lookup to find the element type of
-  // a generator in a foreach loop, then it is very low priority: We will get a
-  // better and more useful diagnostic from the failed conversion to
-  // SequenceType that will fail as well.
+  // If the member constraint is a ".Generator" lookup to find the generator
+  // type in a foreach loop, or a ".Element" lookup to find its element type,
+  // then it is very low priority: We will get a better and more useful
+  // diagnostic from the failed conversion to SequenceType that will fail as
+  // well.
   if (C->getKind() == ConstraintKind::TypeMember) {
     if (auto *loc = C->getLocator())
       for (auto Elt : loc->getPath())
-        if (Elt.getKind() ==  ConstraintLocator::GeneratorElementType)
+        if (Elt.getKind() == ConstraintLocator::GeneratorElementType ||
+            Elt.getKind() == ConstraintLocator::SequenceGeneratorType)
           return true;
   }
 
@@ -2457,7 +2459,7 @@ bool FailureDiagnosis::diagnoseGeneralConversionFailure(Constraint *constraint){
 
   Type fromType = CS->simplifyType(constraint->getFirstType());
 
-  if (fromType->is<TypeVariableType>() && resolvedAnchorToExpr) {
+  if (fromType->hasTypeVariable() && resolvedAnchorToExpr) {
     TCCOptions options;
 
     // If we know we're removing a contextual constraint, then we can force a
@@ -2548,12 +2550,16 @@ bool FailureDiagnosis::diagnoseGeneralConversionFailure(Constraint *constraint){
       return true;
     }
 
-    // Emit a conformance error through conformsToProtocol.  If this succeeds,
-    // then keep searching.
+    // Emit a conformance error through conformsToProtocol.  If this succeeds
+    // and yields a valid protocol conformance, then keep searching.
+    ProtocolConformance *Conformance = nullptr;
     if (CS->TC.conformsToProtocol(fromType, PT->getDecl(), CS->DC,
                                   ConformanceCheckFlags::InExpression,
-                                  nullptr, expr->getLoc()))
-      return false;
+                                  &Conformance, expr->getLoc())) {
+      if (!Conformance || !Conformance->isInvalid()) {
+        return false;
+      }
+    }
     return true;
   }
 

lib/Sema/CSGen.cpp

@@ -2471,9 +2471,20 @@ namespace {
     }
 
     Type visitEditorPlaceholderExpr(EditorPlaceholderExpr *E) {
+      if (E->getTypeLoc().isNull()) {
+        auto locator = CS.getConstraintLocator(E);
+        auto placeholderTy = CS.createTypeVariable(locator, /*options*/0);
+        // A placeholder may have any type, but default to Void type if
+        // otherwise unconstrained.
+        CS.addConstraint(ConstraintKind::Defaultable,
+                         placeholderTy, TupleType::getEmpty(CS.getASTContext()),
+                         locator);
+        E->setType(placeholderTy);
+      }
+      // NOTE: The type loc may be there but have failed to validate, in which
+      // case we return the null type.
       return E->getType();
     }
-
   };
 
   /// \brief AST walker that "sanitizes" an expression for the

lib/Sema/CSSimplify.cpp

@@ -2290,12 +2290,30 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     llvm_unreachable("bad constraint kind");
   }
 
-  if (!type->getAnyOptionalObjectType().isNull() &&
-      protocol->isSpecificProtocol(KnownProtocolKind::BooleanType)) {
-    Fixes.push_back({FixKind::OptionalToBoolean,
-      getConstraintLocator(locator)});
-    
-    return SolutionKind::Solved;
+  if (!shouldAttemptFixes())
+    return SolutionKind::Error;
+
+  // See if there's anything we can do to fix the conformance:
+  OptionalTypeKind optionalKind;
+  if (auto optionalObjectType = type->getAnyOptionalObjectType(optionalKind)) {
+    if (protocol->isSpecificProtocol(KnownProtocolKind::BooleanType)) {
+      // Optionals don't conform to BooleanType; suggest '!= nil'.
+      if (recordFix(FixKind::OptionalToBoolean, getConstraintLocator(locator)))
+        return SolutionKind::Error;
+      return SolutionKind::Solved;
+    } else if (optionalKind == OTK_Optional) {
+      // The underlying type of an optional may conform to the protocol if the
+      // optional doesn't; suggest forcing if that's the case.
+      auto result = simplifyConformsToConstraint(
+        optionalObjectType, protocol, kind,
+        locator.withPathElement(LocatorPathElt::getGenericArgument(0)), flags);
+      if (result == SolutionKind::Solved) {
+        if (recordFix(FixKind::ForceOptional, getConstraintLocator(locator))) {
+          return SolutionKind::Error;
+        }
+      }
+      return result;
+    }
   }
 
   // There's nothing more we can do; fail.