Merge pull request #38788 from hamishknight/literally

Remove some obsolete literal handling logic

Author: hamishknight

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -875,28 +875,7 @@ constantFoldAndCheckIntegerConversions(BuiltinInst *BI,
 template<unsigned N>
 static bool tryExtractLiteralText(FloatLiteralInst *flitInst,
                                   SmallString<N> &fpStr) {
-
-  Expr *expr = flitInst->getLoc().getAsASTNode<Expr>();
-  if (!expr)
-    return false;
-
-  // 'expr' may not be a FloatLiteralExpr since 'flitInst' could have been
-  // created by the ConstantFolder by folding floating-point constructor calls.
-  // So we iterate through the sequence of folded constructors if any, and
-  // try to extract the FloatLiteralExpr.
-  while (auto *callExpr = dyn_cast<CallExpr>(expr)) {
-    if (callExpr->getNumArguments() != 1 ||
-         !dyn_cast<ConstructorRefCallExpr>(callExpr->getFn()))
-      break;
-
-    auto *tupleExpr = dyn_cast<TupleExpr>(callExpr->getArg());
-    if (!tupleExpr)
-      break;
-
-    expr = tupleExpr->getElement(0);
-  }
-
-  auto *flitExpr = dyn_cast<FloatLiteralExpr>(expr);
+  auto *flitExpr = flitInst->getLoc().getAsASTNode<FloatLiteralExpr>();
   if (!flitExpr)
     return false;
 
@@ -1074,27 +1053,8 @@ bool isLossyUnderflow(APFloat srcVal, BuiltinFloatType *srcType,
 /// This function determines whether the float literal in the given
 /// SIL instruction is specified using hex-float notation in the Swift source.
 bool isHexLiteralInSource(FloatLiteralInst *flitInst) {
-  Expr *expr = flitInst->getLoc().getAsASTNode<Expr>();
-  if (!expr)
-    return false;
-
-  // Iterate through a sequence of folded implicit constructors if any, and
-  // try to extract the FloatLiteralExpr.
-  while (auto *callExpr = dyn_cast<CallExpr>(expr)) {
-    if (!callExpr->isImplicit() || callExpr->getNumArguments() != 1 ||
-        !dyn_cast<ConstructorRefCallExpr>(callExpr->getFn()))
-      break;
-
-    auto *tupleExpr = dyn_cast<TupleExpr>(callExpr->getArg());
-    if (!tupleExpr)
-      break;
-
-    expr = tupleExpr->getElement(0);
-  }
-  auto *flitExpr = dyn_cast<FloatLiteralExpr>(expr);
-  if (!flitExpr)
-    return false;
-  return flitExpr->getDigitsText().startswith("0x");
+  auto *flitExpr = flitInst->getLoc().getAsASTNode<FloatLiteralExpr>();
+  return flitExpr && flitExpr->getDigitsText().startswith("0x");
 }
 
 bool maybeExplicitFPCons(BuiltinInst *BI, const BuiltinInfo &Builtin) {

lib/Sema/CSDiagnostics.cpp

@@ -1988,19 +1988,6 @@ bool AssignmentFailure::diagnoseAsError() {
   // If the expression is the result of a call, it is an rvalue, not a mutable
   // lvalue.
   if (auto *AE = dyn_cast<ApplyExpr>(immutableExpr)) {
-    // Handle literals, which are a call to the conversion function.
-    auto argsTuple =
-        dyn_cast<TupleExpr>(AE->getArg()->getSemanticsProvidingExpr());
-    if (isa<CallExpr>(AE) && AE->isImplicit() && argsTuple &&
-        argsTuple->getNumElements() == 1) {
-      if (auto LE = dyn_cast<LiteralExpr>(
-              argsTuple->getElement(0)->getSemanticsProvidingExpr())) {
-        emitDiagnosticAt(Loc, DeclDiagnostic, "literals are not mutable")
-            .highlight(LE->getSourceRange());
-        return true;
-      }
-    }
-
     std::string name = "call";
     if (isa<PrefixUnaryExpr>(AE) || isa<PostfixUnaryExpr>(AE))
       name = "unary operator";

lib/Sema/TypeCheckStmt.cpp

@@ -1421,21 +1421,7 @@ void TypeChecker::checkIgnoredExpr(Expr *E) {
 
     // Otherwise, complain.  Start with more specific diagnostics.
 
-    // Diagnose unused literals that were translated to implicit
-    // constructor calls during CSApply / ExprRewriter::convertLiteral.
-    if (call->isImplicit()) {
-      Expr *arg = call->getArg();
-      if (auto *TE = dyn_cast<TupleExpr>(arg))
-        if (TE->getNumElements() == 1)
-          arg = TE->getElement(0);
-
-      if (auto *LE = dyn_cast<LiteralExpr>(arg)) {
-        diagnoseIgnoredLiteral(Context, LE);
-        return;
-      }
-    }
-
-    // Other unused constructor calls.
+    // Diagnose unused constructor calls.
     if (callee && isa<ConstructorDecl>(callee) && !call->isImplicit()) {
       DE.diagnose(fn->getLoc(), diag::expression_unused_init_result,
                callee->getDeclContext()->getDeclaredInterfaceType())