Synthesize accessors for dynamic global variables

include/swift/AST/Decl.h

@@ -570,7 +570,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1,
     /// If the module was or is being compiled with `-enable-testing`.
     TestingEnabled : 1,
 
@@ -586,7 +586,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasResolvedImports : 1,
 
     // If the module was or is being compiled with `-enable-private-imports`.
-    PrivateImportsEnabled : 1
+    PrivateImportsEnabled : 1,
+
+    // If the module is compiled with `-enable-implicit-dynamic`.
+    ImplicitDynamicEnabled : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,
@@ -2594,6 +2597,10 @@ class ValueDecl : public Decl {
     return isObjC() && isDynamic();
   }
 
+  bool isNativeDynamic() const {
+    return !isObjC() && isDynamic();
+  }
+
   /// Set whether this type is 'dynamic' or not.
   void setIsDynamic(bool value);
 

include/swift/AST/Module.h

@@ -283,6 +283,14 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     Bits.ModuleDecl.TestingEnabled = enabled;
   }
 
+  // Returns true if this module is compiled with implicit dynamic.
+  bool isImplicitDynamicEnabled() const {
+    return Bits.ModuleDecl.ImplicitDynamicEnabled;
+  }
+  void setImplicitDynamicEnabled(bool enabled = true) {
+    Bits.ModuleDecl.ImplicitDynamicEnabled = enabled;
+  }
+
   /// Returns true if this module was or is begin compile with
   /// `-enable-private-imports`.
   bool arePrivateImportsEnabled() const {

include/swift/Basic/LangOptions.h

@@ -144,10 +144,6 @@ namespace swift {
     /// was not compiled with -enable-testing.
     bool EnableTestableAttrRequiresTestableModule = true;
 
-    /// If true, the 'dynamic' attribute is added to all applicable
-    /// declarations.
-    bool EnableImplicitDynamic = false;
-
     ///
     /// Flags for developers
     ///

include/swift/Frontend/FrontendOptions.h

@@ -197,6 +197,12 @@ class FrontendOptions {
   /// \see ModuleDecl::arePrivateImportsEnabled
   bool EnablePrivateImports = false;
 
+
+  /// Indicates whether we add implicit dynamic.
+  ///
+  /// \see ModuleDecl::isImplicitDynamicEnabled
+  bool EnableImplicitDynamic = false;
+
   /// Enables the "fully resilient" resilience strategy.
   ///
   /// \see ResilienceStrategy::Resilient

lib/AST/ASTVerifier.cpp

@@ -3149,12 +3149,12 @@ class Verifier : public ASTWalker {
                storageDecl->getWriteImpl() ==
                    WriteImplKind::StoredWithObservers ||
                storageDecl->getWriteImpl() == WriteImplKind::MutableAddress) &&
-              storageDecl->isDynamic() && !storageDecl->isObjC()) &&
+              storageDecl->isNativeDynamic()) &&
             // We allow a non dynamic getter if there is a dynamic read.
             !(FD->isGetter() &&
               (storageDecl->getReadImpl() == ReadImplKind::Read ||
                storageDecl->getReadImpl() == ReadImplKind::Address) &&
-              storageDecl->isDynamic() && !storageDecl->isObjC())) {
+              storageDecl->isNativeDynamic())) {
           Out << "Property and accessor do not match for 'dynamic'\n";
           abort();
         }

lib/AST/Decl.cpp

