[Sema] Add an implicit applied property wrapper expression and a new

dedicated initializer context for this expressions.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -4109,11 +4109,11 @@ ERROR(throw_in_nonexhaustive_catch,none,
 
 ERROR(throwing_call_in_illegal_context,none,
       "call can throw, but errors cannot be thrown out of "
-      "%select{<<ERROR>>|a default argument|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
+      "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 ERROR(throw_in_illegal_context,none,
       "errors cannot be thrown out of "
-      "%select{<<ERROR>>|a default argument|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
+      "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 
 ERROR(throwing_operator_without_try,none,
@@ -4151,11 +4151,11 @@ WARNING(no_async_in_await,none,
         "no calls to 'async' functions occur within 'await' expression", ())
 ERROR(async_call_in_illegal_context,none,
       "'async' call cannot occur in "
-      "%select{<<ERROR>>|a default argument|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
+      "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 ERROR(await_in_illegal_context,none,
       "'await' operation cannot occur in "
-      "%select{<<ERROR>>|a default argument|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
+      "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 ERROR(async_in_nonasync_function,none,
       "%select{'async'|'await'|'async let'}0 in "
@@ -4197,7 +4197,7 @@ ERROR(async_let_without_await,none,
       "reference to async let %0 is not marked with 'await'", (DeclName))
 ERROR(async_let_in_illegal_context,none,
       "async let %0 cannot be referenced in "
-      "%select{<<ERROR>>|a default argument|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}1",
+      "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}1",
       (DeclName, unsigned))
 
 ERROR(asynchandler_non_func,none,

include/swift/AST/Expr.h

@@ -4228,6 +4228,57 @@ class PropertyWrapperValuePlaceholderExpr : public Expr {
   }
 };
 
+/// An implicit applied property wrapper expression.
+class AppliedPropertyWrapperExpr final : public Expr {
+public:
+  enum class ValueKind {
+    WrappedValue,
+    ProjectedValue
+  };
+
+private:
+  /// The owning declaration.
+  const ParamDecl *Param;
+
+  /// The source location of the argument list.
+  SourceLoc Loc;
+
+  /// The value to which the property wrapper is applied for initialization.
+  Expr *Value;
+
+  /// The kind of value that the property wrapper is applied to.
+  ValueKind Kind;
+
+  AppliedPropertyWrapperExpr(const ParamDecl *param, SourceLoc loc,
+                             Type Ty, Expr *value, ValueKind kind)
+      : Expr(ExprKind::AppliedPropertyWrapper, /*Implicit=*/true, Ty),
+        Param(param), Loc(loc), Value(value), Kind(kind) {}
+
+public:
+  static AppliedPropertyWrapperExpr *
+  create(ASTContext &ctx, const ParamDecl *param, SourceLoc loc,
+         Type Ty, Expr *value, ValueKind kind);
+
+  SourceRange getSourceRange() const { return Loc; }
+
+  /// Returns the parameter declaration with the attached property wrapper.
+  const ParamDecl *getParamDecl() const { return Param; };
+
+  /// Returns the value that the property wrapper is applied to.
+  Expr *getValue() { return Value; }
+
+  /// Sets the value that the property wrapper is applied to.
+  void setValue(Expr *value) { Value = value; }
+
+  /// Returns the kind of value, between wrapped value and projected
+  /// value, the property wrapper is applied to.
+  ValueKind getValueKind() const { return Kind; }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::AppliedPropertyWrapper;
+  }
+};
+
 /// An expression referring to a default argument left unspecified at the
 /// call site.
 ///

include/swift/AST/ExprNodes.def

@@ -131,6 +131,7 @@ EXPR(DynamicType, Expr)
 EXPR(RebindSelfInConstructor, Expr)
 EXPR(OpaqueValue, Expr)
 EXPR(PropertyWrapperValuePlaceholder, Expr)
+EXPR(AppliedPropertyWrapper, Expr)
 EXPR(DefaultArgument, Expr)
 EXPR(BindOptional, Expr)
 EXPR(OptionalEvaluation, Expr)

include/swift/AST/Initializer.h

@@ -33,6 +33,9 @@ enum class InitializerKind : uint8_t {
 
   /// A function's default argument expression.
   DefaultArgument,
+
+  /// A property wrapper initialization expression.
+  PropertyWrapper,
 };
 
 /// An Initializer is a kind of DeclContext used for expressions that
@@ -41,9 +44,9 @@ enum class InitializerKind : uint8_t {
 /// Generally, Initializers are created lazily, as most initializers
 /// don't really require DeclContexts.
 class Initializer : public DeclContext {
-  unsigned Kind : 1;
+  unsigned Kind : 2;
 protected:
-  unsigned SpareBits : 31;
+  unsigned SpareBits : 30;
 
   Initializer(InitializerKind kind, DeclContext *parent)
     : DeclContext(DeclContextKind::Initializer, parent),
@@ -195,6 +198,39 @@ class SerializedDefaultArgumentInitializer : public SerializedLocalDeclContext {
     return false;
   }
 };
+
+/// A property wrapper initialization expression.  The parent context is the
+/// function or closure which owns the property wrapper.
+class PropertyWrapperInitializer : public Initializer {
+public:
+  enum class Kind {
+    WrappedValue,
+    ProjectedValue
+  };
+
+private:
+  ParamDecl *param;
+  Kind kind;
+
+public:
+  explicit PropertyWrapperInitializer(DeclContext *parent, ParamDecl *param, Kind kind)
+      : Initializer(InitializerKind::PropertyWrapper, parent),
+        param(param), kind(kind) {}
+
+  ParamDecl *getParam() const { return param; }
+
+  Kind getKind() const { return kind; }
+
+  static bool classof(const DeclContext *DC) {
+    if (auto init = dyn_cast<Initializer>(DC))
+      return classof(init);
+    return false;
+  }
+
+  static bool classof(const Initializer *I) {
+    return I->getInitializerKind() == InitializerKind::PropertyWrapper;
+  }
+};
 
 } // end namespace swift
 

lib/AST/ASTDumper.cpp

@@ -1385,6 +1385,9 @@ void swift::printContext(raw_ostream &os, DeclContext *dc) {
     case InitializerKind::DefaultArgument:
       os << "default argument initializer";
       break;
+    case InitializerKind::PropertyWrapper:
+      os << "property wrapper initializer";
+      break;
     }
     break;
 
@@ -2585,6 +2588,12 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitAppliedPropertyWrapperExpr(AppliedPropertyWrapperExpr *E) {
+    printCommon(E, "applied_property_wrapper_expr");
+    printRec(E->getValue());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitDefaultArgumentExpr(DefaultArgumentExpr *E) {
     printCommon(E, "default_argument_expr");
     OS << " default_args_owner=";

lib/AST/ASTMangler.cpp

@@ -2116,6 +2116,19 @@ void ASTMangler::appendContext(const DeclContext *ctx, StringRef useModuleName)
       }
       return;
     }
+
+    case InitializerKind::PropertyWrapper: {
+      auto wrapperInit = cast<PropertyWrapperInitializer>(ctx);
+      switch (wrapperInit->getKind()) {
+      case PropertyWrapperInitializer::Kind::WrappedValue:
+        appendBackingInitializerEntity(wrapperInit->getParam());
+        break;
+      case PropertyWrapperInitializer::Kind::ProjectedValue:
+        appendInitFromProjectedValueEntity(wrapperInit->getParam());
+        break;
+      }
+      return;
+    }
     }
     llvm_unreachable("bad initializer kind");
 

lib/AST/ASTWalker.cpp

@@ -514,6 +514,16 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return E;
   }
 
+  Expr *visitAppliedPropertyWrapperExpr(AppliedPropertyWrapperExpr *E) {
+    if (auto *newValue = doIt(E->getValue())) {
+      E->setValue(newValue);
+    } else {
+      return nullptr;
+    }
+
+    return E;
+  }
+
   Expr *visitDefaultArgumentExpr(DefaultArgumentExpr *E) { return E; }
 
   Expr *visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E) {

lib/AST/DeclContext.cpp

@@ -677,6 +677,19 @@ unsigned DeclContext::printContext(raw_ostream &OS, const unsigned indent,
       OS << " DefaultArgument index=" << init->getIndex();
       break;
     }
+    case InitializerKind::PropertyWrapper: {
+      auto init = cast<PropertyWrapperInitializer>(this);
+      OS << "PropertyWrapper 0x" << (void*)init->getParam() << ", kind=";
+      switch (init->getKind()) {
+      case PropertyWrapperInitializer::Kind::WrappedValue:
+        OS << "wrappedValue";
+        break;
+      case PropertyWrapperInitializer::Kind::ProjectedValue:
+          OS << "projectedValue";
+        break;
+      }
+      break;
+    }
     }
     break;
 

