Merge pull request swiftlang#24694 from slavapestov/random-ast-cleanups

slavapestov · web-flow · commit d0c7eb67ba9b · 2019-05-10T18:27:06.000-04:00
More preliminary cleanups for 'Used Conformances' removal
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -5323,6 +5323,8 @@ class ParamDecl : public VarDecl {
   
   SourceRange getSourceRange() const;
 
+  AnyFunctionType::Param toFunctionParam(Type type = Type()) const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { 
     return D->getKind() == DeclKind::Param;
diff --git a/include/swift/AST/ParameterList.h b/include/swift/AST/ParameterList.h
@@ -127,12 +127,6 @@ class alignas(ParamDecl *) ParameterList final :
   /// based on the interface types of the parameters in this list.
   void getParams(SmallVectorImpl<AnyFunctionType::Param> &params) const;
 
-  /// Return a list of function parameters for this parameter list,
-  /// based on types provided by a callback.
-  void getParams(SmallVectorImpl<AnyFunctionType::Param> &params,
-                 llvm::function_ref<Type(ParamDecl *)> getType) const;
-
-
   /// Return the full source range of this parameter.
   SourceRange getSourceRange() const;
   SourceLoc getStartLoc() const { return getSourceRange().Start; }
diff --git a/include/swift/AST/ProtocolConformanceRef.h b/include/swift/AST/ProtocolConformanceRef.h
@@ -138,8 +138,7 @@ class ProtocolConformanceRef {
   static Type
   getTypeWitnessByName(Type type,
                        ProtocolConformanceRef conformance,
-                       Identifier name,
-                       LazyResolver *resolver);
+                       Identifier name);
 
   /// Determine whether this conformance is canonical.
   bool isCanonical() const;
@@ -154,11 +153,6 @@ class ProtocolConformanceRef {
   /// Get any additional requirements that are required for this conformance to
   /// be satisfied.
   ArrayRef<Requirement> getConditionalRequirements() const;
-  
-  /// If this is a conformance reference for a protocol that inherits other
-  /// protocols, get a reference to the related conformance for the inherited
-  /// protocol.
-  ProtocolConformanceRef getInheritedConformanceRef(ProtocolDecl *base) const;
 };
 
 } // end namespace swift
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -4225,13 +4225,8 @@ Type ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
       *bridgedValueType = type;
 
     // Find the Objective-C class type we bridge to.
-    if (conformance->isConcrete()) {
-      return ProtocolConformanceRef::getTypeWitnessByName(
-               type, *conformance, Id_ObjectiveCType,
-               getLazyResolver());
-    } else {
-      return type->castTo<ArchetypeType>()->getNestedType(Id_ObjectiveCType);
-    }
+    return ProtocolConformanceRef::getTypeWitnessByName(
+        type, *conformance, Id_ObjectiveCType);
   }
 
   // Do we conform to Error?
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -5673,6 +5673,21 @@ Type ParamDecl::getVarargBaseTy(Type VarArgT) {
   return T;
 }
 
