Merge pull request swiftlang#24333 from slavapestov/small-conformance-cleanups

slavapestov · web-flow · commit a5a902accde8 · 2019-04-27T12:11:45.000-04:00
Small conformance checking-related cleanups
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -3058,14 +3058,22 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
     return cast<ProtocolDecl>(getDeclContext());
   }
 
+  /// Check if we have a default definition type.
+  bool hasDefaultDefinitionType() const {
+    // If we have a TypeRepr, return true immediately without kicking off
+    // a request.
+    return !DefaultDefinition.isNull() || getDefaultDefinitionType();
+  }
+
   /// Retrieve the default definition type.
-  Type getDefaultDefinitionType() const {
-    return getDefaultDefinitionLoc().getType();
+  Type getDefaultDefinitionType() const;
+
+  TypeLoc &getDefaultDefinitionLoc() {
+    return DefaultDefinition;
   }
 
-  TypeLoc &getDefaultDefinitionLoc();
   const TypeLoc &getDefaultDefinitionLoc() const {
-    return const_cast<AssociatedTypeDecl *>(this)->getDefaultDefinitionLoc();
+    return DefaultDefinition;
   }
 
   /// Retrieve the trailing where clause for this associated type, if any.
@@ -3076,7 +3084,7 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
     TrailingWhere = trailingWhereClause;
   }
 
-  /// Set the interface type of this associated type declaration to a dependen
+  /// Set the interface type of this associated type declaration to a dependent
   /// member type of 'Self'.
   void computeType();
 
diff --git a/include/swift/AST/LazyResolver.h b/include/swift/AST/LazyResolver.h
@@ -159,8 +159,8 @@ class alignas(void*) LazyMemberLoader {
                       SmallVectorImpl<ProtocolConformance *> &Conformances) = 0;
 
   /// Returns the default definition type for \p ATD.
-  virtual TypeLoc loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
-                                            uint64_t contextData) = 0;
+  virtual Type loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
+                                         uint64_t contextData) = 0;
 
   /// Returns the generic environment.
   virtual GenericEnvironment *loadGenericEnvironment(const DeclContext *decl,
diff --git a/include/swift/Serialization/ModuleFile.h b/include/swift/Serialization/ModuleFile.h
@@ -827,8 +827,8 @@ class ModuleFile
   loadAllConformances(const Decl *D, uint64_t contextData,
                     SmallVectorImpl<ProtocolConformance*> &Conforms) override;
 
-  virtual TypeLoc loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
-                                            uint64_t contextData) override;
+  virtual Type loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
+                                         uint64_t contextData) override;
 
   virtual void finishNormalConformance(NormalProtocolConformance *conformance,
                                        uint64_t contextData) override;
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -2321,9 +2321,9 @@ void PrintAST::visitAssociatedTypeDecl(AssociatedTypeDecl *decl) {
     printInherited(decl);
   }
 