lib/AST/Expr.cpp

@@ -320,6 +320,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
 
   NO_REFERENCE(OpaqueValue);
   NO_REFERENCE(PropertyWrapperValuePlaceholder);
+  NO_REFERENCE(AppliedPropertyWrapper);
   NO_REFERENCE(DefaultArgument);
 
   PASS_THROUGH_REFERENCE(BindOptional, getSubExpr);
@@ -633,6 +634,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::RebindSelfInConstructor:
   case ExprKind::OpaqueValue:
   case ExprKind::PropertyWrapperValuePlaceholder:
+  case ExprKind::AppliedPropertyWrapper:
   case ExprKind::DefaultArgument:
   case ExprKind::BindOptional:
   case ExprKind::OptionalEvaluation:
@@ -1507,6 +1509,13 @@ PropertyWrapperValuePlaceholderExpr::create(ASTContext &ctx, SourceRange range,
       range, ty, placeholder, wrappedValue, isAutoClosure);
 }
 
+AppliedPropertyWrapperExpr *
+AppliedPropertyWrapperExpr::create(ASTContext &ctx, const ParamDecl *param,
+                                   SourceLoc loc, Type Ty, Expr *value,
+                                   AppliedPropertyWrapperExpr::ValueKind kind) {
+  return new (ctx) AppliedPropertyWrapperExpr(param, loc, Ty, value, kind);
+}
+
 const ParamDecl *DefaultArgumentExpr::getParamDecl() const {
   return getParameterAt(DefaultArgsOwner.getDecl(), ParamIndex);
 }

lib/IDE/ExprContextAnalysis.cpp

@@ -1097,6 +1097,15 @@ class ExprContextAnalyzer {
       recordPossibleType(AFD->mapTypeIntoContext(param->getInterfaceType()));
       break;
     }
+    case InitializerKind::PropertyWrapper: {
+      auto initDC = cast<PropertyWrapperInitializer>(DC);
+      auto AFD = dyn_cast<AbstractFunctionDecl>(initDC->getParent());
+      if (!AFD)
+        return;
+      auto *param = initDC->getParam();
+      recordPossibleType(AFD->mapTypeIntoContext(param->getInterfaceType()));
+      break;
+    }
     }
   }