[WIP] Property delegates

include/swift/AST/ASTTypeIDZone.def

@@ -0,0 +1,19 @@
+//===--- ASTTypeIDZone.def - Define the AST TypeID Zone ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This definition file describes the types in the "AST" TypeID zone,
+//  for use with the TypeID template.
+//
+//===----------------------------------------------------------------------===//
+SWIFT_TYPEID_NAMED(NominalTypeDecl *, NominalTypeDecl)
+SWIFT_TYPEID_NAMED(VarDecl *, VarDecl)
+SWIFT_TYPEID(PropertyDelegateTypeInfo)

include/swift/AST/ASTTypeIDs.h

@@ -0,0 +1,36 @@
+//===--- ASTTypeIDs.h - AST Type Ids ----------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines TypeID support for AST types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_ASTTYPEIDS_H
+#define SWIFT_AST_ASTTYPEIDS_H
+
+#include "swift/Basic/TypeID.h"
+namespace swift {
+
+class NominalTypeDecl;
+struct PropertyDelegateTypeInfo;
+class VarDecl;
+
+#define SWIFT_AST_TYPEID_ZONE 1
+
+// Define the AST type zone (zone 1)
+#define SWIFT_TYPEID_ZONE SWIFT_AST_TYPEID_ZONE
+#define SWIFT_TYPEID_HEADER "swift/AST/ASTTypeIDZone.def"
+#include "swift/Basic/DefineTypeIDZone.h"
+
+} // end namespace swift
+
+#endif /* SWIFT_AST_ASTTYPEIDS_H */

include/swift/AST/Attr.def

@@ -390,6 +390,12 @@ DECL_ATTR(_private, PrivateImport,
 SIMPLE_DECL_ATTR(_alwaysEmitIntoClient, AlwaysEmitIntoClient,
   OnVar | OnSubscript | OnAbstractFunction | UserInaccessible,
   83)
+SIMPLE_DECL_ATTR(propertyDelegate, PropertyDelegate,
+  OnStruct | OnClass | OnEnum,
+  84)
+DECL_ATTR(_custom, Custom,
+  OnAnyDecl | UserInaccessible,
+  85)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS

include/swift/AST/Attr.h

@@ -32,6 +32,7 @@
 #include "swift/AST/Ownership.h"
 #include "swift/AST/PlatformKind.h"
 #include "swift/AST/Requirement.h"
+#include "swift/AST/TrailingCallArguments.h"
 #include "swift/AST/TypeLoc.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -49,6 +50,7 @@ class FuncDecl;
 class ClassDecl;
 class GenericFunctionType;
 class LazyConformanceLoader;
+class PatternBindingInitializer;
 class TrailingWhereClause;
 
 /// TypeAttributes - These are attributes that may be applied to types.
@@ -1408,6 +1410,54 @@ class ClangImporterSynthesizedTypeAttr : public DeclAttribute {
   }
 };
 
+/// Defines a custom attribute.
+class CustomAttr final : public DeclAttribute,
+                         public TrailingCallArguments<CustomAttr> {
+  TypeLoc type;
+  Expr *arg;
+  PatternBindingInitializer *initContext;
+
+  unsigned hasArgLabelLocs : 1;
+  unsigned numArgLabels : 16;
+
+  CustomAttr(SourceLoc atLoc, SourceRange range, TypeLoc type,
+             PatternBindingInitializer *initContext, Expr *arg,
+             ArrayRef<Identifier> argLabels, ArrayRef<SourceLoc> argLabelLocs,
+             bool implicit);
+
+public:
+  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeLoc type,
+                            bool implicit = false) {
+    return create(ctx, atLoc, type, false, nullptr, SourceLoc(), { }, { }, { },
+                  SourceLoc(), implicit);
+  }
+
+  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeLoc type,
+                            bool hasInitializer,
+                            PatternBindingInitializer *initContext,
+                            SourceLoc lParenLoc,
+                            ArrayRef<Expr *> args,
+                            ArrayRef<Identifier> argLabels,
+                            ArrayRef<SourceLoc> argLabelLocs,
+                            SourceLoc rParenLoc,
+                            bool implicit = false);
+
+  unsigned getNumArguments() const { return numArgLabels; }
+  bool hasArgumentLabelLocs() const { return hasArgLabelLocs; }
+
+  TypeLoc &getTypeLoc() { return type; }
+  const TypeLoc &getTypeLoc() const { return type; }
+
+  Expr *getArg() const { return arg; }
+  void setArg(Expr *newArg) { arg = newArg; }
+
+  PatternBindingInitializer *getInitContext() const { return initContext; }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_Custom;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.
@@ -1584,6 +1634,8 @@ class DeclAttributes {
   SourceLoc getStartLoc(bool forModifiers = false) const;
 };
 
