[ConstraintSystem] Implement implicit property wrapper attribute

hborla · hborla · commit 133dec0e05d4 · 2021-02-25T18:35:14.000-08:00
inference for closure parameters.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -5496,6 +5496,9 @@ ERROR(property_wrapper_param_projection_invalid,none,
 ERROR(property_wrapper_param_mutating,none,
       "property wrapper applied to parameter must have a nonmutating "
       "'wrappedValue' getter", ())
+ERROR(invalid_implicit_property_wrapper,none,
+      "inferred projection type %0 is not a property wrapper",
+      (Type))
 
 ERROR(property_wrapper_mutating_get_composed_to_get_only,none,
       "property wrapper %0 with a mutating getter cannot be composed inside "
diff --git a/include/swift/Sema/CSFix.h b/include/swift/Sema/CSFix.h
@@ -123,6 +123,9 @@ enum class FixKind : uint8_t {
   /// a projection argument.
   AddProjectedValue,
 
+  /// Add '@propertyWrapper' to a nominal type declaration.
+  AddPropertyWrapperAttribute,
+
   /// Instead of spelling out `subscript` directly, use subscript operator.
   UseSubscriptOperator,
 
@@ -966,7 +969,7 @@ class AddProjectedValue final : public ConstraintFix {
 
   AddProjectedValue(ConstraintSystem &cs, Type wrapper,
                     ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::UseWrappedValue, locator), wrapperType(wrapper) {}
+      : ConstraintFix(cs, FixKind::AddProjectedValue, locator), wrapperType(wrapper) {}
 
 public:
   static AddProjectedValue *create(ConstraintSystem &cs, Type wrapper,
@@ -979,6 +982,24 @@ class AddProjectedValue final : public ConstraintFix {
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 };
 
+class AddPropertyWrapperAttribute final : public ConstraintFix {
+  Type wrapperType;
+
+  AddPropertyWrapperAttribute(ConstraintSystem &cs, Type wrapper,
+                              ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AddPropertyWrapperAttribute, locator), wrapperType(wrapper) {}
+
+public:
+  static AddPropertyWrapperAttribute *create(ConstraintSystem &cs, Type wrapper,
+                                             ConstraintLocator *locator);
+
+  std::string getName() const override {
+    return "add '@propertyWrapper'";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+};
+
 class UseSubscriptOperator final : public ConstraintFix {
   UseSubscriptOperator(ConstraintSystem &cs, ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::UseSubscriptOperator, locator) {}
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -7831,23 +7831,23 @@ namespace {
         if (!param->hasAttachedPropertyWrapper())
           continue;
 
-        auto wrapperInfo = param->getPropertyWrapperBackingPropertyInfo();
-        auto *backingVar = wrapperInfo.backingVar;
-        auto wrapperType = solution.simplifyType(solution.getType(backingVar));
-        backingVar->setInterfaceType(wrapperType->mapTypeOutOfContext());
-
-        if (auto *projection = wrapperInfo.projectionVar) {
-          auto typeInfo = param->getAttachedPropertyWrapperTypeInfo(0);
-          auto projectionType = wrapperType->getTypeOfMember(param->getModuleContext(),
-                                                             typeInfo.projectedValueVar);
-          projection->setInterfaceType(projectionType);
+        // Set the interface type of each property wrapper synthesized var
+        auto *backingVar = param->getPropertyWrapperBackingProperty();
+        backingVar->setInterfaceType(
+            solution.simplifyType(solution.getType(backingVar))->mapTypeOutOfContext());
+
+        if (auto *projectionVar = param->getPropertyWrapperProjectionVar()) {
+          projectionVar->setInterfaceType(
+              solution.simplifyType(solution.getType(projectionVar)));
         }
 
         auto *wrappedValueVar = param->getPropertyWrapperWrappedValueVar();
-        auto wrappedValueType = computeWrappedValueType(param, wrapperType);
-        wrappedValueVar->setInterfaceType(wrappedValueType);
+        wrappedValueVar->setInterfaceType(
+            solution.simplifyType(solution.getType(wrappedValueVar)));
       }
 
+      TypeChecker::checkParameterList(closure->getParameters(), closure);
+
       auto &appliedWrappers = Rewriter.solution.appliedPropertyWrappers[closure];
       return Rewriter.buildPropertyWrapperFnThunk(closure, closureFnType, closure,
                                                   appliedWrappers);
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -3309,6 +3309,15 @@ bool MissingProjectedValueFailure::diagnoseAsError() {
   return true;
 }
 
+bool MissingPropertyWrapperAttributeFailure::diagnoseAsError() {
+  emitDiagnostic(diag::invalid_implicit_property_wrapper, wrapperType);
+
+  // FIXME: emit a note and fix-it to add '@propertyWrapper' if the
+  // type is a nominal and in the same module.
+
+  return true;
+}
+
 bool SubscriptMisuseFailure::diagnoseAsError() {
   auto *locator = getLocator();
   auto &sourceMgr = getASTContext().SourceMgr;
diff --git a/lib/Sema/CSDiagnostics.h b/lib/Sema/CSDiagnostics.h
@@ -1079,6 +1079,17 @@ class MissingProjectedValueFailure final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+class MissingPropertyWrapperAttributeFailure final : public FailureDiagnostic {
+  Type wrapperType;
+
+public:
+  MissingPropertyWrapperAttributeFailure(const Solution &solution, Type wrapper,
+                                         ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator), wrapperType(resolveType(wrapper)) {}
+
+  bool diagnoseAsError() override;
+};
+
 class SubscriptMisuseFailure final : public FailureDiagnostic {
 public:
   SubscriptMisuseFailure(const Solution &solution, ConstraintLocator *locator)
diff --git a/lib/Sema/CSFix.cpp b/lib/Sema/CSFix.cpp
@@ -639,6 +639,17 @@ AddProjectedValue *AddProjectedValue::create(ConstraintSystem &cs, Type wrapperT
   return new (cs.getAllocator()) AddProjectedValue(cs, wrapperType, locator);
 }
 
+bool AddPropertyWrapperAttribute::diagnose(const Solution &solution, bool asNote) const {
+  MissingPropertyWrapperAttributeFailure failure(solution, wrapperType, getLocator());
+  return failure.diagnose(asNote);
+}
+
+AddPropertyWrapperAttribute *AddPropertyWrapperAttribute::create(ConstraintSystem &cs,
+                                                                 Type wrapperType,
+                                                                 ConstraintLocator *locator) {
+  return new (cs.getAllocator()) AddPropertyWrapperAttribute(cs, wrapperType, locator);
+}
+
 bool UseSubscriptOperator::diagnose(const Solution &solution,
                                     bool asNote) const {
   SubscriptMisuseFailure failure(solution, getLocator());
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -2053,18 +2053,6 @@ namespace {
                 TVO_CanBindToInOut | TVO_CanBindToNoEscape | TVO_CanBindToHole);
           }
 
-          if (auto wrapperInfo = param->getPropertyWrapperBackingPropertyInfo()) {
-            auto *wrapperAttr = param->getAttachedPropertyWrappers().front();
-            auto wrapperType = param->getAttachedPropertyWrapperType(0);
-            auto backingType = CS.openUnboundGenericTypes(
-                wrapperType, CS.getConstraintLocator(wrapperAttr->getTypeRepr()));
-            CS.setType(wrapperInfo.backingVar, backingType);
-
-            CS.applyPropertyWrapperParameter(backingType, externalType, param,
-                                             param->getName(), ConstraintKind::Equal,
-                                             CS.getConstraintLocator(closure));
-          }
-
           closureParams.push_back(param->toFunctionParam(externalType));
         }
       }
@@ -4082,17 +4070,17 @@ ConstraintSystem::applyPropertyWrapperParameter(
       return getTypeMatchFailure(locator);
     };
 
-    auto typeInfo = param->getAttachedPropertyWrapperTypeInfo(0);
+    auto typeInfo = wrapperType->getAnyNominal()->getPropertyWrapperTypeInfo();
     if (!typeInfo.projectedValueVar) {
       auto *fix = AddProjectedValue::create(*this, wrapperType, getConstraintLocator(locator));
       return attemptProjectedValueFix(fix);
     }
 
-    auto projectionType = wrapperType->getTypeOfMember(param->getModuleContext(),
-                                                       typeInfo.projectedValueVar);
+    Type projectionType = computeProjectedValueType(param, wrapperType);
     addConstraint(matchKind, paramType, projectionType, locator);
 
-    if (param->getAttachedPropertyWrappers().front()->getArg()) {
+    if (!param->hasImplicitPropertyWrapper() &&
+        param->getAttachedPropertyWrappers().front()->getArg()) {
       auto *fix = UseWrappedValue::create(*this, param, /*base=*/Type(), wrapperType,
                                           getConstraintLocator(locator));
       return attemptProjectedValueFix(fix);
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -8197,6 +8197,54 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
         param = param.withFlags(contextualParam->getParameterFlags());
     }
 
+    if (paramDecl->hasAttachedPropertyWrapper()) {
+      bool hasError = false;
+      Type backingType;
+
+      if (paramDecl->hasImplicitPropertyWrapper()) {
+        backingType = getContextualParamAt(i)->getPlainType();
+
+        // If the contextual type is not a property wrapper, record a fix.
+        auto *nominal = backingType->getAnyNominal();
+        if (!(nominal && nominal->getAttrs().hasAttribute<PropertyWrapperAttr>())) {
+          if (!shouldAttemptFixes())
+            return false;
+
+          paramDecl->visitAuxiliaryDecls([](VarDecl *var) {
+            var->setInvalid();
+          });
+
+          auto *fix = AddPropertyWrapperAttribute::create(*this, backingType,
+                                                          getConstraintLocator(paramDecl));
+          recordFix(fix);
+          hasError = true;
+        }
+      } else {
+        auto *wrapperAttr = paramDecl->getAttachedPropertyWrappers().front();
+        auto wrapperType = paramDecl->getAttachedPropertyWrapperType(0);
+        backingType = replaceInferableTypesWithTypeVars(
+            wrapperType, getConstraintLocator(wrapperAttr->getTypeRepr()));
+      }
+
+      if (!hasError) {
+        auto result = applyPropertyWrapperParameter(backingType, param.getParameterType(),
+                                                    paramDecl, paramDecl->getName(),
+                                                    ConstraintKind::Equal, locator);
+        if (result.isFailure())
+          return false;
+
+        auto *backingVar = paramDecl->getPropertyWrapperBackingProperty();
+        setType(backingVar, backingType);
+
+        auto *localWrappedVar = paramDecl->getPropertyWrapperWrappedValueVar();
+        setType(localWrappedVar, computeWrappedValueType(paramDecl, backingType));
+
+        if (auto *projection = paramDecl->getPropertyWrapperProjectionVar()) {
+          setType(projection, computeProjectedValueType(paramDecl, backingType));
+        }
+      }
+    }
+
     Type internalType;
     if (paramDecl->getTypeRepr()) {
       // Internal type is the type used in the body of the closure,
@@ -10665,6 +10713,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::UsePropertyWrapper:
   case FixKind::UseWrappedValue:
   case FixKind::AddProjectedValue:
+  case FixKind::AddPropertyWrapperAttribute:
   case FixKind::ExpandArrayIntoVarargs:
   case FixKind::UseRawValue:
   case FixKind::ExplicitlyConstructRawRepresentable:
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
@@ -2081,13 +2081,6 @@ bool TypeChecker::typeCheckClosureBody(ClosureExpr *closure) {
   TypeChecker::checkClosureAttributes(closure);
   TypeChecker::checkParameterList(closure->getParameters(), closure);
 
-  for (auto *param : *closure->getParameters()) {
-    if (!param->isImplicit() && param->getName().hasDollarPrefix() &&
-        !param->hasAttachedPropertyWrapper()) {
-      param->diagnose(diag::dollar_identifier_decl, param->getName());
-    }
-  }
-
   BraceStmt *body = closure->getBody();
 
   Optional<FunctionBodyTimer> timer;
diff --git a/test/Parse/dollar_identifier.swift b/test/Parse/dollar_identifier.swift
@@ -77,12 +77,9 @@ func $declareWithDollar() { // expected-error{{cannot declare entity named '$dec
     $b c: Int) { } // expected-error{{cannot declare entity named '$b'}}
   let _: (Int) -> Int = {
     [$capture = 0] // expected-error{{cannot declare entity named '$capture'}}
-    $a in // diagnosed after type checking the closure
+    $a in // expected-error{{inferred projection type 'Int' is not a property wrapper}}
     $capture
   }
-  let _: (Int) -> Void = {
-    $a in // expected-error{{cannot declare entity named '$a'}}
-  }
   let ($a: _, _) = (0, 0) // expected-error{{cannot declare entity named '$a'}}
   $label: if true { // expected-error{{cannot declare entity named '$label'}}
     break $label
diff --git a/test/Sema/property_wrapper_parameter.swift b/test/Sema/property_wrapper_parameter.swift
@@ -77,11 +77,34 @@ func testMethods(instance: S<String>, Metatype: S<String>.Type,
 }
 
 func testClosures() {
-  let _: (Int) -> Wrapper<Int> = { (@Wrapper value) in
-    _value
+  typealias PropertyWrapperTuple = (Wrapper<Int>, Int, Projection<Int>)
+
+  let _: (Int) -> PropertyWrapperTuple = { (@Wrapper value) in
+    (_value, value, $value)
+  }
+
+  let _: (Projection<Int>) -> PropertyWrapperTuple = { (@Wrapper $value) in
+    (_value, value, $value)
+  }
+}
+
+@propertyWrapper
+struct ProjectionWrapper<Value> {
+  var wrappedValue: Value
+
+  var projectedValue: ProjectionWrapper<Value> { self }
+
+  init(wrappedValue: Value) { self.wrappedValue = wrappedValue }
+
+  init(projectedValue: ProjectionWrapper<Value>) {
+    self.wrappedValue = projectedValue.wrappedValue
   }
+}
+
+func testImplicitPropertyWrapper() {
+  typealias PropertyWrapperTuple = (ProjectionWrapper<Int>, Int, ProjectionWrapper<Int>)
 
-  let _: (Projection<Int>) -> Wrapper<Int> = { (@Wrapper $value) in
-    _value
+  let _: (ProjectionWrapper<Int>) -> PropertyWrapperTuple = { $value in
+    (_value, value, $value)
   }
 }
