Merge pull request #1610 from gregomni/typealias

[Parse/AST/Sema] Split parsing for typealias & associatedtype, allow typealias in protocols and generic constraints

Author: gregomni

include/swift/AST/ArchetypeBuilder.h

@@ -387,8 +387,10 @@ class ArchetypeBuilder::PotentialArchetype {
 
   /// \brief The name of this potential archetype or, for an
   /// associated type, the declaration of the associated type to which
-  /// this potential archetype has been resolved.
-  llvm::PointerUnion<Identifier, AssociatedTypeDecl *> NameOrAssociatedType;
+  /// this potential archetype has been resolved. Or, for a type alias,
+  /// the type alias decl.
+  llvm::PointerUnion3<Identifier, AssociatedTypeDecl *,
+                      TypeAliasDecl *> NameOrAssociatedType;
 
   /// \brief The representative of the equivalent class of potential archetypes
   /// to which this potential archetype belongs.
@@ -466,6 +468,17 @@ class ArchetypeBuilder::PotentialArchetype {
     EquivalenceClass.push_back(this);
   }
 
+  /// \brief Construct a new potential archetype for a type alias.
+  PotentialArchetype(PotentialArchetype *Parent, TypeAliasDecl *TypeAlias)
+    : ParentOrParam(Parent), NameOrAssociatedType(TypeAlias),
+      Representative(this), IsRecursive(false), Invalid(false),
+      SubstitutingConcreteType(false), RecursiveConcreteType(false),
+      RecursiveSuperclassType(false), Renamed(false)
+  {
+    assert(Parent != nullptr && "Not an associated type?");
+    EquivalenceClass.push_back(this);
+  }
+
   /// \brief Construct a new potential archetype for a generic parameter.
   PotentialArchetype(GenericTypeParamType *GenericParam, 
                      ProtocolDecl *RootProtocol,
@@ -524,6 +537,11 @@ class ArchetypeBuilder::PotentialArchetype {
   GenericTypeParamType *getGenericParam() const {
     return ParentOrParam.dyn_cast<GenericTypeParamType *>(); 
   }
+  
+  /// Retrieve the type alias.
+  TypeAliasDecl *getTypeAliasDecl() const {
+    return NameOrAssociatedType.dyn_cast<TypeAliasDecl *>();
+  }
 
   /// Retrieve the set of protocols to which this type conforms.
   const llvm::MapVector<ProtocolDecl *, RequirementSource> &

include/swift/AST/DiagnosticsParse.def

@@ -283,6 +283,8 @@ ERROR(expected_equal_in_typealias,PointsToFirstBadToken,
       "expected '=' in typealias declaration", ())
 ERROR(expected_type_in_typealias,PointsToFirstBadToken,
       "expected type in typealias declaration", ())
+ERROR(expected_type_in_associatedtype,PointsToFirstBadToken,
+      "expected type in associatedtype declaration", ())
 ERROR(associated_type_generic_parameter_list,PointsToFirstBadToken,
       "associated types may not have a generic parameter list", ())
 ERROR(typealias_generic_list_constraint,PointsToFirstBadToken,
@@ -759,8 +761,8 @@ ERROR(expected_close_after_else_directive,none,
       "further conditions after #else are unreachable", ())
 
 /// Associatedtype Statement
-WARNING(typealias_inside_protocol,none,
-        "use of 'typealias' to declare associated types is deprecated; use 'associatedtype' instead", ())
+ERROR(typealias_inside_protocol_without_type,none,
+      "typealias is missing an assigned type; use 'associatedtype' to define an associated type requirement", ())
 ERROR(associatedtype_outside_protocol,none,
       "associated types can only be defined in a protocol; define a type or introduce a 'typealias' to satisfy an associated type requirement", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -468,6 +468,9 @@ ERROR(invalid_member_type,none,
 ERROR(invalid_member_type_suggest,none,
       "%0 does not have a member type named %1; did you mean %2?",
       (Type, Identifier, Identifier))
+ERROR(invalid_member_type_alias,none,
+      "typealias %0 is too complex to be used as a generic constraint; "
+      "use an associatedtype instead", (Identifier))
 ERROR(ambiguous_member_type,none,
       "ambiguous type name %0 in %1", (Identifier, Type))
 ERROR(no_module_type,none,

include/swift/Parse/Parser.h

@@ -657,15 +657,14 @@ class Parser {
     PD_HasContainerType     = 1 << 2,
     PD_DisallowNominalTypes = 1 << 3,
     PD_DisallowInit         = 1 << 4,
-    PD_DisallowTypeAliasDef = 1 << 5,
-    PD_AllowDestructor      = 1 << 6,
-    PD_AllowEnumElement     = 1 << 7,
-    PD_InProtocol           = 1 << 8,
-    PD_InClass              = 1 << 9,
-    PD_InExtension          = 1 << 10,
-    PD_InStruct             = 1 << 11,
-    PD_InEnum               = 1 << 12,
-    PD_InLoop               = 1 << 13
+    PD_AllowDestructor      = 1 << 5,
+    PD_AllowEnumElement     = 1 << 6,
+    PD_InProtocol           = 1 << 7,
+    PD_InClass              = 1 << 8,
+    PD_InExtension          = 1 << 9,
+    PD_InStruct             = 1 << 10,
+    PD_InEnum               = 1 << 11,
+    PD_InLoop               = 1 << 12
   };
 
   /// Options that control the parsing of declarations.
@@ -701,9 +700,11 @@ class Parser {
   ParserStatus parseDecl(SmallVectorImpl<Decl*> &Entries, ParseDeclOptions Flags);
   void parseDeclDelayed();
 
-  ParserResult<TypeDecl> parseDeclTypeAlias(bool WantDefinition,
-                                            bool isAssociatedType,
+  ParserResult<TypeDecl> parseDeclTypeAlias(ParseDeclOptions Flags,
                                             DeclAttributes &Attributes);
+
+  ParserResult<TypeDecl> parseDeclAssociatedType(ParseDeclOptions Flags,
+                                                 DeclAttributes &Attributes);
 
   ParserResult<IfConfigDecl> parseDeclIfConfig(ParseDeclOptions Flags);
   /// Parse a #line/#setline directive.

include/swift/SIL/SILWitnessVisitor.h

@@ -100,6 +100,10 @@ template <class T> class SILWitnessVisitor : public ASTVisitor<T> {
     ProtocolType::canonicalizeProtocols(protos);
     asDerived().addAssociatedType(td, protos);
   }
+    
+  void visitTypeAliasDecl(TypeAliasDecl *tad) {
+    // We don't care about these by themselves for witnesses.
+  }
 
   void visitPatternBindingDecl(PatternBindingDecl *pbd) {
     // We only care about the contained VarDecls.

lib/AST/ASTVerifier.cpp

@@ -1781,6 +1781,10 @@ struct ASTNodeBase {};
             .verifyChecked(replacementType);
           continue;
         }
+          
+        // No witness necessary for type aliases
+        if (isa<TypeAliasDecl>(member))
+          continue;
 
         // If this is an accessor for something, ignore it.
         if (auto *FD = dyn_cast<FuncDecl>(member))

lib/AST/ArchetypeBuilder.cpp

@@ -219,7 +219,8 @@ void ArchetypeBuilder::PotentialArchetype::buildFullName(
 Identifier ArchetypeBuilder::PotentialArchetype::getName() const { 
   if (auto assocType = NameOrAssociatedType.dyn_cast<AssociatedTypeDecl *>())
     return assocType->getName();
-  
+  if (auto typeAlias = NameOrAssociatedType.dyn_cast<TypeAliasDecl *>())
+    return typeAlias->getName();
   return NameOrAssociatedType.get<Identifier>();
 }
 
@@ -303,12 +304,12 @@ static void maybeAddSameTypeRequirementForNestedType(
               RequirementSource fromSource,
               ProtocolConformance *superConformance,
               ArchetypeBuilder &builder) {
-  auto assocType = nestedPA->getResolvedAssociatedType();
-  assert(assocType && "Not resolved to an associated type?");
-
   // If there's no super conformance, we're done.
   if (!superConformance) return;
 
+  auto assocType = nestedPA->getResolvedAssociatedType();
+  assert(assocType && "Not resolved to an associated type?");
+
   // Dig out the type witness.
   auto concreteType =
     superConformance->getTypeWitness(assocType, builder.getLazyResolver())
@@ -467,20 +468,73 @@ auto ArchetypeBuilder::PotentialArchetype::getNestedType(
   // archetype conforms.
   for (auto &conforms : ConformsTo) {
     for (auto member : conforms.first->lookupDirect(nestedName)) {
-      auto assocType = dyn_cast<AssociatedTypeDecl>(member);
-      if (!assocType)
+      PotentialArchetype *pa;
+      
+      if (auto assocType = dyn_cast<AssociatedTypeDecl>(member)) {
+        // Resolve this nested type to this associated type.
+        pa = new PotentialArchetype(this, assocType);
+      } else if (auto alias = dyn_cast<TypeAliasDecl>(member)) {
+        // Resolve this nested type to this type alias.
+        pa = new PotentialArchetype(this, alias);
+        
+        if (!alias->hasUnderlyingType())
+          builder.getLazyResolver()->resolveDeclSignature(alias);
+        if (!alias->hasUnderlyingType())
+          continue;
+
+        auto type = alias->getUnderlyingType();
+        if (auto archetype = type->getAs<ArchetypeType>()) {
+          auto containingProtocol = cast<ProtocolDecl>(alias->getParent());
+          SmallVector<Identifier, 4> identifiers;
+          
+          // Go up archetype parents until we find our containing protocol.
+          while (archetype->getSelfProtocol() != containingProtocol) {
+            identifiers.push_back(archetype->getName());
+            archetype = archetype->getParent();
+            if (!archetype)
+              break;
+          }
+          if (!archetype)
+            continue;
+          
+          // Go down our PAs until we find the referenced PA.
+          auto existingPA = this;
+          while(identifiers.size()) {
+            existingPA = existingPA->getNestedType(identifiers.back(), builder);
+            identifiers.pop_back();
+          }
+          pa->Representative = existingPA;
+          RequirementSource source(RequirementSource::Inferred, SourceLoc());
+          pa->SameTypeSource = source;
+        } else if (type->hasArchetype()) {
+          // This is a complex type involving other associatedtypes, we'll fail
+          // to resolve and get a special diagnosis in finalize.
+          continue;
+        } else {
+          pa->ArchetypeOrConcreteType = NestedType::forConcreteType(type);
+        }
+      } else
         continue;
 
-      // Resolve this nested type to this associated type.
-      auto pa = new PotentialArchetype(this, assocType);
-
       // If we have resolved this nested type to more than one associated
       // type, create same-type constraints between them.
       RequirementSource source(RequirementSource::Inferred, SourceLoc());
       if (!nested.empty()) {
-        pa->Representative = nested.front()->getRepresentative();
-        pa->Representative->EquivalenceClass.push_back(pa);
-        pa->SameTypeSource = source;
+        auto existing = nested.front();
+        if (auto alias = existing->getTypeAliasDecl()) {
+          // If we found a typealias first, and now have an associatedtype
+          // with the same name, it was a Swift 2 style declaration of the
+          // type an inherited associatedtype should be bound to. In such a
+          // case we want to make sure the associatedtype is frontmost to
+          // generate generics/witness lists correctly, and the alias
+          // will be unused/useless for generic constraining anyway.
+          alias->setInvalid();
+          nested.clear();
+        } else {
+          pa->Representative = existing->getRepresentative();
+          pa->Representative->EquivalenceClass.push_back(pa);
+          pa->SameTypeSource = source;
+        }
       }
 
       // Add this resolved nested type.
@@ -677,6 +731,9 @@ ArchetypeBuilder::PotentialArchetype::getType(ArchetypeBuilder &builder) {
     builder.getASTContext().registerLazyArchetype(arch, builder, this);
     SmallVector<std::pair<Identifier, NestedType>, 4> FlatNestedTypes;
     for (auto Nested : NestedTypes) {
+      // Skip type aliases, which are just shortcuts.
+      if (Nested.second.front()->getTypeAliasDecl())
+        continue;
       bool anyNotRenamed = false;
       for (auto NestedPA : Nested.second) {
         if (!NestedPA->wasRenamed()) {
@@ -1646,6 +1703,23 @@ bool ArchetypeBuilder::finalize(SourceLoc loc) {
           /* FIXME: Should be able to handle this earlier */pa->getSuperclass())
         return;
 
+      // If a typealias with this name exists in one of the parent protocols,
+      // give a special diagnosis.
+      auto parentConformances = pa->getParent()->getConformsTo();
+      for (auto &conforms : parentConformances) {
+        for (auto member : conforms.first->getMembers()) {
+          auto typealias = dyn_cast<TypeAliasDecl>(member);
+          if (!typealias || typealias->getName() != pa->getName())
+            continue;
+
+          Context.Diags.diagnose(loc, diag::invalid_member_type_alias,
+                                 pa->getName());
+          invalid = true;
+          pa->setInvalid();
+          return;
+        }
+      }
+      
       // Try to typo correct to a nested type name.
       Identifier correction = typoCorrectNestedType(pa);
       if (correction.empty()) {
@@ -1702,7 +1776,7 @@ ArrayRef<ArchetypeType *> ArchetypeBuilder::getAllArchetypes() {
         continue;
 
       PotentialArchetype *PA = Entry.second;
-      if (!PA->isConcreteType()) {
+      if (!PA->isConcreteType() && !PA->getTypeAliasDecl()) {
         auto Archetype = PA->getType(*this).castToArchetype();
         GenericParamList::addNestedArchetypes(Archetype, KnownArchetypes,
                                               Impl->AllArchetypes);
@@ -2105,6 +2179,9 @@ addNestedRequirements(
   for (const auto &nested : pa->getNestedTypes()) {
     // FIXME: Dropping requirements among different associated types of the
     // same name.
+    // Skip type aliases, which are just shortcuts down the tree.
+    if (nested.second.front()->getTypeAliasDecl())
+      continue;
     nestedTypes.push_back(std::make_pair(nested.first, nested.second.front()));
   }
   std::sort(nestedTypes.begin(), nestedTypes.end(),

lib/AST/Decl.cpp

@@ -1733,7 +1733,7 @@ Type TypeDecl::getDeclaredType() const {
 
 Type TypeDecl::getDeclaredInterfaceType() const {
   Type interfaceType = getInterfaceType();
-  if (interfaceType->is<ErrorType>())
+  if (interfaceType.isNull() || interfaceType->is<ErrorType>())
     return interfaceType;
 
   return interfaceType->castTo<MetatypeType>()->getInstanceType();