Error type cleanup

include/swift/AST/Decl.h

@@ -4392,13 +4392,6 @@ class AbstractStorageDecl : public ValueDecl {
   /// property from the given module?
   bool isResilient(ModuleDecl *M, ResilienceExpansion expansion) const;
 
-  /// Returns the interface type of elements of storage represented by this
-  /// declaration.
-  ///
-  /// For variables, this is the type of the variable itself.
-  /// For subscripts, this is the type of the subscript element.
-  Type getStorageInterfaceType() const;
-
   /// Does the storage use a behavior?
   bool hasBehavior() const {
     return BehaviorInfo.getPointer() != nullptr;

lib/AST/ASTContext.cpp

@@ -3528,6 +3528,8 @@ getGenericFunctionRecursiveProperties(Type Input, Type Result) {
   static_assert(RecursiveTypeProperties::BitWidth == 10,
                 "revisit this if you add new recursive type properties");
   RecursiveTypeProperties properties;
+  if (Input->getRecursiveProperties().hasError())
+    properties |= RecursiveTypeProperties::HasError;
   if (Result->getRecursiveProperties().hasDynamicSelf())
     properties |= RecursiveTypeProperties::HasDynamicSelf;
   if (Result->getRecursiveProperties().hasError())

lib/AST/Decl.cpp

@@ -4335,7 +4335,7 @@ SourceLoc AbstractStorageDecl::getOverrideLoc() const {
 
 Type AbstractStorageDecl::getValueInterfaceType() const {
   if (auto var = dyn_cast<VarDecl>(this))
-    return var->getInterfaceType();
+    return var->getInterfaceType()->getReferenceStorageReferent();
   return cast<SubscriptDecl>(this)->getElementInterfaceType();
 }
 
@@ -5296,11 +5296,12 @@ void AbstractFunctionDecl::computeType(AnyFunctionType::ExtInfo info) {
   } else if (auto ctor = dyn_cast<ConstructorDecl>(this)) {
     auto *dc = ctor->getDeclContext();
 
-    if (hasSelf)
-      resultTy = dc->getSelfInterfaceType();
-
-    if (!resultTy)
-      resultTy = ErrorType::get(ctx);
+    if (hasSelf) {
+      if (!dc->isTypeContext())
+        resultTy = ErrorType::get(ctx);
+      else
+        resultTy = dc->getSelfInterfaceType();
+    }
 
     // Adjust result type for failability.
     if (ctor->getFailability() != OTK_None)
@@ -5514,7 +5515,7 @@ Type FuncDecl::getResultInterfaceType() const {
     return nullptr;
 
   Type resultTy = getInterfaceType();
-  if (resultTy->hasError())
+  if (resultTy->is<ErrorType>())
     return resultTy;
 
   if (hasImplicitSelfDecl())

lib/AST/NameLookup.cpp

@@ -1511,18 +1511,6 @@ void ClassDecl::recordObjCMethod(AbstractFunctionDecl *method) {
   vec.push_back(method);
 }
 
-Type AbstractStorageDecl::getStorageInterfaceType() const {
-  if (auto var = dyn_cast<VarDecl>(this)) {
-    return var->getInterfaceType();
-  }
-
-  if (auto sub = dyn_cast<SubscriptDecl>(this)) {
-    return sub->getElementInterfaceType();
-  }
-
-  llvm_unreachable("unhandled storage decl kind");
-}
-
 /// Configure name lookup for the given declaration context and options.
 ///
 /// This utility is used by qualified name lookup.

lib/ClangImporter/ImporterImpl.h

@@ -626,8 +626,7 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
       assert(CD->getInterfaceType());
       ty = CD->getResultInterfaceType();
     } else {
-      ty = cast<AbstractStorageDecl>(decl)->getValueInterfaceType()
-                                          ->getReferenceStorageReferent();
+      ty = cast<AbstractStorageDecl>(decl)->getValueInterfaceType();
     }
 #endif
 

lib/SIL/SILVerifier.cpp

@@ -4783,8 +4783,7 @@ void SILProperty::verify(const SILModule &M) const {
   auto sig = dc->getGenericSignatureOfContext();
   auto baseTy = dc->getInnermostTypeContext()->getSelfInterfaceType()
                   ->getCanonicalType(sig);
-  auto leafTy = decl->getStorageInterfaceType()->getReferenceStorageReferent()
-                    ->getCanonicalType(sig);
+  auto leafTy = decl->getValueInterfaceType()->getCanonicalType(sig);
   SubstitutionMap subs;
   if (sig) {
     auto env = dc->getGenericEnvironmentOfContext();

lib/SILGen/SILGen.cpp

@@ -1202,14 +1202,13 @@ TypeConverter::canStorageUseStoredKeyPathComponent(AbstractStorageDecl *decl) {
                                           M.getSwiftModule());
   switch (strategy.getKind()) {
   case AccessStrategy::Storage: {
-    // If the stored value would need to be reabstracted in fully opaque
-    // context, then we have to treat the component as computed.
-    auto componentObjTy = decl->getStorageInterfaceType()
-                              ->getWithoutSpecifierType();
     // Keypaths rely on accessors to handle the special behavior of weak or
     // unowned properties.
-    if (componentObjTy->is<ReferenceStorageType>())
+    if (decl->getInterfaceType()->is<ReferenceStorageType>())
       return false;
+    // If the stored value would need to be reabstracted in fully opaque
+    // context, then we have to treat the component as computed.
+    auto componentObjTy = decl->getValueInterfaceType();
     if (auto genericEnv =
               decl->getInnermostDeclContext()->getGenericEnvironmentOfContext())
       componentObjTy = genericEnv->mapTypeIntoContext(componentObjTy);

lib/SILGen/SILGenExpr.cpp

@@ -3681,7 +3681,7 @@ SILGenModule::emitKeyPathComponentForDecl(SILLocation loc,
   if (auto var = dyn_cast<VarDecl>(storage)) {
     CanType componentTy;
     if (!var->getDeclContext()->isTypeContext()) {
-      componentTy = storage->getStorageInterfaceType()->getCanonicalType();
+      componentTy = var->getInterfaceType()->getCanonicalType();
     } else {
       componentTy =
         GenericEnvironment::mapTypeIntoContext(genericEnv, baseTy)

lib/Sema/CodeSynthesis.cpp

@@ -2169,8 +2169,7 @@ ConstructorDecl *swift::createImplicitConstructor(TypeChecker &tc,
 
       auto varType = var->getType()
         ->getReferenceStorageReferent();
-      auto varInterfaceType = var->getInterfaceType()
-        ->getReferenceStorageReferent();
+      auto varInterfaceType = var->getValueInterfaceType();
 
       // If var is a lazy property, its value is provided for the underlying
       // storage.  We thus take an optional of the properties type.  We only

lib/Sema/TypeCheckDecl.cpp

@@ -2620,6 +2620,12 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
   void visitSubscriptDecl(SubscriptDecl *SD) {
     TC.validateDecl(SD);
+
+    if (!SD->isInvalid()) {
+      TC.checkReferencedGenericParams(SD);
+      TC.checkProtocolSelfRequirements(SD);
+    }
+
     TC.checkDeclAttributes(SD);
 
     AccessControlChecker::checkAccessControl(TC, SD);
@@ -3121,6 +3127,15 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   void visitFuncDecl(FuncDecl *FD) {
     TC.validateDecl(FD);
 
+    // We get bogus errors here with generic subscript materializeForSet.
+    if (!FD->isInvalid()) {
+      if (!isa<AccessorDecl>(FD) ||
+          !cast<AccessorDecl>(FD)->isMaterializeForSet()) {
+        TC.checkReferencedGenericParams(FD);
+        TC.checkProtocolSelfRequirements(FD);
+      }
+    }
+
     AccessControlChecker::checkAccessControl(TC, FD);
     UsableFromInlineChecker::checkUsableFromInline(TC, FD);
 
@@ -3265,6 +3280,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   void visitConstructorDecl(ConstructorDecl *CD) {
     TC.validateDecl(CD);
 
+    if (!CD->isInvalid()) {
+      TC.checkReferencedGenericParams(CD);
+      TC.checkProtocolSelfRequirements(CD);
+    }
+
     // Check whether this initializer overrides an initializer in its
     // superclass.
     if (!checkOverrides(CD)) {
@@ -3609,13 +3629,13 @@ void checkMemberOperator(TypeChecker &TC, FuncDecl *FD) {
               isProtocol, FD->getFullName());
 }
 
-bool checkDynamicSelfReturn(TypeChecker &TC, FuncDecl *func,
+bool checkDynamicSelfReturn(FuncDecl *func,
                             TypeRepr *typeRepr,
                             unsigned optionalDepth) {
   // Look through parentheses.
   if (auto parenRepr = dyn_cast<TupleTypeRepr>(typeRepr)) {
     if (!parenRepr->isParenType()) return false;
-    return checkDynamicSelfReturn(TC, func, parenRepr->getElementType(0),
+    return checkDynamicSelfReturn(func, parenRepr->getElementType(0),
                                   optionalDepth);
   }
 
@@ -3624,8 +3644,9 @@ bool checkDynamicSelfReturn(TypeChecker &TC, FuncDecl *func,
     TypeAttributes attrs = attrRepr->getAttrs();
     if (!attrs.empty())
       return false;
-    return checkDynamicSelfReturn(TC, func, attrRepr->getTypeRepr(),
+    return checkDynamicSelfReturn(func, attrRepr->getTypeRepr(),
                                   optionalDepth);
+
   }
 
   // Look through optional types.
@@ -3639,7 +3660,7 @@ bool checkDynamicSelfReturn(TypeChecker &TC, FuncDecl *func,
   if (base) {
     // But only one level.
     if (optionalDepth != 0) return false;
-    return checkDynamicSelfReturn(TC, func, base, optionalDepth + 1);
+    return checkDynamicSelfReturn(func, base, optionalDepth + 1);
   }
 
   // Check whether we have a simple identifier type.
@@ -3648,17 +3669,16 @@ bool checkDynamicSelfReturn(TypeChecker &TC, FuncDecl *func,
     return false;
 
   // Check whether it is 'Self'.
-  if (simpleRepr->getIdentifier() != TC.Context.Id_Self)
+  if (simpleRepr->getIdentifier() != func->getASTContext().Id_Self)
     return false;
 
   // Note that the function has a dynamic Self return type and set
   // the return type component to the dynamic self type.
-  func->setDynamicSelf(true);
-  return false;
+  return true;
 }
 
 /// Check for methods that return 'DynamicResult'.
-bool checkDynamicSelfReturn(TypeChecker &TC, FuncDecl *func) {
+bool checkDynamicSelfReturn(FuncDecl *func) {
   // Check whether we have a specified result type.
   auto typeRepr = func->getBodyResultTypeLoc().getTypeRepr();
   if (!typeRepr)
@@ -3674,7 +3694,7 @@ bool checkDynamicSelfReturn(TypeChecker &TC, FuncDecl *func) {
   if (isa<AccessorDecl>(func))
     return false;
 
-  return checkDynamicSelfReturn(TC, func, typeRepr, 0);
+  return checkDynamicSelfReturn(func, typeRepr, 0);
 }
 
 Type buildAddressorResultType(TypeChecker &TC,
@@ -4097,8 +4117,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     validateSelfAccessKind(*this, FD);
 
     // Check whether the return type is dynamic 'Self'.
-    if (checkDynamicSelfReturn(*this, FD))
-      FD->setInvalid();
+    FD->setDynamicSelf(checkDynamicSelfReturn(FD));
 
     // Accessors should pick up various parts of their type signatures
     // directly from the storage declaration instead of re-deriving them.

lib/Sema/TypeCheckGeneric.cpp

@@ -602,13 +602,12 @@ static bool isSelfDerivedOrConcrete(Type protoSelf, Type type) {
 
 // For a generic requirement in a protocol, make sure that the requirement
 // set didn't add any requirements to Self or its associated types.
-static bool checkProtocolSelfRequirements(GenericSignature *sig,
-                                          ValueDecl *decl,
-                                          TypeChecker &TC) {
+void TypeChecker::checkProtocolSelfRequirements(ValueDecl *decl) {
   // For a generic requirement in a protocol, make sure that the requirement
   // set didn't add any requirements to Self or its associated types.
   if (auto *proto = dyn_cast<ProtocolDecl>(decl->getDeclContext())) {
     auto protoSelf = proto->getSelfInterfaceType();
+    auto *sig = decl->getInnermostDeclContext()->getGenericSignatureOfContext();
     for (auto req : sig->getRequirements()) {
       // If one of the types in the requirement is dependent on a non-Self
       // type parameter, this requirement is okay.
@@ -622,27 +621,21 @@ static bool checkProtocolSelfRequirements(GenericSignature *sig,
           req.getFirstType()->is<GenericTypeParamType>())
         continue;
 
-      TC.diagnose(decl,
-                  TC.Context.LangOpts.EffectiveLanguageVersion[0] >= 4
-                    ? diag::requirement_restricts_self
-                    : diag::requirement_restricts_self_swift3,
-                  decl->getDescriptiveKind(), decl->getFullName(),
-                  req.getFirstType().getString(),
-                  static_cast<unsigned>(req.getKind()),
-                  req.getSecondType().getString());
-
-      if (TC.Context.LangOpts.EffectiveLanguageVersion[0] >= 4)
-        return true;
+      diagnose(decl,
+               Context.isSwiftVersion3()
+                 ? diag::requirement_restricts_self_swift3
+                 : diag::requirement_restricts_self,
+               decl->getDescriptiveKind(), decl->getFullName(),
+               req.getFirstType().getString(),
+               static_cast<unsigned>(req.getKind()),
+               req.getSecondType().getString());
     }
   }
-
-  return false;
 }
 
 /// All generic parameters of a generic function must be referenced in the
 /// declaration's type, otherwise we have no way to infer them.
-static void checkReferencedGenericParams(GenericContext *dc,
-                                         TypeChecker &TC) {
+void TypeChecker::checkReferencedGenericParams(GenericContext *dc) {
   auto *genericParams = dc->getGenericParams();
   auto *genericSig = dc->getGenericSignatureOfContext();
   if (!genericParams)
@@ -798,9 +791,9 @@ static void checkReferencedGenericParams(GenericContext *dc,
           continue;
       }
       // Produce an error that this generic parameter cannot be bound.
-      TC.diagnose(paramDecl->getLoc(), diag::unreferenced_generic_parameter,
-                  paramDecl->getNameStr());
-      decl->setInterfaceType(ErrorType::get(TC.Context));
+      diagnose(paramDecl->getLoc(), diag::unreferenced_generic_parameter,
+               paramDecl->getNameStr());
+      decl->setInterfaceType(ErrorType::get(Context));
       decl->setInvalid();
     }
   }
@@ -868,9 +861,6 @@ void TypeChecker::validateGenericFuncSignature(AbstractFunctionDecl *func) {
   if (checkGenericFuncSignature(*this, nullptr, func, completeResolver))
     invalid = true;
 
-  if (!invalid)
-    invalid = checkProtocolSelfRequirements(sig, func, *this);
-
   if (invalid) {
     func->setInterfaceType(ErrorType::get(Context));
     func->setInvalid();
@@ -879,15 +869,9 @@ void TypeChecker::validateGenericFuncSignature(AbstractFunctionDecl *func) {
 
   func->computeType();
 
-  // We get bogus errors here with generic subscript materializeForSet.
-  if (!isa<AccessorDecl>(func) ||
-      !cast<AccessorDecl>(func)->isMaterializeForSet())
-    checkReferencedGenericParams(func, *this);
-
-  // Make sure that there are no unresolved
-  // dependent types in the generic signature.
-  assert(func->getInterfaceType()->hasError() ||
-         !func->getInterfaceType()->findUnresolvedDependentMemberType());
+  // Make sure that there are no unresolved dependent types in the
+  // generic signature.
+  assert(!func->getInterfaceType()->findUnresolvedDependentMemberType());
 }
 
 ///
@@ -1010,10 +994,6 @@ TypeChecker::validateGenericSubscriptSignature(SubscriptDecl *subscript) {
   CompleteGenericTypeResolver completeResolver(*this, sig);
   if (checkGenericSubscriptSignature(*this, nullptr, subscript, completeResolver))
     invalid = true;
-
-  if (!invalid)
-    invalid = checkProtocolSelfRequirements(sig, subscript, *this);
-
   if (invalid) {
     subscript->setInterfaceType(ErrorType::get(Context));
     subscript->setInvalid();
@@ -1022,8 +1002,6 @@ TypeChecker::validateGenericSubscriptSignature(SubscriptDecl *subscript) {
   }
 
   subscript->computeType();
-
-  checkReferencedGenericParams(subscript, *this);
 }
 
 ///

lib/Sema/TypeChecker.h

@@ -1294,6 +1294,14 @@ class TypeChecker final : public LazyResolver {
   /// of a generic subscript.
   void validateGenericSubscriptSignature(SubscriptDecl *subscript);
 
+  /// For a generic requirement in a protocol, make sure that the requirement
+  /// set didn't add any requirements to Self or its associated types.
+  void checkProtocolSelfRequirements(ValueDecl *decl);
+
+  /// All generic parameters of a generic function must be referenced in the
+  /// declaration's type, otherwise we have no way to infer them.
+  void checkReferencedGenericParams(GenericContext *dc);
+
   /// Construct a new generic environment for the given declaration context.
   ///
   /// \param genericParams The generic parameters to validate.

test/Parse/init_deinit.swift

@@ -11,7 +11,6 @@ struct FooStructConstructorB {
 struct FooStructConstructorC {
   init {} // expected-error {{expected '('}}{{7-7=()}}
   init<T> {} // expected-error {{expected '('}} {{10-10=()}}
-	// expected-error@-1{{generic parameter 'T' is not used in function signature}}
   init? { self.init() } // expected-error {{expected '('}} {{8-8=()}}
 }