+AnyFunctionType::Param ParamDecl::toFunctionParam(Type type) const {
+  if (!type)
+    type = getInterfaceType();
+
+  if (isVariadic())
+    type = ParamDecl::getVarargBaseTy(type);
+
+  auto label = getArgumentName();
+  auto flags = ParameterTypeFlags::fromParameterType(type,
+                                                     isVariadic(),
+                                                     isAutoClosure(),
+                                                     getValueOwnership());
+  return AnyFunctionType::Param(type, label, flags);
+}
+
 void ParamDecl::setDefaultValue(Expr *E) {
   if (!DefaultValueAndFlags.getPointer()) {
     if (!E) return;
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
@@ -2057,13 +2057,6 @@ TypeDecl *EquivalenceClass::lookupNestedType(
               != proto->getParentModule())
           continue;
 
-        // Resolve the signature of this type.
-        if (!type->hasInterfaceType()) {
-          type->getASTContext().getLazyResolver()->resolveDeclSignature(type);
-          if (!type->hasInterfaceType())
-            continue;
-        }
-
         concreteDecls.push_back(type);
         continue;
       }
diff --git a/lib/AST/Parameter.cpp b/lib/AST/Parameter.cpp
@@ -89,29 +89,8 @@ ParameterList *ParameterList::clone(const ASTContext &C,
 
 void ParameterList::getParams(
                         SmallVectorImpl<AnyFunctionType::Param> &params) const {
-  getParams(params,
-            [](ParamDecl *decl) { return decl->getInterfaceType(); });
-}
-
-void ParameterList::getParams(
-                          SmallVectorImpl<AnyFunctionType::Param> &params,
-                          llvm::function_ref<Type(ParamDecl *)> getType) const {
-  if (size() == 0)
-    return;
-
-  for (auto P : *this) {
-    auto type = getType(P);
-
-    if (P->isVariadic())
-      type = ParamDecl::getVarargBaseTy(type);
-
-    auto label = P->getArgumentName();
-    auto flags = ParameterTypeFlags::fromParameterType(type,
-                                                       P->isVariadic(),
-                                                       P->isAutoClosure(),
-                                                       P->getValueOwnership());
-    params.emplace_back(type, label, flags);
-  }
+  for (auto P : *this)
+    params.push_back(P->toFunctionParam());
 }
 
 
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
@@ -144,13 +144,13 @@ ProtocolConformanceRef::subst(Type origType,
 Type
 ProtocolConformanceRef::getTypeWitnessByName(Type type,
                                              ProtocolConformanceRef conformance,
-                                             Identifier name,
-                                             LazyResolver *resolver) {
+                                             Identifier name) {
   assert(!conformance.isInvalid());
 
   // Find the named requirement.
+  ProtocolDecl *proto = conformance.getRequirement();
   AssociatedTypeDecl *assocType = nullptr;
-  auto members = conformance.getRequirement()->lookupDirect(name);
+  auto members = proto->lookupDirect(name);
   for (auto member : members) {
     assocType = dyn_cast<AssociatedTypeDecl>(member);
     if (assocType)
@@ -161,21 +161,8 @@ ProtocolConformanceRef::getTypeWitnessByName(Type type,
   if (!assocType)
     return nullptr;
 
-  if (conformance.isAbstract()) {
-    // For an archetype, retrieve the nested type with the appropriate
-    // name. There are no conformance tables.
-    if (auto archetype = type->getAs<ArchetypeType>()) {
-      return archetype->getNestedType(name);
-    }
-
-    return DependentMemberType::get(type, assocType);
-  }
-
-  auto concrete = conformance.getConcrete();
-  if (!concrete->hasTypeWitness(assocType, resolver)) {
-    return nullptr;
-  }
-  return concrete->getTypeWitness(assocType, resolver);
+  return assocType->getDeclaredInterfaceType().subst(
+    SubstitutionMap::getProtocolSubstitutions(proto, type, conformance));
 }
 
 void *ProtocolConformance::operator new(size_t bytes, ASTContext &context,
@@ -500,37 +487,6 @@ ProtocolConformanceRef::getConditionalRequirements() const {
     return {};
 }
 
-ProtocolConformanceRef
-ProtocolConformanceRef::getInheritedConformanceRef(ProtocolDecl *base) const {
-  if (isAbstract()) {
-    assert(getRequirement()->inheritsFrom(base));
-    return ProtocolConformanceRef(base);
-  }
-
-  auto concrete = getConcrete();
-  auto proto = concrete->getProtocol();
-  auto path =
-    proto->getGenericSignature()->getConformanceAccessPath(
-                                            proto->getSelfInterfaceType(), base);
-  ProtocolConformanceRef result = *this;
-  Type resultType = concrete->getType();
-  bool first = true;
-  for (const auto &step : path) {
-    if (first) {
-      assert(step.first->isEqual(proto->getSelfInterfaceType()));
-      assert(step.second == proto);
-      first = false;
-      continue;
-    }
-
-    result =
-        result.getAssociatedConformance(resultType, step.first, step.second);
-    resultType = result.getAssociatedType(resultType, step.first);
-  }
-
-  return result;
-}
-
 void NormalProtocolConformance::differenceAndStoreConditionalRequirements()
     const {
   switch (CRState) {
diff --git a/lib/PrintAsObjC/PrintAsObjC.cpp b/lib/PrintAsObjC/PrintAsObjC.cpp
@@ -1380,8 +1380,7 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     Type objcType = ProtocolConformanceRef::getTypeWitnessByName(
                       nominal->getDeclaredType(),
                       ProtocolConformanceRef(conformance),
-                      ctx.Id_ObjectiveCType,
-                      nullptr);
+                      ctx.Id_ObjectiveCType);
     if (!objcType) return nullptr;
 
     // Dig out the Objective-C class.
diff --git a/lib/SIL/Bridging.cpp b/lib/SIL/Bridging.cpp
@@ -225,8 +225,7 @@ Type TypeConverter::getLoweredCBridgedType(AbstractionPattern pattern,
     Type bridgedTy =
       ProtocolConformanceRef::getTypeWitnessByName(
         t, ProtocolConformanceRef(conformance),
-        M.getASTContext().Id_ObjectiveCType,
-        M.getASTContext().getLazyResolver());
+        M.getASTContext().Id_ObjectiveCType);
     assert(bridgedTy && "Missing _ObjectiveCType witness?");
     if (purpose == BridgedTypePurpose::ForResult && clangTy)
       bridgedTy = OptionalType::get(bridgedTy);
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
@@ -1741,7 +1741,7 @@ static Type isRawRepresentable(Type fromType, const ConstraintSystem &CS) {
     return Type();
 
   Type rawTy = ProtocolConformanceRef::getTypeWitnessByName(
-      fromType, *conformance, CS.getASTContext().Id_RawValue, &CS.TC);
+      fromType, *conformance, CS.getASTContext().Id_RawValue);
   return rawTy;
 }
 
@@ -2120,8 +2120,8 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
         Type errorCodeType = CS.getType(expr);
         Type errorType =
           ProtocolConformanceRef::getTypeWitnessByName(errorCodeType, *conformance,
-                                                       TC.Context.Id_ErrorType,
-                                                       &TC)->getCanonicalType();
+                                                       TC.Context.Id_ErrorType)
+                                                         ->getCanonicalType();
         if (errorType) {
           auto diag = diagnose(expr->getLoc(), diag::cannot_throw_error_code,
                                errorCodeType, errorType);
@@ -6255,7 +6255,7 @@ bool FailureDiagnosis::visitArrayExpr(ArrayExpr *E) {
     Type contextualElementType =
         ProtocolConformanceRef::getTypeWitnessByName(
             contextualType, *Conformance,
-            CS.getASTContext().Id_ArrayLiteralElement, &CS.TC)
+            CS.getASTContext().Id_ArrayLiteralElement)
             ->getDesugaredType();
 
     // Type check each of the subexpressions in place, passing down the contextual
@@ -6344,12 +6344,12 @@ bool FailureDiagnosis::visitDictionaryExpr(DictionaryExpr *E) {
 
     contextualKeyType =
         ProtocolConformanceRef::getTypeWitnessByName(
-            contextualType, *Conformance, CS.getASTContext().Id_Key, &CS.TC)
+            contextualType, *Conformance, CS.getASTContext().Id_Key)
             ->getDesugaredType();
 
     contextualValueType =
         ProtocolConformanceRef::getTypeWitnessByName(
-            contextualType, *Conformance, CS.getASTContext().Id_Value, &CS.TC)
+            contextualType, *Conformance, CS.getASTContext().Id_Value)
             ->getDesugaredType();
 
     assert(contextualKeyType && contextualValueType &&
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -2036,7 +2036,8 @@ namespace {
                           SmallVectorImpl<AnyFunctionType::Param> &params) {
       auto *paramList = closureExpr->getParameters();
       unsigned i = 0;
-      paramList->getParams(params, [&](ParamDecl *param) {
+
+      for (auto *param : *paramList) {
         auto *locator = CS.getConstraintLocator(
             closureExpr, LocatorPathElt::getTupleElement(i++));
         Type paramType, internalType;
@@ -2058,8 +2059,8 @@ namespace {
                            locator);
         }
         CS.setType(param, internalType);
-        return paramType;
-      });
+        params.push_back(param->toFunctionParam(paramType));
+      }
     }
 
     /// Produces a type for the given pattern, filling in any missing
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -4326,7 +4326,7 @@ void TypeChecker::useBridgedNSErrorConformances(DeclContext *dc, Type type) {
     // protocol, also use the RawRepresentable and _ErrorCodeProtocol
     // conformances on the Code associated type witness.
     if (auto codeType = ProtocolConformanceRef::getTypeWitnessByName(
-                          type, *conformance, Context.Id_Code, this)) {
+                          type, *conformance, Context.Id_Code)) {
       (void)conformsToProtocol(codeType, errorCodeProto, dc,
                                ConformanceCheckFlags::Used);
       (void)conformsToProtocol(codeType, rawProto, dc,
@@ -4341,7 +4341,7 @@ void TypeChecker::useBridgedNSErrorConformances(DeclContext *dc, Type type) {
                       ConformanceCheckFlags::Used));
   if (conformance && conformance->isConcrete()) {
     if (Type errorType = ProtocolConformanceRef::getTypeWitnessByName(
-          type, *conformance, Context.Id_ErrorType, this)) {
+          type, *conformance, Context.Id_ErrorType)) {
       (void)conformsToProtocol(errorType, bridgedStoredNSError, dc,
                                ConformanceCheckFlags::Used);
     }
@@ -5663,8 +5663,7 @@ Type TypeChecker::getWitnessType(Type type, ProtocolDecl *protocol,
                                  ProtocolConformanceRef conformance,
                                  Identifier name,
                                  Diag<> brokenProtocolDiag) {
-  Type ty = ProtocolConformanceRef::getTypeWitnessByName(type, conformance,
-                                                         name, this);
+  Type ty = ProtocolConformanceRef::getTypeWitnessByName(type, conformance, name);
   if (!ty &&
       !(conformance.isConcrete() && conformance.getConcrete()->isInvalid()))
     diagnose(protocol->getLoc(), brokenProtocolDiag);
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -228,8 +228,13 @@ Type TypeResolution::resolveDependentMemberType(
   auto lazyResolver = ctx.getLazyResolver();
   if (lazyResolver)
     lazyResolver->resolveDeclSignature(concrete);
-  if (!concrete->hasInterfaceType())
+  if (!concrete->hasInterfaceType()) {
+    ctx.Diags.diagnose(ref->getIdLoc(), diag::recursive_decl_reference,
+                       concrete->getDescriptiveKind(), concrete->getName());
+    concrete->diagnose(diag::kind_declared_here,
+                       DescriptiveDeclKind::Type);
     return ErrorType::get(ctx);
+  }
 
   // Make sure that base type didn't get replaced along the way.
   assert(baseTy->isTypeParameter());
diff --git a/test/decl/typealias/protocol.swift b/test/decl/typealias/protocol.swift
@@ -144,17 +144,15 @@ protocol P3 {
 
 // Test for not crashing on recursive aliases
 protocol Circular {
-  typealias Y = Self.Y // expected-error {{'Y' is not a member type of 'Self'}}
+  typealias Y = Self.Y // expected-error {{type alias 'Y' references itself}}
+  // expected-note@-1 {{type declared here}}
 
   typealias Y2 = Y2 // expected-error {{type alias 'Y2' references itself}}
   // expected-note@-1 {{type declared here}}
-  // expected-note@-2 {{did you mean 'Y2'?}}
 
   typealias Y3 = Y4 // expected-note {{type declared here}}
-  // expected-note@-1 {{did you mean 'Y3'?}}
 
   typealias Y4 = Y3 // expected-error {{type alias 'Y3' references itself}}
-  // expected-note@-1 {{did you mean 'Y4'?}}
 }
 
 // Qualified and unqualified references to protocol typealiases from concrete type