-  if (!decl->getDefaultDefinitionLoc().isNull()) {
+  if (decl->hasDefaultDefinitionType()) {
     Printer << " = ";
-    decl->getDefaultDefinitionLoc().getType().print(Printer, Options);
+    decl->getDefaultDefinitionType().print(Printer, Options);
   }
 
   // As with protocol's trailing where clauses, use the requirement signature
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -3526,13 +3526,14 @@ void AssociatedTypeDecl::computeType() {
   setInterfaceType(MetatypeType::get(interfaceTy, ctx));
 }
 
-TypeLoc &AssociatedTypeDecl::getDefaultDefinitionLoc() {
+Type AssociatedTypeDecl::getDefaultDefinitionType() const {
   if (Resolver) {
-    DefaultDefinition =
-      Resolver->loadAssociatedTypeDefault(this, ResolverContextData);
-    Resolver = nullptr;
+    const_cast<AssociatedTypeDecl *>(this)->DefaultDefinition
+      = TypeLoc::withoutLoc(
+        Resolver->loadAssociatedTypeDefault(this, ResolverContextData));
+    const_cast<AssociatedTypeDecl *>(this)->Resolver = nullptr;
   }
-  return DefaultDefinition;
+  return DefaultDefinition.getType();
 }
 
 SourceRange AssociatedTypeDecl::getSourceRange() const {
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
@@ -4282,7 +4282,7 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
         source->kind == RequirementSource::RequirementSignatureSelf &&
         !assocTypeDecl->getAttrs().hasAttribute<NonOverrideAttr>() &&
         !assocTypeDecl->getAttrs().hasAttribute<OverrideAttr>() &&
-        assocTypeDecl->getDefaultDefinitionLoc().isNull() &&
+        !assocTypeDecl->hasDefaultDefinitionType() &&
         (!assocTypeDecl->getInherited().empty() ||
          assocTypeDecl->getTrailingWhereClause() ||
          getASTContext().LangOpts.WarnImplicitOverrides);
diff --git a/lib/ClangImporter/ImporterImpl.h b/lib/ClangImporter/ImporterImpl.h
@@ -1261,8 +1261,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
                                uint64_t unused) override;
   
   /// Returns the default definition type for \p ATD.
-  TypeLoc loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
-                                            uint64_t contextData) override {
+  Type loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
+                                 uint64_t contextData) override {
     llvm_unreachable("unimplemented for ClangImporter");
   }
   
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -4360,7 +4360,7 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
           continue;
         // FIXME: Also exclude the type alias that has already been specified.
         if (!Conformance->hasTypeWitness(ATD) ||
-            !ATD->getDefaultDefinitionLoc().isNull())
+            ATD->hasDefaultDefinitionType())
           continue;
         addTypeAlias(ATD,
           DeclVisibilityKind::MemberOfProtocolImplementedByCurrentNominal);
