Merge pull request swiftlang#22611 from pschuh/s-4

IntegerLiteralExpr now is lowered directly into SIL.

Author: slavapestov

include/swift/AST/Expr.h

@@ -157,8 +157,9 @@ class alignas(8) Expr {
     HasTrailingClosure : 1
   );
 
-  SWIFT_INLINE_BITFIELD(NumberLiteralExpr, LiteralExpr, 1,
-    IsNegative : 1
+  SWIFT_INLINE_BITFIELD(NumberLiteralExpr, LiteralExpr, 1+1,
+    IsNegative : 1,
+    IsExplicitConversion : 1
   );
 
   SWIFT_INLINE_BITFIELD(StringLiteralExpr, LiteralExpr, 3+1+1,
@@ -744,7 +745,9 @@ class NumberLiteralExpr : public LiteralExpr {
   /// The value of the literal as an ASTContext-owned string. Underscores must
   /// be stripped.
   StringRef Val;  // Use StringRef instead of APInt or APFloat, which leak.
-  
+  ConcreteDeclRef BuiltinInitializer;
+  ConcreteDeclRef Initializer;
+
 protected:
   SourceLoc MinusLoc;
   SourceLoc DigitsLoc;
@@ -755,6 +758,7 @@ class NumberLiteralExpr : public LiteralExpr {
        : LiteralExpr(Kind, Implicit), Val(Val), DigitsLoc(DigitsLoc)
    {
      Bits.NumberLiteralExpr.IsNegative = false;
+     Bits.NumberLiteralExpr.IsExplicitConversion = false;
    }
 
   bool isNegative() const { return Bits.NumberLiteralExpr.IsNegative; }
@@ -763,6 +767,13 @@ class NumberLiteralExpr : public LiteralExpr {
     Bits.NumberLiteralExpr.IsNegative = true;
   }
 
+  bool isExplicitConversion() const {
+    return Bits.NumberLiteralExpr.IsExplicitConversion;
+  }
+  void setExplicitConversion(bool isExplicitConversion = true) {
+    Bits.NumberLiteralExpr.IsExplicitConversion = isExplicitConversion;
+  }
+
   StringRef getDigitsText() const { return Val; }
 
   SourceRange getSourceRange() const {
@@ -780,6 +791,32 @@ class NumberLiteralExpr : public LiteralExpr {
     return DigitsLoc;
   }
 
+  /// Retrieve the builtin initializer that will be used to construct the
+  /// boolean literal.
+  ///
+  /// Any type-checked boolean literal will have a builtin initializer, which is
+  /// called first to form a concrete Swift type.
+  ConcreteDeclRef getBuiltinInitializer() const { return BuiltinInitializer; }
+
+  /// Set the builtin initializer that will be used to construct the boolean
+  /// literal.
+  void setBuiltinInitializer(ConcreteDeclRef builtinInitializer) {
+    BuiltinInitializer = builtinInitializer;
+  }
+
+  /// Retrieve the initializer that will be used to construct the boolean
+  /// literal from the result of the initializer.
+  ///
+  /// Only boolean literals that have no builtin literal conformance will have
+  /// this initializer, which will be called on the result of the builtin
+  /// initializer.
+  ConcreteDeclRef getInitializer() const { return Initializer; }
+
+  /// Set the initializer that will be used to construct the boolean literal.
+  void setInitializer(ConcreteDeclRef initializer) {
+    Initializer = initializer;
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() >= ExprKind::First_NumberLiteralExpr
       && E->getKind() <= ExprKind::Last_NumberLiteralExpr;
@@ -1125,37 +1162,32 @@ class MagicIdentifierLiteralExpr : public LiteralExpr {
       = static_cast<unsigned>(encoding);
   }
 
-  /// Retrieve the builtin initializer that will be used to construct the string
+  /// Retrieve the builtin initializer that will be used to construct the
   /// literal.
   ///
-  /// Any type-checked string literal will have a builtin initializer, which is
+  /// Any type-checked literal will have a builtin initializer, which is
   /// called first to form a concrete Swift type.
   ConcreteDeclRef getBuiltinInitializer() const {
-    assert(isString() && "Magic identifier literal is not a string");
     return BuiltinInitializer;
   }
 
-  /// Set the builtin initializer that will be used to construct the string
-  /// literal.
+  /// Set the builtin initializer that will be used to construct the literal.
   void setBuiltinInitializer(ConcreteDeclRef builtinInitializer) {
-    assert(isString() && "Magic identifier literal is not a string");
     BuiltinInitializer = builtinInitializer;
   }
 
-  /// Retrieve the initializer that will be used to construct the string
-  /// literal from the result of the initializer.
+  /// Retrieve the initializer that will be used to construct the literal from
+  /// the result of the initializer.
   ///
-  /// Only string literals that have no builtin literal conformance will have
+  /// Only literals that have no builtin literal conformance will have
   /// this initializer, which will be called on the result of the builtin
   /// initializer.
   ConcreteDeclRef getInitializer() const {
-    assert(isString() && "Magic identifier literal is not a string");
     return Initializer;
   }
 
-  /// Set the initializer that will be used to construct the string literal.
+  /// Set the initializer that will be used to construct the literal.
   void setInitializer(ConcreteDeclRef initializer) {
-    assert(isString() && "Magic identifier literal is not a string");
     Initializer = initializer;
   }
 

lib/AST/ASTDumper.cpp

@@ -1820,6 +1820,11 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
       PrintWithColorRAII(OS, LiteralValueColor) << E->getDigitsText();
     else
       PrintWithColorRAII(OS, LiteralValueColor) << E->getValue();
+    PrintWithColorRAII(OS, LiteralValueColor) << " builtin_initializer=";
+    E->getBuiltinInitializer().dump(
+        PrintWithColorRAII(OS, LiteralValueColor).getOS());
+    PrintWithColorRAII(OS, LiteralValueColor) << " initializer=";
+    E->getInitializer().dump(PrintWithColorRAII(OS, LiteralValueColor).getOS());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
   void visitFloatLiteralExpr(FloatLiteralExpr *E) {
@@ -1868,12 +1873,12 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
 
     if (E->isString()) {
       OS << " encoding="
-         << getStringLiteralExprEncodingString(E->getStringEncoding())
-         << " builtin_initializer=";
-      E->getBuiltinInitializer().dump(OS);
-      OS << " initializer=";
-      E->getInitializer().dump(OS);
+         << getStringLiteralExprEncodingString(E->getStringEncoding());
     }
+    OS << " builtin_initializer=";
+    E->getBuiltinInitializer().dump(OS);
+    OS << " initializer=";
+    E->getInitializer().dump(OS);
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 

lib/AST/Expr.cpp

@@ -876,6 +876,8 @@ APInt IntegerLiteralExpr::getRawValue() const {
 APInt IntegerLiteralExpr::getValue() const {
   assert(!getType().isNull() && "Semantic analysis has not completed");
   assert(!getType()->hasError() && "Should have a valid type");
+  if (!getType()->is<AnyBuiltinIntegerType>())
+    return getRawValue();
   auto width = getType()->castTo<AnyBuiltinIntegerType>()->getWidth();
   return width.parse(getDigitsText(), /*radix*/ 0, isNegative());
 }

lib/SILGen/SILGenApply.cpp

@@ -5537,6 +5537,16 @@ RValue SILGenFunction::emitLiteral(LiteralExpr *literal, SGFContext C) {
     builtinLiteralArgs = RValue(*this, {boolManaged}, ty);
     builtinInit = booleanLiteral->getBuiltinInitializer();
     init = booleanLiteral->getInitializer();
+  } else if (auto integerLiteral = dyn_cast<IntegerLiteralExpr>(literal)) {
+    ManagedValue integerManaged =
+        ManagedValue::forUnmanaged(B.createIntegerLiteral(
+            integerLiteral,
+            SILType::getBuiltinIntegerLiteralType(getASTContext()),
+            integerLiteral->getRawValue()));
+    CanType ty = integerManaged.getType().getASTType()->getCanonicalType();
+    builtinLiteralArgs = RValue(*this, {integerManaged}, ty);
+    builtinInit = integerLiteral->getBuiltinInitializer();
+    init = integerLiteral->getInitializer();
   } else {
     ASTContext &ctx = getASTContext();
     SourceLoc loc = literal->getStartLoc();
@@ -5566,7 +5576,23 @@ RValue SILGenFunction::emitLiteral(LiteralExpr *literal, SGFContext C) {
     }
 
     case MagicIdentifierLiteralExpr::Line:
-    case MagicIdentifierLiteralExpr::Column:
+    case MagicIdentifierLiteralExpr::Column: {
+      SourceLoc Loc = literal->getStartLoc();
+      unsigned Value = 0;
+      if (Loc.isValid()) {
+        Value = magicLiteral->getKind() == MagicIdentifierLiteralExpr::Line
+                    ? ctx.SourceMgr.getLineAndColumn(Loc).first
+                    : ctx.SourceMgr.getLineAndColumn(Loc).second;
+      }
+
+      auto Ty = SILType::getBuiltinIntegerLiteralType(ctx);
+      SILValue V = B.createIntegerLiteral(literal, Ty, Value);
+      builtinLiteralArgs = RValue(*this, {ManagedValue::forUnmanaged(V)},
+                                  Ty.getASTType()->getCanonicalType());
+      builtinInit = magicLiteral->getBuiltinInitializer();
+      init = magicLiteral->getInitializer();
+      break;
+    }
     case MagicIdentifierLiteralExpr::DSOHandle:
       llvm_unreachable("handled elsewhere");
     }

lib/SILGen/SILGenExpr.cpp

@@ -952,8 +952,10 @@ RValue RValueEmitter::visitNilLiteralExpr(NilLiteralExpr *E, SGFContext C) {
 
 RValue RValueEmitter::visitIntegerLiteralExpr(IntegerLiteralExpr *E,
                                               SGFContext C) {
-  return RValue(SGF, E,
-                ManagedValue::forUnmanaged(SGF.B.createIntegerLiteral(E)));
+  if (E->getType()->is<AnyBuiltinIntegerType>())
+    return RValue(SGF, E,
+                  ManagedValue::forUnmanaged(SGF.B.createIntegerLiteral(E)));
+  return SGF.emitLiteral(E, C);
 }
 RValue RValueEmitter::visitFloatLiteralExpr(FloatLiteralExpr *E,
                                             SGFContext C) {
@@ -3724,31 +3726,12 @@ visitKeyPathApplicationExpr(KeyPathApplicationExpr *E, SGFContext C) {
 
 RValue RValueEmitter::
 visitMagicIdentifierLiteralExpr(MagicIdentifierLiteralExpr *E, SGFContext C) {
-  ASTContext &Ctx = SGF.getASTContext();
-  SILType Ty = SGF.getLoweredLoadableType(E->getType());
-  SourceLoc Loc = E->getStartLoc();
-  
   switch (E->getKind()) {
   case MagicIdentifierLiteralExpr::File:
   case MagicIdentifierLiteralExpr::Function:
+  case MagicIdentifierLiteralExpr::Line:
+  case MagicIdentifierLiteralExpr::Column:
     return SGF.emitLiteral(E, C);
-  case MagicIdentifierLiteralExpr::Line: {
-    unsigned Value = 0;
-    if (Loc.isValid())
-      Value = Ctx.SourceMgr.getLineAndColumn(Loc).first;
-
-    SILValue V = SGF.B.createIntegerLiteral(E, Ty, Value);
-    return RValue(SGF, E, ManagedValue::forUnmanaged(V));
-  }
-  case MagicIdentifierLiteralExpr::Column: {
-    unsigned Value = 0;
-    if (Loc.isValid())
-      Value = Ctx.SourceMgr.getLineAndColumn(Loc).second;
-
-    SILValue V = SGF.B.createIntegerLiteral(E, Ty, Value);
-    return RValue(SGF, E, ManagedValue::forUnmanaged(V));
-  }
-
   case MagicIdentifierLiteralExpr::DSOHandle: {
     auto SILLoc = SILLocation(E);
     auto UnsafeRawPointer = SGF.getASTContext().getUnsafeRawPointerDecl();

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -755,6 +755,8 @@ constantFoldAndCheckIntegerConversions(BuiltinInst *BI,
         UserSrcTy = CE->getArg()->getType();
         UserDstTy = CE->getType();
       }
+    } else if (auto *ILE = Loc.getAsASTNode<IntegerLiteralExpr>()) {
+      UserDstTy = ILE->getType();
     }
 
     // Assume that we're converting from a literal if the source type is
@@ -1057,6 +1059,9 @@ bool isHexLiteralInSource(FloatLiteralInst *flitInst) {
 bool maybeExplicitFPCons(BuiltinInst *BI, const BuiltinInfo &Builtin) {
   assert(Builtin.ID == BuiltinValueKind::FPTrunc ||
          Builtin.ID == BuiltinValueKind::IntToFPWithOverflow);
+  if (auto *literal = BI->getLoc().getAsASTNode<NumberLiteralExpr>()) {
+    return literal->isExplicitConversion();
+  }
 
   auto *callExpr = BI->getLoc().getAsASTNode<CallExpr>();
   if (!callExpr || !dyn_cast<ConstructorRefCallExpr>(callExpr->getFn()))
@@ -1218,7 +1223,9 @@ case BuiltinValueKind::id:
         SrcVal, /*IsSigned=*/true, APFloat::rmNearestTiesToEven);
 
     SILLocation Loc = BI->getLoc();
-    const ApplyExpr *CE = Loc.getAsASTNode<ApplyExpr>();
+    const Expr *CE = Loc.getAsASTNode<ApplyExpr>();
+    if (!CE)
+      CE = Loc.getAsASTNode<LiteralExpr>();
 
     bool overflow = ConversionStatus & APFloat::opOverflow;
     bool inexact = ConversionStatus & APFloat::opInexact;

lib/Sema/CSApply.cpp

@@ -1778,19 +1778,15 @@ namespace {
       DeclName builtinInitName(tc.Context, DeclBaseName::createConstructor(),
                                { tc.Context.Id_builtinIntegerLiteral });
 
-      return convertLiteral(
-               expr,
-               type,
-               cs.getType(expr),
-               protocol,
-               tc.Context.Id_IntegerLiteralType,
-               initName,
-               builtinProtocol,
-               tc.Context.TheIntegerLiteralType,
-               builtinInitName,
-               nullptr,
-               diag::integer_literal_broken_proto,
-               diag::builtin_integer_literal_broken_proto);
+      auto *result = convertLiteralInPlace(
+          expr, type, protocol, tc.Context.Id_IntegerLiteralType, initName,
+          builtinProtocol, builtinInitName, diag::integer_literal_broken_proto,
+          diag::builtin_integer_literal_broken_proto);
+      if (result) {
+        // TODO: It seems that callers expect this to have types assigned...
+        result->setType(cs.getType(result));
+      }
+      return result;
     }
 
     Expr *visitNilLiteralExpr(NilLiteralExpr *expr) {
@@ -3556,7 +3552,11 @@ namespace {
           });
         }
 
-        literalInit->setImplicit(false);
+        if (auto *literal = dyn_cast<NumberLiteralExpr>(literalInit)) {
+          literal->setExplicitConversion();
+        } else {
+          literalInit->setImplicit(false);
+        }
 
         cs.setType(expr, toType);
         // Keep the coercion around, because it contains the source range
@@ -6981,6 +6981,8 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
       stringLiteral->setBuiltinInitializer(witness);
     else if (auto booleanLiteral = dyn_cast<BooleanLiteralExpr>(literal))
       booleanLiteral->setBuiltinInitializer(witness);
+    else if (auto numberLiteral = dyn_cast<NumberLiteralExpr>(literal))
+      numberLiteral->setBuiltinInitializer(witness);
     else {
       cast<MagicIdentifierLiteralExpr>(literal)
         ->setBuiltinInitializer(witness);
@@ -7030,6 +7032,8 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
     stringLiteral->setInitializer(witness);
   else if (auto booleanLiteral = dyn_cast<BooleanLiteralExpr>(literal))
     booleanLiteral->setInitializer(witness);
+  else if (auto numberLiteral = dyn_cast<NumberLiteralExpr>(literal))
+    numberLiteral->setInitializer(witness);
   else
     cast<MagicIdentifierLiteralExpr>(literal)->setInitializer(witness);
 

lib/Sema/CSDiagnostics.cpp

@@ -937,6 +937,12 @@ bool AssignmentFailure::diagnoseAsError() {
     return true;
   }
 
+  if (auto LE = dyn_cast<LiteralExpr>(immInfo.first)) {
+    emitDiagnostic(Loc, DeclDiagnostic, "literals are not mutable")
+        .highlight(LE->getSourceRange());
+    return true;
+  }
+
   // If the expression is the result of a call, it is an rvalue, not a mutable
   // lvalue.
   if (auto *AE = dyn_cast<ApplyExpr>(immInfo.first)) {

test/Frontend/dump-parse.swift

@@ -6,12 +6,11 @@
 func foo(_ n: Int) -> Int {
   // CHECK:   (brace_stmt
   // CHECK:     (return_stmt
-  // CHECK:       (integer_literal_expr type='<null>' value=42)))
+  // CHECK:       (integer_literal_expr type='<null>' value=42 {{.*}})))
   // CHECK-AST: (brace_stmt
   // CHECK-AST:   (return_stmt
-  // CHECK-AST:     (call_expr implicit type='Int'
-  // CHECK-AST:       (integer_literal_expr type='{{[^']+}}' {{.*}} value=42)
-  return 42
+  // CHECK-AST:     (integer_literal_expr type='{{[^']+}}' {{.*}} value=42 {{.*}})
+    return 42
 }
 
 // -dump-parse should print an AST even though this code is invalid.