Merge remote-tracking branch 'origin/master' into master-rebranch

Author: swift-ci

include/swift/AST/DiagnosticsSema.def

@@ -3009,6 +3009,8 @@ ERROR(lazy_must_be_property,none,
       "lazy is only valid for members of a struct or class", ())
 ERROR(lazy_not_strong,none,
       "lazy properties cannot be %0", (ReferenceOwnership))
+ERROR(lazy_var_storage_access,none,
+     "access to the underlying storage of a lazy property is not allowed", ())
 
 // Debugger function attribute.
 ERROR(attr_for_debugger_support_only,none,

lib/Sema/MiscDiagnostics.cpp

@@ -4390,6 +4390,53 @@ static void maybeDiagnoseCallToKeyValueObserveMethod(const Expr *E,
   const_cast<Expr *>(E)->walk(Walker);
 }
 
+static void diagnoseExplicitUseOfLazyVariableStorage(const Expr *E,
+                                                     const DeclContext *DC) {
+
+  class ExplicitLazyVarStorageAccessFinder : public ASTWalker {
+    const ASTContext &C;
+
+  public:
+    ExplicitLazyVarStorageAccessFinder(ASTContext &ctx) : C(ctx) {}
+
+    void tryDiagnoseExplicitLazyStorageVariableUse(MemberRefExpr *MRE) {
+      if (MRE->isImplicit()) {
+        return;
+      }
+      auto VD = dyn_cast<VarDecl>(MRE->getMember().getDecl());
+      if (!VD) {
+        return;
+      }
+      auto sourceFileKind = VD->getDeclContext()->getParentSourceFile();
+      if (!sourceFileKind) {
+        return;
+      }
+      if (sourceFileKind->Kind != SourceFileKind::Library &&
+          sourceFileKind->Kind != SourceFileKind::Main) {
+        return;
+      }
+      if (VD->isLazyStorageProperty()) {
+        C.Diags.diagnose(MRE->getLoc(), diag::lazy_var_storage_access);
+      }
+    }
+
+    std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
+      if (!E || isa<ErrorExpr>(E) || !E->getType())
+        return {false, E};
+
+      if (auto *MRE = dyn_cast<MemberRefExpr>(E)) {
+        tryDiagnoseExplicitLazyStorageVariableUse(MRE);
+        return {false, E};
+      }
+
+      return {true, E};
+    }
+  };
+
+  ExplicitLazyVarStorageAccessFinder Walker(DC->getASTContext());
+  const_cast<Expr *>(E)->walk(Walker);
+}
+
 //===----------------------------------------------------------------------===//
 // High-level entry points.
 //===----------------------------------------------------------------------===//
@@ -4405,6 +4452,7 @@ void swift::performSyntacticExprDiagnostics(const Expr *E,
   diagnoseImplicitSelfUseInClosure(E, DC);
   diagnoseUnintendedOptionalBehavior(E, DC);
   maybeDiagnoseCallToKeyValueObserveMethod(E, DC);
+  diagnoseExplicitUseOfLazyVariableStorage(E, DC);
   if (!ctx.isSwiftVersionAtLeast(5))
     diagnoseDeprecatedWritableKeyPath(E, DC);
   if (!ctx.LangOpts.DisableAvailabilityChecking)

lib/Sema/TypeCheckType.cpp

@@ -2345,15 +2345,23 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
     }
   }
 
