---

yaml
---
r: 316903
b: refs/heads/master-rebranch
c: e9ec2ed
h: refs/heads/master
i:
  316901: 0ade4c6
  316899: 2638288
  316895: 8a1b9d8

Author: swift-ci

[refs]

@@ -1457,4 +1457,4 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: caec0f909cf2aaffa88daaecf14016a3df02d58e
+refs/heads/master-rebranch: e9ec2ed51f96353f6797eea56174a8c3b0416c84

branches/master-rebranch/include/swift/Basic/Version.h

@@ -161,6 +161,7 @@ class Version {
 };
 
 bool operator>=(const Version &lhs, const Version &rhs);
+bool operator<(const Version &lhs, const Version &rhs);
 bool operator==(const Version &lhs, const Version &rhs);
 inline bool operator!=(const Version &lhs, const Version &rhs) {
   return !(lhs == rhs);

branches/master-rebranch/lib/AST/ASTPrinter.cpp

@@ -64,6 +64,13 @@ void PrintOptions::clearSynthesizedExtension() {
   TransformContext.reset();
 }
 
+static bool isPublicOrUsableFromInline(const ValueDecl *VD) {
+  AccessScope scope =
+      VD->getFormalAccessScope(/*useDC*/nullptr,
+                               /*treatUsableFromInlineAsPublic*/true);
+  return scope.isPublic();
+}
+
 static bool contributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
   auto *DC = ASD->getDeclContext()->getAsDecl();
   if (!DC) return false;
@@ -96,10 +103,7 @@ PrintOptions PrintOptions::printTextualInterfaceFile() {
     bool shouldPrint(const Decl *D, const PrintOptions &options) override {
       // Skip anything that isn't 'public' or '@usableFromInline'.
       if (auto *VD = dyn_cast<ValueDecl>(D)) {
-        AccessScope accessScope =
-            VD->getFormalAccessScope(/*useDC*/nullptr,
-                                     /*treatUsableFromInlineAsPublic*/true);
-        if (!accessScope.isPublic()) {
+        if (!isPublicOrUsableFromInline(VD)) {
           // We do want to print private stored properties, without their
           // original names present.
           if (auto *ASD = dyn_cast<AbstractStorageDecl>(VD))
@@ -109,6 +113,14 @@ PrintOptions PrintOptions::printTextualInterfaceFile() {
         }
       }
 
+      // Skip extensions that extend things we wouldn't print.
+      if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
+        if (!shouldPrint(ED->getExtendedNominal(), options))
+          return false;
+        // FIXME: We also need to check the generic signature for constraints
+        // that we can't reference.
+      }
+
       // Skip typealiases that just redeclare generic parameters.
       if (auto *alias = dyn_cast<TypeAliasDecl>(D)) {
         if (alias->isImplicit()) {
@@ -886,7 +898,7 @@ void PrintAST::printPattern(const Pattern *pattern) {
     recordDeclLoc(decl, [&]{
       if (Options.OmitNameOfInaccessibleProperties &&
           contributesToParentTypeStorage(decl) &&
-          decl->getFormalAccess() < AccessLevel::Public)
+          !isPublicOrUsableFromInline(decl))
         Printer << "_";
       else
         Printer.printName(named->getBoundName());

branches/master-rebranch/lib/Basic/Version.cpp

@@ -384,6 +384,11 @@ bool operator>=(const class Version &lhs,
   return true;
 }
 
+bool operator<(const class Version &lhs, const class Version &rhs) {
+
+  return !(lhs >= rhs);
+}
+
 bool operator==(const class Version &lhs,
                 const class Version &rhs) {
   auto n = std::max(lhs.size(), rhs.size());
@@ -446,4 +451,3 @@ std::string getSwiftRevision() {
 
 } // end namespace version
 } // end namespace swift
-

branches/master-rebranch/lib/Parse/ParseIfConfig.cpp

@@ -36,7 +36,7 @@ namespace {
 /// Get PlatformConditionKind from platform condition name.
 static
 Optional<PlatformConditionKind> getPlatformConditionKind(StringRef Name) {
-  return llvm::StringSwitch<llvm::Optional<PlatformConditionKind>>(Name)
+  return llvm::StringSwitch<Optional<PlatformConditionKind>>(Name)
     .Case("os", PlatformConditionKind::OS)
     .Case("arch", PlatformConditionKind::Arch)
     .Case("_endian", PlatformConditionKind::Endianness)
@@ -53,6 +53,20 @@ static StringRef extractExprSource(SourceManager &SM, Expr *E) {
   return SM.extractText(Range);
 }
 
+static bool isValidPrefixUnaryOperator(Optional<StringRef> UnaryOperator) {
+  return UnaryOperator != None &&
+         (UnaryOperator.getValue() == ">=" || UnaryOperator.getValue() == "<");
+}
+
+static bool isValidVersion(const version::Version &Version,
+                           const version::Version &ExpectedVersion,
+                           StringRef UnaryOperator) {
+  if (UnaryOperator == ">=")
+    return Version >= ExpectedVersion;
+  if (UnaryOperator == "<")
+    return Version < ExpectedVersion;
+  llvm_unreachable("unsupported unary operator");
+}
 
 /// The condition validator.
 class ValidateIfConfigCondition :
@@ -63,7 +77,7 @@ class ValidateIfConfigCondition :
   bool HasError;
 
   /// Get the identifier string of the UnresolvedDeclRefExpr.
-  llvm::Optional<StringRef> getDeclRefStr(Expr *E, DeclRefKind Kind) {
+  Optional<StringRef> getDeclRefStr(Expr *E, DeclRefKind Kind) {
     auto UDRE = dyn_cast<UnresolvedDeclRefExpr>(E);
     if (!UDRE ||
         !UDRE->hasName() ||
@@ -85,7 +99,7 @@ class ValidateIfConfigCondition :
   Expr *foldSequence(Expr *LHS, ArrayRef<Expr*> &S, bool isRecurse = false) {
     assert(!S.empty() && ((S.size() & 1) == 0));
 
-    auto getNextOperator = [&]() -> llvm::Optional<StringRef> {
+    auto getNextOperator = [&]() -> Optional<StringRef> {
       assert((S.size() & 1) == 0);
       while (!S.empty()) {
         auto Name = getDeclRefStr(S[0], DeclRefKind::BinaryOperator);
@@ -109,7 +123,7 @@ class ValidateIfConfigCondition :
       // If failed, it's not a sequence anymore.
       return LHS;
     Expr *Op = S[0];
-  
+
     // We will definitely be consuming at least one operator.
     // Pull out the prospective RHS and slice off the first two elements.
     Expr *RHS = validate(S[1]);
@@ -216,16 +230,16 @@ class ValidateIfConfigCondition :
       return E;
     }
 
-    // 'swift' '(' '>=' float-literal ( '.' integer-literal )* ')'
-    // 'compiler' '(' '>=' float-literal ( '.' integer-literal )* ')'
+    // 'swift' '(' ('>=' | '<') float-literal ( '.' integer-literal )* ')'
+    // 'compiler' '(' ('>=' | '<') float-literal ( '.' integer-literal )* ')'
     if (*KindName == "swift" || *KindName == "compiler") {
       auto PUE = dyn_cast<PrefixUnaryExpr>(Arg);
-      llvm::Optional<StringRef> PrefixName = PUE ?
-        getDeclRefStr(PUE->getFn(), DeclRefKind::PrefixOperator) : None;
-      if (!PrefixName || *PrefixName != ">=") {
-        D.diagnose(Arg->getLoc(),
-                   diag::unsupported_platform_condition_argument,
-                   "a unary comparison, such as '>=2.2'");
+      Optional<StringRef> PrefixName =
+          PUE ? getDeclRefStr(PUE->getFn(), DeclRefKind::PrefixOperator) : None;
+      if (!isValidPrefixUnaryOperator(PrefixName)) {
+        D.diagnose(
+            Arg->getLoc(), diag::unsupported_platform_condition_argument,
+            "a unary comparison '>=' or '<'; for example, '>=2.2' or '<2.2'");
         return nullptr;
       }
       auto versionString = extractExprSource(Ctx.SourceMgr, PUE->getArg());
@@ -382,13 +396,17 @@ class EvaluateIfConfigCondition :
       return thisVersion >= Val;
     } else if ((KindName == "swift") || (KindName == "compiler")) {
       auto PUE = cast<PrefixUnaryExpr>(Arg);
+      auto PrefixName = getDeclRefStr(PUE->getFn());
       auto Str = extractExprSource(Ctx.SourceMgr, PUE->getArg());
       auto Val = version::Version::parseVersionString(
           Str, SourceLoc(), nullptr).getValue();
       if (KindName == "swift") {
-        return Ctx.LangOpts.EffectiveLanguageVersion >= Val;  
+        return isValidVersion(Ctx.LangOpts.EffectiveLanguageVersion, Val,
+                              PrefixName);
       } else if (KindName == "compiler") {
-        return version::Version::getCurrentLanguageVersion() >= Val;
+        auto currentLanguageVersion =
+            version::Version::getCurrentLanguageVersion();
+        return isValidVersion(currentLanguageVersion, Val, PrefixName);
       } else {
         llvm_unreachable("unsupported version conditional");
       }

branches/master-rebranch/test/ModuleInterface/access-filter.swift

@@ -102,3 +102,12 @@ extension PublicStruct {
   // CHECK: public private(set) static var secretlySettable: Int{{$}}
   public private(set) static var secretlySettable: Int = 0
 } // CHECK: {{^[}]$}}
+
+extension InternalStruct_BAD: PublicProto {
+  internal static var dummy: Int { return 0 }
+}
+
+// CHECK: extension UFIStruct : PublicProto {{[{]$}}
+extension UFIStruct: PublicProto {
+  internal static var dummy: Int { return 0 }
+} // CHECK-NEXT: {{^[}]$}}

branches/master-rebranch/test/ModuleInterface/private-stored-member-type-layout.swift

@@ -17,10 +17,10 @@
 // These two appear out-of-order between run lines
 
 // CHECK-DAG: [[MYCLASS:%T20PrivateStoredMembers7MyClassC]] = type opaque
-// CHECK-DAG: [[MYSTRUCT:%T20PrivateStoredMembers8MyStructV]] = type <{ %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V }>
+// CHECK-DAG: [[MYSTRUCT:%T20PrivateStoredMembers8MyStructV]] = type <{ %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V }>
 
-// CHECK-MAIN-DAG: [[MYCLASS:%T4main7MyClassC]] = type <{ %swift.refcounted, %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V }>
-// CHECK-MAIN-DAG: [[MYSTRUCT:%T4main8MyStructV]] = type <{ %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V }>
+// CHECK-MAIN-DAG: [[MYCLASS:%T4main7MyClassC]] = type <{ %swift.refcounted, %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V }>
+// CHECK-MAIN-DAG: [[MYSTRUCT:%T4main8MyStructV]] = type <{ %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V, %TSb, [7 x i8], %Ts5Int64V }>
 
 #if SHOULD_IMPORT
 import PrivateStoredMembers
@@ -29,7 +29,7 @@ import PrivateStoredMembers
 // CHECK-EXEC: swiftcc void @"$s{{[^ ]+}}8makeUseryyF"() #0 {
 public func makeUser() {
   let ptr = UnsafeMutablePointer<MyStruct>.allocate(capacity: 1)
-  // CHECK-EXEC: %.publicEndVar = getelementptr inbounds [[MYSTRUCT]], [[MYSTRUCT]]* %{{[0-9]+}}, i32 0, i32 [[PUBLIC_END_VAR_IDX:9]]
+  // CHECK-EXEC: %.publicEndVar = getelementptr inbounds [[MYSTRUCT]], [[MYSTRUCT]]* %{{[0-9]+}}, i32 0, i32 [[PUBLIC_END_VAR_IDX:12]]
   // CHECK-EXEC: %.publicEndVar._value = getelementptr inbounds %Ts5Int64V, %Ts5Int64V* %.publicEndVar, i32 0, i32 0
   // CHECK-EXEC: store i64 4, i64* %.publicEndVar._value
   ptr.pointee.publicEndVar = 4

branches/master-rebranch/test/ModuleInterface/private-stored-members.swift

@@ -29,6 +29,14 @@ public struct MyStruct {
 // RESILIENT-NOT: internal let _: [[BOOL]]{{$}}
   let internalLet: Bool
 
+// COMMON-NEXT: @usableFromInline
+// COMMON-NEXT: internal var ufiVar: [[INT64]]{{$}}
+  @usableFromInline var ufiVar: Int64
+
+// COMMON-NEXT: @usableFromInline
+// COMMON-NEXT: internal let ufiLet: [[BOOL]]{{$}}
+  @usableFromInline let ufiLet: Bool
+
 // CHECK-NEXT: private var _: [[INT64]]{{$}}
 // RESILIENT-NOT: private var _: [[INT64]]{{$}}
   private var privateVar: Int64
@@ -69,6 +77,14 @@ public class MyClass {
 // RESILIENT-NOT: internal let _: [[BOOL]]{{$}}
   let internalLet: Bool = true
 
+// COMMON-NEXT: @usableFromInline
+// COMMON-NEXT: internal var ufiVar: [[INT64]]{{$}}
+  @usableFromInline var ufiVar: Int64 = 0
+
+// COMMON-NEXT: @usableFromInline
+// COMMON-NEXT: internal let ufiLet: [[BOOL]]{{$}}
+  @usableFromInline let ufiLet: Bool = true
+
 // CHECK-NEXT: private var _: [[INT64]]{{$}}
 // RESILIENT-NOT: private var _: [[INT64]]{{$}}
   private var privateVar: Int64 = 0

branches/master-rebranch/test/Parse/ConditionalCompilation/compiler.swift

@@ -0,0 +1,30 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -swift-version 4
+
+#if !compiler(>=4.1)
+ // There should be no error here.
+ foo bar
+#else
+ let _: Int = 1
+#endif
+
+#if compiler(<4.1)
+ // There should be no error here.
+ foo bar
+#else
+ let _: Int = 1
+#endif
+
+#if (compiler(>=4.1))
+ let _: Int = 1
+#else
+ // There should be no error here.
+ foo bar
+#endif
+
+#if !compiler(<4.1)
+ let _: Int = 1
+#else
+ // There should be no error here.
+ foo bar
+#endif

branches/master-rebranch/test/Parse/ConditionalCompilation/language_version.swift

@@ -7,6 +7,20 @@
   asdf asdf asdf asdf
 #endif
 
+#if swift(<1.2)
+#endif
+
+#if swift(<4.2)
+  let a = 1
+#else
+  let a = 2
+#endif
+
+#if swift(<1.0)
+   // This shouldn't emit any diagnostics.
+   asdf asdf asdf asdf
+#endif
+
 #if swift(>=1.2)
 
 #if os(iOS)
@@ -34,13 +48,21 @@
   %#^*&
 #endif
 
-#if swift(">=7.1") // expected-error {{unexpected platform condition argument: expected a unary comparison, such as '>=2.2'}}
+#if !swift(<1000.0)
+  // This shouldn't emit any diagnostics.
+  %#^*&
+#endif
+
+#if swift(">=7.1") // expected-error {{unexpected platform condition argument: expected a unary comparison '>=' or '<'; for example, '>=2.2' or '<2.2'}}
+#endif
+
+#if swift("<7.1") // expected-error {{unexpected platform condition argument: expected a unary comparison '>=' or '<'; for example, '>=2.2' or '<2.2'}}
 #endif
 
-#if swift(">=2n.2") // expected-error {{unexpected platform condition argument: expected a unary comparison, such as '>=2.2'}}
+#if swift(">=2n.2") // expected-error {{unexpected platform condition argument: expected a unary comparison '>=' or '<'; for example, '>=2.2' or '<2.2'}}
 #endif
 
-#if swift("") // expected-error {{unexpected platform condition argument: expected a unary comparison, such as '>=2.2'}}
+#if swift("") // expected-error {{unexpected platform condition argument: expected a unary comparison '>=' or '<'; for example, '>=2.2' or '<2.2'}}
 #endif
 
 #if swift(>=2.2.1)