[AST][SILGen] model ABI-safe casts of LValues

We needed a way to describe an ABI-safe cast of an address
representing an LValue to implement `@preconcurrency` and
its injection of casts during accesses of members.

This new AST node, `ABISafeConversionExpr` models what is
essentially an `unchecked_addr_cast` in SIL when accessing
the LVAlue.

As of now I simply implemented it and the verification of
the node for the concurrency needs to ensure that it's not
misused by accident. If it finds use outside of that,
feel free to update the verifier.

Author: kavon

include/swift/AST/Expr.h

@@ -3157,6 +3157,19 @@ class LoadExpr : public ImplicitConversionExpr {
   static bool classof(const Expr *E) { return E->getKind() == ExprKind::Load; }
 };
 
+/// ABISafeConversion - models a type conversion on an l-value that has no
+/// material affect on the ABI of the type, while *preserving* the l-valueness
+/// of the type.
+class ABISafeConversionExpr : public ImplicitConversionExpr {
+public:
+  ABISafeConversionExpr(Expr *subExpr, Type type)
+    : ImplicitConversionExpr(ExprKind::ABISafeConversion, subExpr, type) {}
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ABISafeConversion;
+  }
+};
+
 /// This is a conversion from an expression of UnresolvedType to an arbitrary
 /// other type, and from an arbitrary type to UnresolvedType.  This node does
 /// not appear in valid code, only in code involving diagnostics.

include/swift/AST/ExprNodes.def

@@ -152,6 +152,7 @@ ABSTRACT_EXPR(Apply, Expr)
   EXPR_RANGE(Apply, Call, ConstructorRefCall)
 ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(Load, ImplicitConversionExpr)
+  EXPR(ABISafeConversion, ImplicitConversionExpr)
   EXPR(DestructureTuple, ImplicitConversionExpr)
   EXPR(UnresolvedTypeConversion, ImplicitConversionExpr)
   EXPR(FunctionConversion, ImplicitConversionExpr)

lib/AST/ASTDumper.cpp