-  if (hasFunctionAttr && !fnRepr) {
-    if (attrs.has(TAK_autoclosure)) {
+  if (attrs.has(TAK_autoclosure)) {
+    // If this is a situation where function type is wrapped
+    // into a number of parens, let's try to look through them,
+    // because parens are insignificant here e.g.:
+    //
+    // let _: (@autoclosure (() -> Void)) -> Void = { _ in }
+    if (!ty->is<FunctionType>()) {
       // @autoclosure is going to be diagnosed when type of
       // the parameter is validated, because that attribute
       // applies to the declaration now.
       repr->setInvalid();
-      attrs.clearAttribute(TAK_autoclosure);
     }
 
+    attrs.clearAttribute(TAK_autoclosure);
+  }
+
+  if (hasFunctionAttr && !fnRepr) {
     const auto diagnoseInvalidAttr = [&](TypeAttrKind kind) {
       if (kind == TAK_escaping) {
         Type optionalObjectType = ty->getOptionalObjectType();

localization/diagnostics/en.yaml

@@ -1993,6 +1993,9 @@
   msg: >-
     cannot declare entity named %0; the '$' prefix is reserved for
     implicitly-synthesized declarations
+- id: lazy_var_storage_access
+  msg: >-
+    access to the underlying storage of a lazy property is not allowed
 
 - id: anon_closure_arg_not_in_closure
   msg: >-

test/attr/attr_autoclosure.swift

@@ -295,3 +295,36 @@ struct SR_11938_S : @autoclosure SR_11938_P {} // expected-error {{'@autoclosure
 
 // SR-9178
 func bar<T>(_ x: @autoclosure T) {} // expected-error 1{{@autoclosure attribute only applies to function types}}
+
+func test_autoclosure_type_in_parens() {
+  let _: (@autoclosure (() -> Void)) -> Void = { _ in } // Ok
+
+  struct Test {
+    func bugSingle<T: RawRepresentable>(defaultValue: @autoclosure (() -> T)) -> T { // Ok
+      defaultValue()
+    }
+
+    func bugMultiple<T: RawRepresentable>(defaultValue: @autoclosure ((() -> T))) -> T { // Ok
+      defaultValue()
+    }
+  }
+
+  enum E : String {
+    case foo = "foo"
+    case bar = "bar"
+  }
+
+  _ = Test().bugSingle(defaultValue: E.foo)   // Ok
+  _ = Test().bugMultiple(defaultValue: E.bar) // Ok
+}
+
+func test_autoclosure_with_typealias() {
+  typealias ConcreteFunc = () -> Int
+  typealias GenericFunc<T> = () -> T
+
+  func test(cr: @autoclosure ConcreteFunc) -> Int { cr() } // Ok
+  func test<Q>(gn: @autoclosure GenericFunc<Q>) -> Q { gn() } // Ok
+
+  _ = test(cr: 0) // Ok
+  _ = test(gn: 1) // Ok
+}

test/decl/var/lazy_properties.swift

@@ -189,3 +189,32 @@ class ReferenceStaticInLazyProperty {
   static var i = 42
   static func f() -> Int { return 0 }
 }
+
+// Explicit access to the lazy variable storage
+class LazyVarContainer {
+  lazy var foo: Int = {
+    return 0
+  }()
+
+  func accessLazyStorage() {
+    $__lazy_storage_$_foo = nil // expected-error {{access to the underlying storage of a lazy property is not allowed}}
+    print($__lazy_storage_$_foo!) // expected-error {{access to the underlying storage of a lazy property is not allowed}}
+    _ = $__lazy_storage_$_foo == nil // expected-error {{access to the underlying storage of a lazy property is not allowed}}
+  }
+}
+
+// Make sure we can still access a synthesized variable with the same name as a lazy storage variable
+// i.e. $__lazy_storage_$_{property_name} when using property wrapper where the property name is 
+// '__lazy_storage_$_{property_name}'.
+@propertyWrapper
+struct Wrapper {
+  var wrappedValue: Int { 1 }
+  var projectedValue: Int { 1 }
+}
+
+struct PropertyWrapperContainer {
+  @Wrapper var __lazy_storage_$_foo
+  func test() {
+    _ = $__lazy_storage_$_foo  // This is okay.
+  }
+}

utils/build-script

@@ -220,7 +220,6 @@ def validate_arguments(toolchain, args):
         'build_indexstoredb',
         'build_playgroundsupport',
         'build_sourcekitlsp',
-        'build_tensorflow_swift_apis',
         'build_toolchainbenchmarks',
         'build_swift_inspect',
         'tsan_libdispatch_test',
@@ -273,7 +272,6 @@ def apply_default_arguments(toolchain, args):
         args.build_foundation or
         args.build_indexstoredb or
         args.build_sourcekitlsp or
-        args.build_tensorflow_swift_apis or
         args.cmake_generator == 'Ninja'
     )
     if ninja_required and toolchain.ninja is None:
@@ -889,8 +887,6 @@ class BuildScriptInvocation(object):
             product_classes.append(products.IndexStoreDB)
         if self.args.build_playgroundsupport:
             product_classes.append(products.PlaygroundSupport)
-        if self.args.build_tensorflow_swift_apis:
-            product_classes.append(products.TensorFlowSwiftAPIs)
         if self.args.build_sourcekitlsp:
             product_classes.append(products.SourceKitLSP)
         if self.args.build_toolchainbenchmarks:

utils/build_swift/build_swift/driver_arguments.py

@@ -633,12 +633,6 @@ def create_argument_parser():
            store_true('install_playgroundsupport'),
            help='install playground support')
 
-    option('--tensorflow-swift-apis', store_true('build_tensorflow_swift_apis'),
-           help='build TensorFlow Swift APIs')
-    option('--install-tensorflow-swift-apis',
-           store_true('install_tensorflow_swift_apis'),
-           help='install TensorFlow Swift APIs')
-
     option('--build-ninja', toggle_true,
            help='build the Ninja tool')
 

utils/build_swift/tests/expected_options.py

@@ -90,7 +90,6 @@
     'build_swiftpm': False,
     'build_swift_driver': False,
     'build_swiftsyntax': False,
-    'build_tensorflow_swift_apis': False,
     'build_libparser_only': False,
     'build_skstresstester': False,
     'build_swiftformat': False,
@@ -107,7 +106,6 @@
     'install_sourcekitlsp': False,
     'install_skstresstester': False,
     'install_swiftevolve': False,
-    'install_tensorflow_swift_apis': False,
     'build_toolchainbenchmarks': False,
     'build_tvos': True,
     'build_tvos_device': False,
@@ -467,9 +465,6 @@ class BuildScriptImplOption(_BaseOption):
     SetTrueOption('--playgroundsupport', dest='build_playgroundsupport'),
     SetTrueOption('--install-playgroundsupport',
                   dest='install_playgroundsupport'),
-    SetTrueOption('--tensorflow-swift-apis', dest='build_tensorflow_swift_apis'),
-    SetTrueOption('--install-tensorflow-swift-apis',
-                  dest='install_tensorflow_swift_apis'),
     SetTrueOption('--skip-build'),
     SetTrueOption('--swiftpm', dest='build_swiftpm'),
     SetTrueOption('--swift-driver', dest='build_swift_driver'),

utils/swift_build_support/swift_build_support/products/__init__.py

@@ -31,7 +31,6 @@
 from .swiftinspect import SwiftInspect
 from .swiftpm import SwiftPM
 from .swiftsyntax import SwiftSyntax
-from .tensorflow import TensorFlowSwiftAPIs
 from .tsan_libdispatch import TSanLibDispatch
 from .xctest import XCTest
 
@@ -52,7 +51,6 @@
     'SwiftInspect',
     'SwiftPM',
     'SwiftDriver',
-    'TensorFlowSwiftAPIs',
     'XCTest',
     'SwiftSyntax',
     'SKStressTester',