@@ -1549,7 +1549,7 @@ getDirectReadWriteAccessStrategy(const AbstractStorageDecl *storage) {
     return AccessStrategy::getStorage();
   case ReadWriteImplKind::Stored: {
     // If the storage isDynamic (and not @objc) use the accessors.
-    if (storage->isDynamic() && !storage->isObjC())
+    if (storage->isNativeDynamic())
       return AccessStrategy::getMaterializeToTemporary(
           getOpaqueReadAccessStrategy(storage, false),
           getOpaqueWriteAccessStrategy(storage, false));
@@ -1623,7 +1623,7 @@ AbstractStorageDecl::getAccessStrategy(AccessSemantics semantics,
       if (isPolymorphic(this))
         return getOpaqueAccessStrategy(this, accessKind, /*dispatch*/ true);
 
-      if (isDynamic())
+      if (isNativeDynamic())
         return getOpaqueAccessStrategy(this, accessKind, /*dispatch*/ false);
 
       // If the storage is resilient to the given use DC (perhaps because

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -69,6 +69,7 @@ bool ArgsToFrontendOptionsConverter::convert(
   Opts.EnableTesting |= Args.hasArg(OPT_enable_testing);
   Opts.EnablePrivateImports |= Args.hasArg(OPT_enable_private_imports);
   Opts.EnableResilience |= Args.hasArg(OPT_enable_resilience);
+  Opts.EnableImplicitDynamic |= Args.hasArg(OPT_enable_implicit_dynamic);
 
   Opts.TrackSystemDeps |= Args.hasArg(OPT_track_system_dependencies);
 

lib/Frontend/CompilerInvocation.cpp

@@ -274,7 +274,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.DebugConstraintSolver |= Args.hasArg(OPT_debug_constraints);
   Opts.NamedLazyMemberLoading &= !Args.hasArg(OPT_disable_named_lazy_member_loading);
   Opts.DebugGenericSignatures |= Args.hasArg(OPT_debug_generic_signatures);
-  Opts.EnableImplicitDynamic |= Args.hasArg(OPT_enable_implicit_dynamic);
 
   if (Args.hasArg(OPT_verify_syntax_tree)) {
     Opts.BuildSyntaxTree = true;

lib/Frontend/Frontend.cpp

@@ -488,6 +488,8 @@ ModuleDecl *CompilerInstance::getMainModule() {
       MainModule->setTestingEnabled();
     if (Invocation.getFrontendOptions().EnablePrivateImports)
       MainModule->setPrivateImportsEnabled();
+    if (Invocation.getFrontendOptions().EnableImplicitDynamic)
+      MainModule->setImplicitDynamicEnabled();
 
     if (Invocation.getFrontendOptions().EnableResilience)
       MainModule->setResilienceStrategy(ResilienceStrategy::Resilient);

lib/SIL/SILDeclRef.cpp

@@ -964,13 +964,14 @@ bool SILDeclRef::isDynamicallyReplaceable() const {
     return false;
 
   if (kind == SILDeclRef::Kind::Destroyer ||
-      kind == SILDeclRef::Kind::Initializer) {
+      kind == SILDeclRef::Kind::Initializer ||
+      kind == SILDeclRef::Kind::GlobalAccessor) {
     return false;
   }
 
   if (!hasDecl())
     return false;
 
   auto decl = getDecl();
-  return decl->isDynamic() && !decl->isObjC();
+  return decl->isNativeDynamic();
 }

lib/Sema/CodeSynthesis.cpp

@@ -2042,6 +2042,11 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
     return;
 
   if (!dc->isTypeContext()) {
+    // dynamic globals need accessors.
+    if (dc->isModuleScopeContext() && storage->isNativeDynamic()) {
+      addTrivialAccessorsToStorage(storage, TC);
+      return;
+    }
     // Fixed-layout global variables don't get accessors.
     if (!storage->isResilient())
       return;

lib/Sema/TypeCheckAttr.cpp

@@ -2175,7 +2175,7 @@ void TypeChecker::checkDynamicReplacementAttribute(ValueDecl *D) {
     return;
   }
 
-  if (D->isDynamic() && !D->isObjC()) {
+  if (D->isNativeDynamic()) {
     diagnose(attr->getLocation(), diag::dynamic_replacement_must_not_be_dynamic,
              D->getBaseName());
     attr->setInvalid();
@@ -2451,9 +2451,6 @@ TypeChecker::diagnosticIfDeclCannotBePotentiallyUnavailable(const Decl *D) {
 }
 
 void TypeChecker::addImplicitDynamicAttribute(Decl *D) {
-  if (!getLangOpts().EnableImplicitDynamic)
-    return;
-
   // Add the attribute if the decl kind allows it and it is not an accessor
   // decl. Accessor decls should always infer the var/subscript's attribute.
   if (!DeclAttribute::canAttributeAppearOnDecl(DAK_Dynamic, D) ||

lib/Sema/TypeCheckDecl.cpp

@@ -1214,6 +1214,11 @@ IsDynamicRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
   if (!DeclAttribute::canAttributeAppearOnDecl(DAK_Dynamic, decl))
     return false;
 
+  // Add dynamic if -enable-implicit-dynamic was requested.
+  if (decl->getModuleContext()->isImplicitDynamicEnabled()) {
+    TypeChecker::addImplicitDynamicAttribute(decl);
+  }
+
   // If 'dynamic' was explicitly specified, check it.
   if (decl->getAttrs().hasAttribute<DynamicAttr>()) {
     if (decl->getASTContext().LangOpts.isSwiftVersionAtLeast(5))
@@ -2726,8 +2731,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   }
 
   void visitSubscriptDecl(SubscriptDecl *SD) {
-    TC.addImplicitDynamicAttribute(SD);
-
     TC.validateDecl(SD);
 
     if (!SD->isInvalid()) {
@@ -3197,8 +3200,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   }
 
   void visitVarDecl(VarDecl *VD) {
-    TC.addImplicitDynamicAttribute(VD);
-
     // Delay type-checking on VarDecls until we see the corresponding
     // PatternBindingDecl.
 
@@ -3250,8 +3251,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   }
 
   void visitFuncDecl(FuncDecl *FD) {
-    TC.addImplicitDynamicAttribute(FD);
-
     TC.validateDecl(FD);
 
     if (!FD->isInvalid()) {
@@ -3368,7 +3367,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   }
 
   void visitConstructorDecl(ConstructorDecl *CD) {
-    TC.addImplicitDynamicAttribute(CD);
     TC.validateDecl(CD);
 
     if (!CD->isInvalid()) {

lib/Sema/TypeChecker.h

@@ -1095,7 +1095,7 @@ class TypeChecker final : public LazyResolver {
   void typeCheckDecl(Decl *D);
 
   void checkDeclAttributesEarly(Decl *D);
-  void addImplicitDynamicAttribute(Decl *D);
+  static void addImplicitDynamicAttribute(Decl *D);
   void checkDeclAttributes(Decl *D);
   void checkDynamicReplacementAttribute(ValueDecl *D);
   void checkTypeModifyingDeclAttributes(VarDecl *var);

lib/TBDGen/TBDGen.cpp

@@ -165,7 +165,7 @@ void TBDGenVisitor::visitAbstractFunctionDecl(AbstractFunctionDecl *AFD) {
   addSymbol(SILDeclRef(AFD));
 
   // Add the global function pointer for a dynamically replaceable function.
-  if (AFD->isDynamic() && ! AFD->isObjC()) {
+  if (AFD->isNativeDynamic()) {
     addSymbol(LinkEntity::forDynamicallyReplaceableFunctionVariable(AFD));
     addSymbol(LinkEntity::forDynamicallyReplaceableFunctionImpl(AFD));
     addSymbol(LinkEntity::forDynamicallyReplaceableFunctionKey(AFD));

test/Interpreter/Inputs/dynamic_replacement_module.swift

@@ -1,4 +1,6 @@
 #if MODULE
+public dynamic var public_global_var = "public_global_var"
+
 public dynamic func public_global_func() -> String {
   return "public_global_func"
 }
@@ -64,6 +66,8 @@ public enum PublicEnumeration<Q> {
   }
 }
 #elseif MODULENODYNAMIC
+public var public_global_var = "public_global_var"
+
 public func public_global_func() -> String {
   return "public_global_func"
 }
@@ -134,6 +138,11 @@ import Module1
 
 /// Public global functions, struct, class, and enum.
 
+@_dynamicReplacement(for: public_global_var)
+public var replacement_for_public_global_var : String {
+  return "replacement of public_global_var"
+}
+
 @_dynamicReplacement(for: public_global_func())
 public func replacement_for_public_global_func() -> String {
   return "replacement of " + public_global_func()

test/Interpreter/dynamic_replacement.swift

@@ -72,6 +72,8 @@ func expectedResult(_ forOriginalLibrary: Bool,  _ expectedOriginalString: Strin
 }
 
 func checkExpectedResults(forOriginalLibrary useOrig: Bool) {
+ expectTrue(public_global_var == expectedResult(useOrig, "public_global_var"))
+
  expectTrue(public_global_func() ==
             expectedResult(useOrig, "public_global_func"))
  expectTrue(public_global_generic_func(Int.self) ==

test/SILGen/dynamically_replaceable.swift

@@ -271,3 +271,14 @@ extension GenericS {
     }
   }
 }
+
+dynamic var globalX = 0
+// CHECK-LABEL: sil hidden [dynamically_replacable] @$s23dynamically_replaceable7globalXSivg : $@convention(thin) () -> Int
+// CHECK-LABEL: sil hidden [dynamically_replacable] @$s23dynamically_replaceable7globalXSivs : $@convention(thin) (Int) -> ()
+// CHECK-LABEL: sil hidden @$s23dynamically_replaceable7getsetXyS2iF
+// CHECK: dynamic_function_ref @$s23dynamically_replaceable7globalXSivs
+// CHECK: dynamic_function_ref @$s23dynamically_replaceable7globalXSivg
+func getsetX(_ x: Int) -> Int {
+  globalX = x
+  return globalX
+}