Split parsing for typealias & associatedtype, and allow typealias in protocols.

Split up parsing of typealias and associatedtype, including dropping a
now unneeded ParseDeclOptions flag.

Then made typealias in a protocol valid, and act like you would
hope for protocol conformance purposes (i.e. as an alias possibly
involved in the types of other func/var conformances, not as a hidden
generic param in itself).

Also added support for simple type aliases in generic constraints. Aliases
to simple (non-sugared) archetype types (and also - trivially - aliases to
concrete types) can now be part of same-type constraints.

The strategy here is to add type aliases to the tree of
PotentialArchetypes, and if they are an alias to an archetype, also to
immediately find the real associated type and set it as the
representative for the PA. Thus the typealias PA node becomes just a
shortcut farther down into the tree for purposes of lookup and
generating same type requirements.

Then the typealias PA nodes need to be explicitly skipped when walking
the tree for building archetype types and other types of requirements,
in order to keep from getting extra out-of-order archetypes/witness
markers of the real associated type inserted where the typealias is
defined.

Any constraint with a typealias more complex than pointing to a single
nested associated type (e.g. `typealias T = A.B.C.D`), will now get a
specialized diagnoses.

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

@@ -280,6 +280,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,
@@ -756,8 +758,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

@@ -646,15 +646,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.
@@ -690,9 +689,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();