@@ -2276,6 +2276,11 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+  void visitABISafeConversionExpr(ABISafeConversionExpr *E) {
+    printCommon(E, "abi_safe_conversion_expr") << '\n';
+    printRec(E->getSubExpr());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
   void visitMetatypeConversionExpr(MetatypeConversionExpr *E) {
     printCommon(E, "metatype_conversion_expr") << '\n';
     printRec(E->getSubExpr());

lib/AST/ASTPrinter.cpp

@@ -4793,6 +4793,9 @@ void PrintAST::visitConstructorRefCallExpr(ConstructorRefCallExpr *expr) {
   }
 }
 
+void PrintAST::visitABISafeConversionExpr(ABISafeConversionExpr *expr) {
+}
+
 void PrintAST::visitFunctionConversionExpr(FunctionConversionExpr *expr) {
 }
 

lib/AST/ASTVerifier.cpp

@@ -240,6 +240,17 @@ class Verifier : public ASTWalker {
     pushScope(DC);
   }
 
+  /// Emit an error message and abort, optionally dumping the expression.
+  /// \param E if non-null, the expression to dump() followed by a new-line.
+  void error(llvm::StringRef msg, Expr *E = nullptr) {
+    Out << msg << "\n";
+    if (E) {
+      E->dump(Out);
+      Out << "\n";
+    }
+    abort();
+  }
+
 public:
   Verifier(ModuleDecl *M, DeclContext *DC)
       : Verifier(PointerUnion<ModuleDecl *, SourceFile *>(M), DC) {}
@@ -2306,6 +2317,34 @@ class Verifier : public ASTWalker {
       verifyCheckedBase(E);
     }
 
+    void verifyChecked(ABISafeConversionExpr *E) {
+      PrettyStackTraceExpr debugStack(Ctx, "verify ABISafeConversionExpr", E);
+
+      auto toType = E->getType();
+      auto fromType = E->getSubExpr()->getType();
+
+      if (!fromType->hasLValueType())
+        error("conversion source must be an l-value", E);
+
+      if (!toType->hasLValueType())
+        error("conversion result must be an l-value", E);
+
+      {
+        // At the moment, "ABI Safe" means concurrency features can be stripped.
+        // Since we don't know how deeply the stripping is happening, to verify
+        // in a fuzzy way, strip everything to see if they're the same type.
+        auto strippedFrom = fromType->getRValueType()
+                                    ->stripConcurrency(/*recurse*/true,
+                                                       /*dropGlobalActor*/true);
+        auto strippedTo = toType->getRValueType()
+                                ->stripConcurrency(/*recurse*/true,
+                                                   /*dropGlobalActor*/true);
+
+        if (!strippedFrom->isEqual(strippedTo))
+          error("possibly non-ABI safe conversion", E);
+      }
+    }
+
     void verifyChecked(ValueDecl *VD) {
       if (VD->getInterfaceType()->hasError()) {
         Out << "checked decl cannot have error type\n";

lib/AST/Expr.cpp

@@ -414,6 +414,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(Load, getSubExpr);
   NO_REFERENCE(DestructureTuple);
   NO_REFERENCE(UnresolvedTypeConversion);
+  PASS_THROUGH_REFERENCE(ABISafeConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(FunctionConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(CovariantFunctionConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(CovariantReturnConversion, getSubExpr);
@@ -741,6 +742,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
     return false;
 
   case ExprKind::Load:
+  case ExprKind::ABISafeConversion:
   case ExprKind::DestructureTuple:
   case ExprKind::UnresolvedTypeConversion:
   case ExprKind::FunctionConversion:
@@ -914,6 +916,7 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::Load:
   case ExprKind::DestructureTuple:
   case ExprKind::UnresolvedTypeConversion:
+  case ExprKind::ABISafeConversion:
   case ExprKind::FunctionConversion:
   case ExprKind::CovariantFunctionConversion:
   case ExprKind::CovariantReturnConversion:

lib/SILGen/LValue.h

@@ -105,6 +105,7 @@ class PathComponent {
     CoroutineAccessorKind,      // coroutine accessor
     ValueKind,                  // random base pointer as an lvalue
     PhysicalKeyPathApplicationKind, // applying a key path
+    ABISafeConversionKind,        // unchecked_addr_cast
 
     // Logical LValue kinds
     GetterSetterKind,           // property or subscript getter/setter

lib/SILGen/SILGenExpr.cpp

@@ -451,6 +451,9 @@ namespace {
     RValue visitArchetypeToSuperExpr(ArchetypeToSuperExpr *E, SGFContext C);
     RValue visitUnresolvedTypeConversionExpr(UnresolvedTypeConversionExpr *E,
                                              SGFContext C);
+    RValue visitABISafeConversionExpr(ABISafeConversionExpr *E, SGFContext C) {
+      llvm_unreachable("cannot appear in rvalue");
+    }
     RValue visitFunctionConversionExpr(FunctionConversionExpr *E,
                                        SGFContext C);
     RValue visitCovariantFunctionConversionExpr(

lib/SILGen/SILGenLValue.cpp

@@ -327,6 +327,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenLValue
                                      LValueOptions options);
   LValue visitMoveExpr(MoveExpr *e, SGFAccessKind accessKind,
                        LValueOptions options);
+  LValue visitABISafeConversionExpr(ABISafeConversionExpr *e,
+                                    SGFAccessKind accessKind,
+                                    LValueOptions options);
 
   // Expressions that wrap lvalues
 
@@ -2204,6 +2207,29 @@ namespace {
       OS.indent(indent) << "PhysicalKeyPathApplicationComponent\n";
     }
   };
+
+  /// A physical component which performs an unchecked_addr_cast
+  class ABISafeConversionComponent final : public PhysicalPathComponent {
+  public:
+    ABISafeConversionComponent(LValueTypeData typeData)
+      : PhysicalPathComponent(typeData, ABISafeConversionKind,
+                              /*actorIsolation=*/None) {}
+
+    ManagedValue project(SILGenFunction &SGF, SILLocation loc,
+                         ManagedValue base) && override {
+      auto toType = SGF.getLoweredType(getTypeData().SubstFormalType)
+                       .getAddressType();
+
+      if (base.getType() == toType)
+        return base; // nothing to do
+
+      return SGF.B.createUncheckedAddrCast(loc, base, toType);
+    }
+
+    void dump(raw_ostream &OS, unsigned indent) const override {
+      OS.indent(indent) << "ABISafeConversionComponent\n";
+    }
+  };
 } // end anonymous namespace
 
 RValue
@@ -3734,6 +3760,17 @@ LValue SILGenLValue::visitMoveExpr(MoveExpr *e, SGFAccessKind accessKind,
                           toAddr->getType().getASTType());
 }
 
+LValue SILGenLValue::visitABISafeConversionExpr(ABISafeConversionExpr *e,
+                                    SGFAccessKind accessKind,
+                                    LValueOptions options) {
+  LValue lval = visitRec(e->getSubExpr(), accessKind, options);
+  auto typeData = getValueTypeData(SGF, accessKind, e);
+
+  lval.add<ABISafeConversionComponent>(typeData);
+
+  return lval;
+}
+
 /// Emit an lvalue that refers to the given property.  This is
 /// designed to work with ManagedValue 'base's that are either +0 or +1.
 LValue SILGenFunction::emitPropertyLValue(SILLocation loc, ManagedValue base,

lib/Sema/CSApply.cpp

@@ -919,13 +919,22 @@ namespace {
 
       auto &context = cs.getASTContext();
 
-      // turn LValues into RValues first
+      // For an RValue function type, use a standard function conversion.
+      if (openedType->is<AnyFunctionType>()) {
+        expr = new (context) FunctionConversionExpr(
+            expr, getNewType(adjustedOpenedType));
+        cs.cacheType(expr);
+        return expr;
+      }
+
+      // For any kind of LValue, use an ABISafeConversion.
       if (openedType->hasLValueType()) {
-        assert(adjustedOpenedType->hasLValueType() && "lvalue-ness mismatch?");
-        return adjustTypeForDeclReference(cs.coerceToRValue(expr),
-                  openedType->getRValueType(),
-                  adjustedOpenedType->getRValueType(),
-                  getNewType);
+        assert(adjustedOpenedType->hasLValueType() && "lvalueness mismatch?");
+
+        expr = new (context) ABISafeConversionExpr(
+                                expr, getNewType(adjustedOpenedType));
+        cs.cacheType(expr);
+        return expr;
       }
 
       // If we have an optional type, wrap it up in a monadic '?' and recurse.
@@ -944,14 +953,6 @@ namespace {
         return expr;
       }
 
-      // For a function type, perform a function conversion.
-      if (openedType->is<AnyFunctionType>()) {
-        expr = new (context) FunctionConversionExpr(
-            expr, getNewType(adjustedOpenedType));
-        cs.cacheType(expr);
-        return expr;
-      }
-
       assert(false && "Unhandled adjustment");
       return expr;
     }