---

yaml
---
r: 348147
b: refs/heads/master
c: f7574e4
h: refs/heads/master
i:
  348145: f6a1828
  348143: 289253a

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ece4dd093477fb7ed68df59a65358ad8c10b11b1
+refs/heads/master: f7574e4670c5f562dfc2903358496385914cfd77
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/SILGen/RValue.cpp

@@ -21,6 +21,7 @@
 #include "Initialization.h"
 #include "SILGenFunction.h"
 #include "swift/AST/CanTypeVisitor.h"
+#include "swift/Basic/Defer.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/SIL/AbstractionPattern.h"
 #include "swift/SIL/SILArgument.h"
@@ -573,19 +574,19 @@ void RValue::assignInto(SILGenFunction &SGF, SILLocation loc,
 
 ManagedValue RValue::getAsSingleValue(SILGenFunction &SGF, SILLocation loc) && {
   assert(!isUsed() && "r-value already used");
+  SWIFT_DEFER {
+    makeUsed();
+  };
 
   if (isInContext()) {
-    makeUsed();
     return ManagedValue::forInContext();
   }
 
   // Avoid killing and re-emitting the cleanup if the enclosed value isn't a
   // tuple.
   if (!isa<TupleType>(type)) {
     assert(values.size() == 1 && "exploded non-tuple?!");
-    ManagedValue result = values[0];
-    makeUsed();
-    return result;
+    return values[0];
   }
 
   // *NOTE* Inside implodeTupleValues, we copy our values if they are not at +1.

trunk/lib/Sema/TypeCheckDecl.cpp

@@ -1966,6 +1966,24 @@ static void validateSelfAccessKind(TypeChecker &TC, FuncDecl *FD) {
     FD->setSelfAccessKind(SelfAccessKind::NonMutating);
   else if (FD->getAttrs().hasAttribute<ConsumingAttr>())
     FD->setSelfAccessKind(SelfAccessKind::__Consuming);
+  else if (auto accessor = dyn_cast<AccessorDecl>(FD)) {
+    if (accessor->getAccessorKind() == AccessorKind::Get ||
+        accessor->getAccessorKind() == AccessorKind::Set ||
+        accessor->getAccessorKind() == AccessorKind::DidSet ||
+        accessor->getAccessorKind() == AccessorKind::WillSet) {
+      auto storage = accessor->getStorage();
+      TC.validateDecl(storage);
+      if (accessor->getAccessorKind() == AccessorKind::Get) {
+        FD->setSelfAccessKind(storage->isGetterMutating()
+                              ? SelfAccessKind::Mutating
+                              : SelfAccessKind::NonMutating);
+      } else {
+        FD->setSelfAccessKind(storage->isSetterMutating()
+                              ? SelfAccessKind::Mutating
+                              : SelfAccessKind::NonMutating);
+      }
+    }
+  }
 
   if (FD->isMutating()) {
     if (!FD->isInstanceMember() ||

trunk/lib/Sema/TypeCheckStmt.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "TypeChecker.h"
+#include "TypeCheckAvailability.h"
 #include "TypeCheckType.h"
 #include "MiscDiagnostics.h"
 #include "ConstraintSystem.h"
@@ -2050,8 +2051,19 @@ static bool checkSuperInit(TypeChecker &tc, ConstructorDecl *fromCtor,
       // super.init() call.
       return true;
     }
+
+    // Make sure we can reference the designated initializer correctly.
+    if (fromCtor->getResilienceExpansion() == ResilienceExpansion::Minimal) {
+      TypeChecker::FragileFunctionKind fragileKind;
+      bool treatUsableFromInlineAsPublic;
+      std::tie(fragileKind, treatUsableFromInlineAsPublic) =
+        tc.getFragileFunctionKind(fromCtor);
+      tc.diagnoseInlinableDeclRef(
+          fromCtor->getLoc(), ctor, fromCtor, fragileKind,
+          treatUsableFromInlineAsPublic);
+    }
   }
-  
+
   return false;
 }
 

trunk/test/SILGen/property_wrappers.swift

@@ -346,6 +346,67 @@ func testComposition() {
   _ = CompositionMembers(p1: nil)
 }
 
+// Observers with non-default mutatingness.
+@propertyWrapper
+struct NonMutatingSet<T> {
+  private var fixed: T
+
+  var wrappedValue: T {
+    get { fixed }
+    nonmutating set { }
+  }
+
+  init(initialValue: T) {
+    fixed = initialValue
+  }
+}
+
+@propertyWrapper
+struct MutatingGet<T> {
+  private var fixed: T
+
+  var wrappedValue: T {
+    mutating get { fixed }
+    set { }
+  }
+
+  init(initialValue: T) {
+    fixed = initialValue
+  }
+}
+
+struct ObservingTest {
+	// ObservingTest.text.setter
+	// CHECK-LABEL: sil hidden [ossa] @$s17property_wrappers13ObservingTestV4textSSvs : $@convention(method) (@owned String, @guaranteed ObservingTest) -> ()
+	// CHECK: function_ref @$s17property_wrappers14NonMutatingSetV12wrappedValuexvg
+  @NonMutatingSet var text: String = "" {
+    didSet { }
+  }
+
+  @NonMutatingSet var integer: Int = 17 {
+    willSet { }
+  }
+
+  @MutatingGet var text2: String = "" {
+    didSet { }
+  }
+
+  @MutatingGet var integer2: Int = 17 {
+    willSet { }
+  }
+}
+
+// Tuple initial values.
+struct WithTuples {
+	// CHECK-LABEL: sil hidden [ossa] @$s17property_wrappers10WithTuplesVACycfC : $@convention(method) (@thin WithTuples.Type) -> WithTuples {
+	// CHECK: function_ref @$s17property_wrappers10WithTuplesV10$fractions33_F728088E0028E14D18C6A10CF68512E8LLAA07WrapperC12InitialValueVySd_S2dtGvpfi : $@convention(thin) () -> (Double, Double, Double)
+	// CHECK: function_ref @$s17property_wrappers23WrapperWithInitialValueV07initialF0ACyxGx_tcfC : $@convention(method) <τ_0_0> (@in τ_0_0, @thin WrapperWithInitialValue<τ_0_0>.Type) -> @out WrapperWithInitialValue<τ_0_0>
+  @WrapperWithInitialValue var fractions = (1.3, 0.7, 0.3)
+
+	static func getDefault() -> WithTuples {
+		return .init()
+	}
+}
 
 // CHECK-LABEL: sil_vtable ClassUsingWrapper {
 // CHECK-NEXT:  #ClassUsingWrapper.x!getter.1: (ClassUsingWrapper) -> () -> Int : @$s17property_wrappers17ClassUsingWrapperC1xSivg   // ClassUsingWrapper.x.getter

trunk/test/attr/attr_inlinable.swift

@@ -167,6 +167,7 @@ enum InternalEnum {
   _ = VersionedEnum.persimmon
 }
 
+
 // Inherited initializers - <rdar://problem/34398148>
 @usableFromInline
 @_fixed_layout
@@ -188,6 +189,7 @@ class Derived : Middle {
   }
 }
 
+
 // More inherited initializers
 @_fixed_layout
 public class Base2 {
@@ -208,6 +210,36 @@ class Derived2 : Middle2 {
   }
 }
 
+
+// Even more inherited initializers - https://bugs.swift.org/browse/SR-10940
+@_fixed_layout
+public class Base3 {}
+// expected-note@-1 {{initializer 'init()' is not '@usableFromInline' or public}}
+
+@_fixed_layout
+public class Derived3 : Base3 {
+  @inlinable
+  public init(_: Int) {}
+  // expected-error@-1 {{initializer 'init()' is internal and cannot be referenced from an '@inlinable' function}}
+}
+
+@_fixed_layout
+public class Base4 {}
+
+@_fixed_layout
+@usableFromInline
+class Middle4 : Base4 {}
+// expected-note@-1 {{initializer 'init()' is not '@usableFromInline' or public}}
+
+@_fixed_layout
+@usableFromInline
+class Derived4 : Middle4 {
+  @inlinable
+  public init(_: Int) {}
+  // expected-error@-1 {{initializer 'init()' is internal and cannot be referenced from an '@inlinable' function}}
+}
+
+
 // Stored property initializer expressions.
 //
 // Note the behavior here does not depend on the state of the -enable-library-evolution