diff --git a/lib/Sema/DerivedConformanceCodable.cpp b/lib/Sema/DerivedConformanceCodable.cpp
@@ -83,14 +83,7 @@ static CodableConformanceType typeConformsToCodable(TypeChecker &tc,
                                                     DeclContext *context,
                                                     Type target, bool isIUO,
                                                     ProtocolDecl *proto) {
-  target = context->mapTypeIntoContext(target->mapTypeOutOfContext());
-  // Some generic types need to be introspected to get at their "true" Codable
-  // conformance.
-  if (auto referenceType = target->getAs<ReferenceStorageType>()) {
-    // This is a weak/unowned/unmanaged var. Get the inner type before checking
-    // conformance.
-    target = referenceType->getReferentType();
-  }
+  target = context->mapTypeIntoContext(target);
 
   if (isIUO)
     return typeConformsToCodable(tc, context, target->getOptionalObjectType(),
@@ -129,17 +122,18 @@ static CodableConformanceType varConformsToCodable(TypeChecker &tc,
   // }
   //
   // Validate the decl eagerly.
-  if (!varDecl->hasType())
+  if (!varDecl->hasInterfaceType())
     tc.validateDecl(varDecl);
 
   // If the var decl didn't validate, it may still not have a type; confirm it
   // has a type before ensuring the type conforms to Codable.
-  if (!varDecl->hasType())
+  if (!varDecl->hasInterfaceType())
     return TypeNotValidated;
 
   bool isIUO =
       varDecl->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>();
-  return typeConformsToCodable(tc, context, varDecl->getType(), isIUO, proto);
+  return typeConformsToCodable(tc, context, varDecl->getValueInterfaceType(),
+                               isIUO, proto);
 }
 
 /// Validates the given CodingKeys enum decl by ensuring its cases are a 1-to-1
@@ -522,8 +516,6 @@ static std::tuple<VarDecl *, Type, bool>
 lookupVarDeclForCodingKeysCase(DeclContext *conformanceDC,
                                EnumElementDecl *elt,
                                NominalTypeDecl *targetDecl) {
-  ASTContext &C = elt->getASTContext();
-
   for (auto decl : targetDecl->lookupDirect(DeclName(elt->getName()))) {
     if (auto *vd = dyn_cast<VarDecl>(decl)) {
       if (!vd->isStatic()) {
@@ -532,17 +524,11 @@ lookupVarDeclForCodingKeysCase(DeclContext *conformanceDC,
         auto varType =
             conformanceDC->mapTypeIntoContext(vd->getValueInterfaceType());
 
-        bool useIfPresentVariant =
-            varType->getAnyNominal() == C.getOptionalDecl();
-
-        if (useIfPresentVariant) {
-          // The type we request out of decodeIfPresent needs to be unwrapped
-          // one level.
-          // e.g. String? => decodeIfPresent(String.self, forKey: ...), not
-          //                 decodeIfPresent(String?.self, forKey: ...)
-          auto boundOptionalType =
-              dyn_cast<BoundGenericType>(varType->getCanonicalType());
-          varType = boundOptionalType->getGenericArgs()[0];
+        bool useIfPresentVariant = false;
+
+        if (auto objType = varType->getOptionalObjectType()) {
+          varType = objType;
+          useIfPresentVariant = true;
         }
 
         return std::make_tuple(vd, varType, useIfPresentVariant);
diff --git a/lib/Sema/DerivedConformanceEquatableHashable.cpp b/lib/Sema/DerivedConformanceEquatableHashable.cpp
@@ -50,7 +50,7 @@ static bool allAssociatedValuesConformToProtocol(DeclContext *DC,
       continue;
 
     for (auto param : *PL) {
-      auto type = param->getType()->mapTypeOutOfContext();
+      auto type = param->getInterfaceType();
       if (!TypeChecker::conformsToProtocol(DC->mapTypeIntoContext(type),
                                            protocol, DC,
                                            ConformanceCheckFlags::Used)) {
@@ -73,9 +73,9 @@ static bool allStoredPropertiesConformToProtocol(DeclContext *DC,
   auto storedProperties =
     theStruct->getStoredProperties(/*skipInaccessible=*/true);
   for (auto propertyDecl : storedProperties) {
-    if (!propertyDecl->hasType())
+    if (!propertyDecl->hasInterfaceType())
       lazyResolver->resolveDeclSignature(propertyDecl);
-    if (!propertyDecl->hasType())
+    if (!propertyDecl->hasInterfaceType())
       return false;
 
     auto type = propertyDecl->getValueInterfaceType();
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2700,8 +2700,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       checkEnumRawValues(TC, ED);
     }
 
-    ED->getAllConformances();
-
     TC.checkDeclCircularity(ED);
     TC.ConformanceContexts.push_back(ED);
   }
@@ -2725,8 +2723,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     checkAccessControl(TC, SD);
 
-    SD->getAllConformances();
-
     TC.checkDeclCircularity(SD);
     TC.ConformanceContexts.push_back(SD);
   }
@@ -2941,8 +2937,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
     }
 
-    CD->getAllConformances();
-
     TC.checkDeclAttributes(CD);
 
     checkInheritanceClause(CD);
@@ -3169,13 +3163,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       TC.checkDeclAttributes(ED);
 
     checkAccessControl(TC, ED);
-
-    // Trigger the creation of all of the conformances associated with this
-    // nominal type.
-    // FIXME: This is a hack to make sure that the type checker precomputes
-    // enough information for later passes that might query conformances.
-    if (auto nominal = ED->getExtendedNominal())
-      (void) nominal->getAllConformances();
   }
 
   void visitTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -2616,7 +2616,7 @@ printRequirementStub(ValueDecl *Requirement, DeclContext *Adopter,
     }
   }
   if (auto MissingTypeWitness = dyn_cast<AssociatedTypeDecl>(Requirement)) {
-    if (!MissingTypeWitness->getDefaultDefinitionLoc().isNull()) {
+    if (MissingTypeWitness->hasDefaultDefinitionType()) {
       // For type witnesses with default definitions, we don't print the stub.
       return false;
     }
diff --git a/lib/Sema/TypeCheckProtocolInference.cpp b/lib/Sema/TypeCheckProtocolInference.cpp
@@ -769,7 +769,7 @@ AssociatedTypeDecl *AssociatedTypeInference::findDefaultedAssociatedType(
                                              AssociatedTypeDecl *assocType) {
   // If this associated type has a default, we're done.
   tc.validateDecl(assocType);
-  if (!assocType->getDefaultDefinitionLoc().isNull())
+  if (assocType->hasDefaultDefinitionType())
     return assocType;
 
   // Look at overridden associated types.
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
@@ -334,10 +334,8 @@ static void typeCheckFunctionsAndExternalDecls(SourceFile &SF, TypeChecker &TC)
         TC.checkFunctionErrorHandling(AFD);
         continue;
       }
-      if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
-        (void)nominal->getAllConformances();
+      if (isa<NominalTypeDecl>(decl))
         continue;
-      }
       if (isa<VarDecl>(decl))
         continue;
       llvm_unreachable("Unhandled external definition kind");
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -5411,10 +5411,10 @@ ModuleFile::loadAllConformances(const Decl *D, uint64_t contextData,
   }
 }
 
-TypeLoc
+Type
 ModuleFile::loadAssociatedTypeDefault(const swift::AssociatedTypeDecl *ATD,
                                       uint64_t contextData) {
-  return TypeLoc::withoutLoc(getType(contextData));
+  return getType(contextData);
 }
 
 void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,

Original file line number	Diff line number	Diff line change
`@@ -2321,9 +2321,9 @@ void PrintAST::visitAssociatedTypeDecl(AssociatedTypeDecl *decl) {`
`2321`	`2321`	`printInherited(decl);`
`2322`	`2322`	`}`
`2323`	`2323`
`2324`		`- if (!decl->getDefaultDefinitionLoc().isNull()) {`
	`2324`	`+ if (decl->hasDefaultDefinitionType()) {`
`2325`	`2325`	`Printer << " = ";`
`2326`		`- decl->getDefaultDefinitionLoc().getType().print(Printer, Options);`
	`2326`	`+ decl->getDefaultDefinitionType().print(Printer, Options);`
`2327`	`2327`	`}`
`2328`	`2328`
`2329`	`2329`	`// As with protocol's trailing where clauses, use the requirement signature`
Original file line number	Diff line number	Diff line change
`@@ -3526,13 +3526,14 @@ void AssociatedTypeDecl::computeType() {`
`3526`	`3526`	`setInterfaceType(MetatypeType::get(interfaceTy, ctx));`
`3527`	`3527`	`}`
`3528`	`3528`
`3529`		`-TypeLoc &AssociatedTypeDecl::getDefaultDefinitionLoc() {`
	`3529`	`+Type AssociatedTypeDecl::getDefaultDefinitionType() const {`
`3530`	`3530`	`if (Resolver) {`
`3531`		`- DefaultDefinition =`
`3532`		`- Resolver->loadAssociatedTypeDefault(this, ResolverContextData);`
`3533`		`- Resolver = nullptr;`
	`3531`	`+ const_cast<AssociatedTypeDecl *>(this)->DefaultDefinition`
	`3532`	`+ = TypeLoc::withoutLoc(`
	`3533`	`+ Resolver->loadAssociatedTypeDefault(this, ResolverContextData));`
	`3534`	`+ const_cast<AssociatedTypeDecl *>(this)->Resolver = nullptr;`
`3534`	`3535`	`}`
`3535`		`- return DefaultDefinition;`
	`3536`	`+ return DefaultDefinition.getType();`
`3536`	`3537`	`}`
`3537`	`3538`
`3538`	`3539`	`SourceRange AssociatedTypeDecl::getSourceRange() const {`
Original file line number	Diff line number	Diff line change
`@@ -1261,8 +1261,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation`
`1261`	`1261`	`uint64_t unused) override;`
`1262`	`1262`
`1263`	`1263`	`/// Returns the default definition type for \p ATD.`
`1264`		`- TypeLoc loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,`
`1265`		`- uint64_t contextData) override {`
	`1264`	`+ Type loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,`
	`1265`	`+ uint64_t contextData) override {`
`1266`	`1266`	`llvm_unreachable("unimplemented for ClangImporter");`
`1267`	`1267`	`}`
`1268`	`1268`