+void simple_display(llvm::raw_ostream &out, const DeclAttribute *attr);
+
 } // end namespace swift
 
 #endif

include/swift/AST/Decl.h

@@ -356,7 +356,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     ValidKeyPathComponent : 1
   );
 
-  SWIFT_INLINE_BITFIELD(VarDecl, AbstractStorageDecl, 1+4+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(VarDecl, AbstractStorageDecl, 1+4+1+1+1+1+1+1,
     /// Whether this property is a type property (currently unfortunately
     /// called 'static').
     IsStatic : 1,
@@ -379,7 +379,13 @@ class alignas(1 << DeclAlignInBits) Decl {
 
     /// Whether this is a property defined in the debugger's REPL.
     /// FIXME: Remove this once LLDB has proper support for resilience.
-    IsREPLVar : 1
+    IsREPLVar : 1,
+
+    /// Whether this property has an associated property delegate.
+    HasPropertyDelegate : 1,
+
+    /// Whether this is the backing storage for a property delegate.
+    IsPropertyDelegateBackingProperty : 1
   );
 
   SWIFT_INLINE_BITFIELD(ParamDecl, VarDecl, 1 + NumDefaultArgumentKindBits,
@@ -1887,15 +1893,21 @@ class PatternBindingEntry {
   enum class Flags {
     Checked = 1 << 0,
     Removed = 1 << 1,
-    Lazy    = 1 << 2
+    /// Whether the contents of this initializer were subsumed by
+    /// some other initialization, e.g., a lazy property's initializer
+    /// gets subsumed by the getter body.
+    Subsumed    = 1 << 2
   };
   llvm::PointerIntPair<Pattern *, 3, OptionSet<Flags>> PatternAndFlags;
 
   struct ExprAndEqualLoc {
     // When the initializer is removed we don't actually clear the pointer
     // because we might need to get initializer's source range. Since the
     // initializer is ASTContext-allocated it is safe.
-    Expr *Node;
+    //
+    // The bit indicates whether the initializer is for an attached property
+    // delegate.
+    llvm::PointerIntPair<Expr *, 1, bool> NodeAndPropertyDelegateInit;
     /// The location of the equal '=' token.
     SourceLoc EqualLoc;
   };
@@ -1915,8 +1927,10 @@ class PatternBindingEntry {
 
 public:
   PatternBindingEntry(Pattern *P, SourceLoc EqualLoc, Expr *E,
+                      bool InitIsPropertyDelegateInit,
                       DeclContext *InitContext)
-    : PatternAndFlags(P, {}), InitExpr({E, EqualLoc}),
+    : PatternAndFlags(P, {}),
+      InitExpr({{E, InitIsPropertyDelegateInit}, EqualLoc}),
       InitContextAndIsText({InitContext, false}) {
   }
 
@@ -1926,13 +1940,21 @@ class PatternBindingEntry {
     if (PatternAndFlags.getInt().contains(Flags::Removed) ||
         InitContextAndIsText.getInt())
       return nullptr;
-    return InitExpr.Node;
+    return InitExpr.NodeAndPropertyDelegateInit.getPointer();
+  }
+  bool isPropertyDelegateInit() const {
+    return InitExpr.NodeAndPropertyDelegateInit.getInt();
   }
-  Expr *getNonLazyInit() const {
-    return isInitializerLazy() ? nullptr : getInit();
+  /// Retrieve the initializer if it should be executed to initialize this
+  /// particular pattern binding.
+  Expr *getExecutableInit() const {
+    return isInitializerSubsumed() ? nullptr : getInit();
   }
   SourceRange getOrigInitRange() const;
   void setInit(Expr *E);
+  void setIsPropertyDelegateInit(bool isPropertyDelegateInit) {
+    InitExpr.NodeAndPropertyDelegateInit.setInt(isPropertyDelegateInit);
+  }
 
   /// Gets the text of the initializer expression, stripping out inactive
   /// branches of any #ifs inside the expression.
@@ -1963,7 +1985,9 @@ class PatternBindingEntry {
 
   /// Retrieve the initializer as it was written in the source.
   Expr *getInitAsWritten() const {
-    return InitContextAndIsText.getInt() ? nullptr : InitExpr.Node;
+    return InitContextAndIsText.getInt()
+        ? nullptr
+        : InitExpr.NodeAndPropertyDelegateInit.getPointer();
   }
 
   bool isInitializerChecked() const {
@@ -1973,11 +1997,11 @@ class PatternBindingEntry {
     PatternAndFlags.setInt(PatternAndFlags.getInt() | Flags::Checked);
   }
 
-  bool isInitializerLazy() const {
-    return PatternAndFlags.getInt().contains(Flags::Lazy);
+  bool isInitializerSubsumed() const {
+    return PatternAndFlags.getInt().contains(Flags::Subsumed);
   }
-  void setInitializerLazy() {
-    PatternAndFlags.setInt(PatternAndFlags.getInt() | Flags::Lazy);
+  void setInitializerSubsumed() {
+    PatternAndFlags.setInt(PatternAndFlags.getInt() | Flags::Subsumed);
   }
 
   // Return the first variable initialized by this pattern.
@@ -2036,6 +2060,7 @@ class PatternBindingDecl final : public Decl,
                                     StaticSpellingKind StaticSpelling,
                                     SourceLoc VarLoc, Pattern *Pat,
                                     SourceLoc EqualLoc, Expr *E,
+                                    bool IsPropertyDelegateInit,
                                     DeclContext *Parent);
 
   static PatternBindingDecl *createImplicit(ASTContext &Ctx,
@@ -2072,10 +2097,13 @@ class PatternBindingDecl final : public Decl,
   Expr *getInit(unsigned i) const {
     return getPatternList()[i].getInit();
   }
-  Expr *getNonLazyInit(unsigned i) const {
-    return getPatternList()[i].getNonLazyInit();
+  Expr *getExecutableInit(unsigned i) const {
+    return getPatternList()[i].getExecutableInit();
   }
-
+  bool isPropertyDelegateInit(unsigned i) const {
+    return getPatternList()[i].isPropertyDelegateInit();
+  }
+
   SourceRange getOrigInitRange(unsigned i) const {
     return getPatternList()[i].getOrigInitRange();
   }
@@ -2114,12 +2142,12 @@ class PatternBindingDecl final : public Decl,
     getMutablePatternList()[i].setInitializerChecked();
   }
 
-  bool isInitializerLazy(unsigned i) const {
-    return getPatternList()[i].isInitializerLazy();
+  bool isInitializerSubsumed(unsigned i) const {
+    return getPatternList()[i].isInitializerSubsumed();
   }
 
-  void setInitializerLazy(unsigned i) {
-    getMutablePatternList()[i].setInitializerLazy();
+  void setInitializerSubsumed(unsigned i) {
+    getMutablePatternList()[i].setInitializerSubsumed();
   }
 
   /// Does this binding declare something that requires storage?
@@ -4600,6 +4628,8 @@ class VarDecl : public AbstractStorageDecl {
     Bits.VarDecl.IsCaptureList = IsCaptureList;
     Bits.VarDecl.IsDebuggerVar = false;
     Bits.VarDecl.IsREPLVar = false;
+    Bits.VarDecl.HasPropertyDelegate = false;
+    Bits.VarDecl.IsPropertyDelegateBackingProperty = false;
     Bits.VarDecl.HasNonPatternBindingInit = false;
   }
 
@@ -4872,6 +4902,47 @@ class VarDecl : public AbstractStorageDecl {
     Bits.VarDecl.IsREPLVar = IsREPLVar;
   }
 
+  /// Whether this variable has a property delegate attached.
+  bool hasPropertyDelegate() const;
+
+  /// For a property delegate, retrieve the source location for the
+  /// 'by' keyword.
+  SourceLoc getPropertyDelegateByLoc() const;
+
+  /// For a property delegate, retrieve the behavior type location
+  /// information.
+  TypeLoc &getPropertyDelegateTypeLoc();
+
+  /// For a property delegate, retrieve the behavior type location
+  /// information.
+  const TypeLoc &getPropertyDelegateTypeLoc() const;
+
+  /// Retrieve the formal access level for the attached property delegate.
+  AccessLevel getPropertyDelegateFormalAccess() const;
+
+  /// Retrieve the source location for access specifier of the property.
+  SourceLoc getPropertyDelegateAccessLoc() const;
+
+  /// Add a property delegate to this variable.
+  void addPropertyDelegate(SourceLoc byLoc,
+                           AccessLevel access,
+                           SourceLoc accessLoc,
+                           TypeLoc typeLoc);
+
+  /// Retrieve the backing variable for the property delegate.
+  VarDecl *getPropertyDelegateBackingVar() const;
+
+  /// Set the backing variable for the property delegate.
+  void setPropertyDelegateBackingVar(VarDecl *backingVar);
+
+  /// Retrieve the property that delegates to this backing property,
+  /// or \c nullptr if this is not a backing property.
+  VarDecl *getOriginalDelegatedProperty() const;
+
+  /// Set the property that delegates to this property as it's backing
+  /// property.
+  void setOriginalDelegatedProperty(VarDecl *originalProperty);
+
   /// Return the Objective-C runtime name for this property.
   Identifier getObjCPropertyName() const;
 

include/swift/AST/DiagnosticsParse.def

@@ -1099,14 +1099,14 @@ ERROR(invalid_postfix_operator,none,
 
 ERROR(expected_member_name,PointsToFirstBadToken,
       "expected member name following '.'", ())
-ERROR(expected_dollar_numeric,none,
-      "expected numeric value following '$'", ())
 ERROR(dollar_numeric_too_large,none,
       "numeric value following '$' is too large", ())
 ERROR(numeric_literal_numeric_member,none,
       "expected named member of numeric literal", ())
 ERROR(standalone_dollar_identifier,none,
      "'$' is not an identifier; use backticks to escape it", ())
+ERROR(dollar_identifier_decl,none,
+     "cannot declare entity %0 with a '$' prefix", (Identifier))
 
 ERROR(anon_closure_arg_not_in_closure,none,
       "anonymous closure argument not contained in a closure", ())
@@ -1620,6 +1620,16 @@ ERROR(pound_available_package_description_not_allowed, none,
 ERROR(availability_query_repeated_platform, none,
       "version for '%0' already specified", (StringRef))
 
+//------------------------------------------------------------------------------
+// MARK: property delegate diagnostics
+//------------------------------------------------------------------------------
+ERROR(property_delegate_not_named, none,
+      "property delegate can only by written on a single-variable pattern", ())
+ERROR(expected_property_delegate_type_after_by,PointsToFirstBadToken,
+      "expected property delegate type after 'by'", ())
+ERROR(property_delegate_local,none,
+      "property delegates are not yet supported on local properties", ())
+
 //------------------------------------------------------------------------------
 // MARK: syntax parsing diagnostics
 //------------------------------------------------------------------------------