Fix witness substitution computation for property behaviors.

My recent refactoring of witnesses in Sema and the AST disabled a
test for property behaviors, because they were no longer handling
substitutions correctly. Introduce a type checker entrypoint to record
information about a known witness, using the normal witness-matching
logic rather than trying to synthesize the correct answer (and getting
it wrong).

Note that I had to manually introduce some type witnesses to get the
property behavior tests passing, because the property-behavior code is
(intentionally) not introducing implicit typealiases for the type
witnesses it synthesized. The old witness-synthesizing code worked
around this issue, but the new code does not. A different fix is in
the works (i.e., better handling of type witnesses in the constraint
solver), so we'll take this temporary regression in an experimental
feature.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -1903,6 +1903,8 @@ ERROR(property_behavior_invalid_parameter,none,
       "parameter expression provided, but property behavior %0 does not "
       "use it",
       (Identifier))
+ERROR(property_behavior_conformance_broken,none,
+      "property behavior for %0 in type %1 is broken", (DeclName, Type))
 
 //------------------------------------------------------------------------------
 // Type Check Attributes

lib/Sema/CodeSynthesis.cpp

@@ -1270,15 +1270,17 @@ void TypeChecker::completePropertyBehaviorStorage(VarDecl *VD,
   // Add accessors to the storage, since we'll need them to satisfy the
   // conformance requirements.
   addTrivialAccessorsToStorage(Storage, *this);
-  
+
+  // FIXME: Hack to eliminate spurious diagnostics.
+  if (BehaviorStorage->isStatic() != Storage->isStatic()) return;
+
   // Add the witnesses to the conformance.
-  // FIXME: Dropping substitution.
-  BehaviorConformance->setWitness(BehaviorStorage, Storage);
-  BehaviorConformance->setWitness(BehaviorStorage->getGetter(),
-                                  Storage->getGetter());
+  recordKnownWitness(BehaviorConformance, BehaviorStorage, Storage);
+  recordKnownWitness(BehaviorConformance, BehaviorStorage->getGetter(),
+                     Storage->getGetter());
   if (BehaviorStorage->isSettable(DC))
-    BehaviorConformance->setWitness(BehaviorStorage->getSetter(),
-                                    Storage->getSetter());
+    recordKnownWitness(BehaviorConformance, BehaviorStorage->getSetter(),
+                       Storage->getSetter());
 }
 
 void TypeChecker::completePropertyBehaviorParameter(VarDecl *VD,
@@ -1433,8 +1435,7 @@ void TypeChecker::completePropertyBehaviorParameter(VarDecl *VD,
   addMemberToContextIfNeeded(Parameter, DC);
 
   // Add the witnesses to the conformance.
-  // FIXME: Should compute substitutions.
-  BehaviorConformance->setWitness(BehaviorParameter, Parameter);
+  recordKnownWitness(BehaviorConformance, BehaviorParameter, Parameter);
 }
 
 void TypeChecker::completePropertyBehaviorAccessors(VarDecl *VD,

lib/Sema/TypeCheckProtocol.cpp

@@ -5436,3 +5436,18 @@ bool TypeChecker::isProtocolExtensionUsable(DeclContext *dc, Type type,
   return cs.solveSingle().hasValue();
 }
 
+void TypeChecker::recordKnownWitness(NormalProtocolConformance *conformance,
+                                     ValueDecl *req, ValueDecl *witness) {
+  // Match the witness. This should never fail, but it does allow renaming
+  // (because property behaviors rely on renaming).
+  auto match = matchWitness(*this, conformance->getProtocol(), conformance,
+                            conformance->getDeclContext(), req, witness);
+  if (match.Kind != MatchKind::ExactMatch &&
+      match.Kind != MatchKind::RenamedMatch) {
+    diagnose(witness, diag::property_behavior_conformance_broken,
+             witness->getFullName(), conformance->getType());
+    return;
+  }
+
+  conformance->setWitness(req, match.getWitness(Context));
+}

lib/Sema/TypeChecker.h

@@ -1640,6 +1640,15 @@ class TypeChecker final : public LazyResolver {
                          NominalTypeDecl *nominal,
                          AssociatedTypeDecl *assocType);
 
+  /// Record the witness information into the given conformance that maps
+  /// the given requirement to the given witness declaration.
+  ///
+  /// Use this routine only when the given witness is known to satisfy the
+  /// requirement, e.g., because the witness itself was synthesized. This
+  /// function is not allowed to fail.
+  void recordKnownWitness(NormalProtocolConformance *conformance,
+                          ValueDecl *req, ValueDecl *witness);
+
   /// Perform unqualified name lookup at the given source location
   /// within a particular declaration context.
   ///

test/Prototypes/property_behaviors/delayed.swift

@@ -39,6 +39,10 @@ extension delayedImmutable {
 
 class Foo {
   var x: Int __behavior delayedImmutable
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = Int
 }
 
 var DelayedImmutable = TestSuite("DelayedImmutable")

test/Prototypes/property_behaviors/lazy.swift

@@ -44,6 +44,10 @@ func evaluateLazy() -> Int {
 
 class Foo {
   var y: Int __behavior lazy { evaluateLazy() }
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = Int
 }
 
 var Lazy = TestSuite("Lazy")

test/SILGen/property_behavior.swift

@@ -1,8 +1,4 @@
 // RUN: %target-swift-frontend -emit-silgen -enable-experimental-property-behaviors %s | %FileCheck %s
-
-// Note: CodeSynthesis is forming witnesses without proper substitutions.
-// XFAIL: *
-
 protocol behavior {
   associatedtype Value
 }
@@ -100,9 +96,17 @@ extension withStorage {
 // TODO: storage behaviors in non-instance context
 struct S2<T> {
   var instance: T __behavior withStorage
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = T
 }
 class C2<T> {
   var instance: T __behavior withStorage
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = T
 }
 
 func exerciseStorage<T>(_ sx: inout S2<T>, _ sy: inout S2<Int>,
@@ -139,10 +143,18 @@ extension withInit {
 func any<T>() -> T { }
 
 struct S3<T> {
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = T
   var instance: T __behavior withInit { any() }
 }
 class C3<T> {
   var instance: T __behavior withInit { any() }
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = T
 }
 
 func exerciseStorage<T>(_ sx: inout S3<T>, _ sy: inout S3<Int>,

test/SILGen/property_behavior_init.swift

@@ -17,6 +17,10 @@ func whack<T>(_ x: inout T) {}
 struct Foo {
   var x: Int __behavior diBehavior
 
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = Int
+
   // TODO
   // var xx: (Int, Int) __behavior diBehavior
 

test/decl/var/behaviors.swift

@@ -126,10 +126,9 @@ struct Foo<T> {
   static var staticStorage1: T __behavior hasStorage // expected-error{{static stored properties not supported in generic types}}
   var storage2: T __behavior hasStorage
 
-  var storage3: Int = 0 // expected-error {{initializer expression provided, but property behavior 'hasStorage' does not use it}}
-    __behavior hasStorage
-  var (storage4, storage5) = tuple // expected-error* {{initializer expression provided, but property behavior 'hasStorage' does not use it}}
-    __behavior hasStorage
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = T
 
   func foo<U>(_: U) {
     var storage1: T __behavior hasStorage // expected-error {{not supported}}
@@ -139,6 +138,20 @@ struct Foo<T> {
     _ = storage2
   }
 }
+
+struct Foo2<T> {
+  var storage3: Int = 0 // expected-error {{initializer expression provided, but property behavior 'hasStorage' does not use it}}
+    __behavior hasStorage
+
+  var (storage4, storage5) = tuple // expected-error* {{initializer expression provided, but property behavior 'hasStorage' does not use it}}
+    __behavior hasStorage
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = Int
+}
+
+
 extension Foo {
   static var y: T __behavior hasStorage // expected-error{{static stored properties not supported in generic types}}
   var y: T __behavior hasStorage // expected-error {{extensions may not contain stored properties}}
@@ -240,4 +253,8 @@ struct TestStorageWithInitialValue {
   var y = 0 __behavior storageWithInitialValue
   var z: Int = 5.5 __behavior storageWithInitialValue // expected-error {{cannot convert value of type 'Double' to type 'Int' in coercion}}
   var (a, b) = tuple __behavior storageWithInitialValue // expected-error* {{do not support destructuring}}
+
+  // FIXME: Hack because we can't find the synthesized associated type witness
+  // during witness matching.
+  typealias Value = Int
 }