Push VarDecl's TypeRepr into ParamDecl

VarDecls inherit their TypeRepr from their enclosing pattern, if any.
To retrieve the TypeRepr attached to a VarDecl or a ParamDecl in
a uniform way, the getTypeReprOrParentPatternTypeRepr API has been
provided.

Author: CodaFi

include/swift/AST/Decl.h

@@ -4786,8 +4786,6 @@ class VarDecl : public AbstractStorageDecl {
           bool issCaptureList, SourceLoc nameLoc, Identifier name,
           DeclContext *dc, StorageIsMutable_t supportsMutation);
 
-  TypeRepr *ParentRepr = nullptr;
-
   Type typeInContext;
 
 public:
@@ -4806,11 +4804,6 @@ class VarDecl : public AbstractStorageDecl {
     return hasName() ? getBaseName().getIdentifier().str() : "_";
   }
 
-  /// Retrieve the TypeRepr corresponding to the parsed type of the parent
-  /// pattern, if it exists.
-  TypeRepr *getTypeRepr() const { return ParentRepr; }
-  void setTypeRepr(TypeRepr *repr) { ParentRepr = repr; }
-
   bool hasType() const {
     // We have a type if either the type has been computed already or if
     // this is a deserialized declaration with an interface type.
@@ -4864,6 +4857,14 @@ class VarDecl : public AbstractStorageDecl {
   ///
   Pattern *getParentPattern() const;
 
+  /// Returns the parsed type of this variable declaration.  For parameters, this
+  /// is the parsed type the user explicitly wrote.  For variables, this is the
+  /// type the user wrote in the typed pattern that binds this variable.
+  ///
+  /// Note that there are many cases where the user may elide types.  This will
+  /// return null in those cases.
+  TypeRepr *getTypeReprOrParentPatternTypeRepr() const;
+
   /// Return the statement that owns the pattern associated with this VarDecl,
   /// if one exists.
   ///
@@ -5158,6 +5159,8 @@ class ParamDecl : public VarDecl {
   SourceLoc ArgumentNameLoc;
   SourceLoc SpecifierLoc;
 
+  TypeRepr *TyRepr = nullptr;
+
   struct StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
     Initializer *InitContext = nullptr;
@@ -5203,6 +5206,10 @@ class ParamDecl : public VarDecl {
 
   SourceLoc getSpecifierLoc() const { return SpecifierLoc; }
 
+  /// Retrieve the TypeRepr corresponding to the parsed type of the parameter, if it exists.
+  TypeRepr *getTypeRepr() const { return TyRepr; }
+  void setTypeRepr(TypeRepr *repr) { TyRepr = repr; }
+
   DefaultArgumentKind getDefaultArgumentKind() const {
     return static_cast<DefaultArgumentKind>(Bits.ParamDecl.defaultArgumentKind);
   }

lib/AST/ASTPrinter.cpp

@@ -2524,7 +2524,7 @@ void PrintAST::visitVarDecl(VarDecl *decl) {
   if (decl->hasInterfaceType()) {
     Printer << ": ";
     TypeLoc tyLoc;
-    if (auto *repr = decl->getTypeRepr())
+    if (auto *repr = decl->getTypeReprOrParentPatternTypeRepr())
       tyLoc = TypeLoc(repr, decl->getInterfaceType());
     else
       tyLoc = TypeLoc::withoutLoc(decl->getInterfaceType());

lib/AST/Decl.cpp

@@ -2595,7 +2595,7 @@ OpaqueReturnTypeRepr *ValueDecl::getOpaqueResultTypeRepr() const {
         }
       }
     } else {
-      returnRepr = VD->getTypeRepr();
+      returnRepr = VD->getTypeReprOrParentPatternTypeRepr();
     }
   } else if (auto *FD = dyn_cast<FuncDecl>(this)) {
     returnRepr = FD->getBodyResultTypeLoc().getTypeRepr();
@@ -5285,6 +5285,16 @@ Pattern *VarDecl::getParentPattern() const {
   return nullptr;
 }
 
+TypeRepr *VarDecl::getTypeReprOrParentPatternTypeRepr() const {
+  if (auto *param = dyn_cast<ParamDecl>(this))
+    return param->getTypeRepr();
+
+  if (auto *parentPattern = dyn_cast_or_null<TypedPattern>(getParentPattern()))
+      return parentPattern->getTypeLoc().getTypeRepr();
+
+  return nullptr;
+}
+
 NullablePtr<VarDecl>
 VarDecl::getCorrespondingFirstCaseLabelItemVarDecl() const {
   if (!hasName())

lib/Sema/TypeCheckConstraints.cpp

@@ -2136,8 +2136,10 @@ class FallbackDiagnosticListener : public ExprTypeCheckListener {
     // Before producing fatal error here, let's check if there are any "error"
     // diagnostics already emitted or waiting to be emitted. Because they are
     // a better indication of the problem.
-    if (!(hadAnyErrors() || TC.Context.hasDelayedConformanceErrors()))
+    if (!(hadAnyErrors() || TC.Context.hasDelayedConformanceErrors())) {
       TC.diagnose(expr->getLoc(), diag::failed_to_produce_diagnostic);
+      llvm_unreachable("");
+    }
   }
 };
 

lib/Sema/TypeCheckDecl.cpp

@@ -3663,7 +3663,7 @@ IsImplicitlyUnwrappedOptionalRequest::evaluate(Evaluator &evaluator,
     if (auto *subscript = dyn_cast<SubscriptDecl>(storage))
       TyR = subscript->getElementTypeLoc().getTypeRepr();
     else
-      TyR = cast<VarDecl>(storage)->getTypeRepr();
+      TyR = cast<VarDecl>(storage)->getTypeReprOrParentPatternTypeRepr();
     break;
   }
 
@@ -4251,21 +4251,26 @@ void TypeChecker::validateDecl(ValueDecl *D) {
       break;
     }
 
-    // If we're already checking our PatternBindingDecl, bail out
-    // without setting our own 'is being validated' flag, since we
-    // will attempt validation again later.
-    if (PBD->isBeingValidated())
-      return;
-
-    // Attempt to infer the type using initializer expressions.
-    validatePatternBindingEntries(*this, PBD);
+    // If we're not being validated, validate our parent pattern binding and
+    // attempt to infer the interface type using the initializer expressions.
+    if (!PBD->isBeingValidated()) {
+      validatePatternBindingEntries(*this, PBD);
+    }
 
     auto parentPattern = VD->getParentPattern();
     if (PBD->isInvalid() || !parentPattern->hasType()) {
       parentPattern->setType(ErrorType::get(Context));
       setBoundVarsTypeError(parentPattern, Context);
     }
 
+    auto interfaceType = parentPattern->getType()->mapTypeOutOfContext();
+    // In SIL mode, VarDecls are written as having reference storage types.
+    if (!interfaceType->is<ReferenceStorageType>()) {
+      if (auto *attr = VD->getAttrs().getAttribute<ReferenceOwnershipAttr>())
+        interfaceType = checkReferenceOwnershipAttr(VD, interfaceType, attr);
+    }
+    VD->setInterfaceType(interfaceType);
+
     break;
   }
 

lib/Sema/TypeCheckPattern.cpp

@@ -1013,9 +1013,11 @@ bool TypeChecker::coercePatternToType(Pattern *&P, TypeResolution resolution,
 
     // Note that the pattern's type does not include the reference storage type.
     P->setType(type);
-    var->setInterfaceType(interfaceType);
     var->setType(var->getDeclContext()->mapTypeIntoContext(interfaceType));
-    var->setTypeRepr(tyLoc.getTypeRepr());
+    // If there's no parent pattern binding then take this opportunity to
+    // set the interface type as well.
+    if (var->getParentPatternBinding() == nullptr)
+      var->setInterfaceType(interfaceType);
 
     // FIXME: Should probably just remove the forbidden prefix stuff, it no
     // longer makes a lot of sense in a request-based world.

lib/Sema/TypeCheckStorage.cpp

@@ -2421,7 +2421,7 @@ static void finishProtocolStorageImplInfo(AbstractStorageDecl *storage,
                                           StorageImplInfo &info) {
   if (auto *var = dyn_cast<VarDecl>(storage)) {
     SourceLoc typeLoc;
-    if (auto *repr = var->getTypeRepr())
+    if (auto *repr = var->getTypeReprOrParentPatternTypeRepr())
       typeLoc = repr->getLoc();
 
     if (info.hasStorage()) {