Merge pull request #6321 from slavapestov/typealias-underlying-interface-type

Change the underlying type of TypeAliasDecls to an interface type

Author: slavapestov

include/swift/AST/Decl.h

@@ -72,6 +72,7 @@ namespace swift {
   class TypeAliasDecl;
   class Stmt;
   class SubscriptDecl;
+  class UnboundGenericType;
   class ValueDecl;
   class VarDecl;
 
@@ -413,9 +414,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     friend class TypeAliasDecl;
     unsigned : NumGenericTypeDeclBits;
 
-    /// Whether the underlying type is an interface type that will be lazily
-    /// resolved to a context type.
-    unsigned HasInterfaceUnderlyingType : 1;
+    /// Whether we have completed validation of the typealias.
+    /// This is necessary because unlike other declarations, a
+    /// typealias will not get an interface type right away.
+    unsigned HasCompletedValidation : 1;
   };
   enum { NumTypeAliasDeclBits = NumGenericTypeDeclBits + 1 };
   static_assert(NumTypeAliasDeclBits <= 32, "fits in an unsigned");
@@ -2391,60 +2393,38 @@ class GenericTypeDecl : public TypeDecl, public DeclContext {
 /// TypeAliasDecl's always have 'MetatypeType' type.
 ///
 class TypeAliasDecl : public GenericTypeDecl {
-  /// The type that represents this (sugared) name alias.
-  mutable NameAliasType *AliasTy;
-
   SourceLoc TypeAliasLoc;           // The location of the 'typealias' keyword
-  mutable TypeLoc UnderlyingTy;
-
-  Type computeUnderlyingContextType() const;
+  TypeLoc UnderlyingTy;
 
 public:
   TypeAliasDecl(SourceLoc TypeAliasLoc, Identifier Name,
-                SourceLoc NameLoc, TypeLoc UnderlyingTy,
-                GenericParamList *GenericParams, DeclContext *DC);
+                SourceLoc NameLoc, GenericParamList *GenericParams,
+                DeclContext *DC);
 
   SourceLoc getStartLoc() const { return TypeAliasLoc; }
   SourceRange getSourceRange() const;
 
-  /// getUnderlyingType - Returns the underlying type, which is
-  /// assumed to have been set.
-  Type getUnderlyingType() const {
-    if (TypeAliasDeclBits.HasInterfaceUnderlyingType)
-      return computeUnderlyingContextType();
-
-    assert(!UnderlyingTy.getType().isNull() &&
-           "getting invalid underlying type");
-    return UnderlyingTy.getType();
-  }
-
-  /// computeType - Compute the type (and declared type) of this type alias;
-  /// can only be called after the alias type has been resolved.
-  void computeType();
-
-  /// \brief Determine whether this type alias has an underlying type.
-  bool hasUnderlyingType() const {
-    return !UnderlyingTy.getType().isNull();
-  }
-
   TypeLoc &getUnderlyingTypeLoc() {
-    if (TypeAliasDeclBits.HasInterfaceUnderlyingType)
-      (void)computeUnderlyingContextType();
-
     return UnderlyingTy;
   }
   const TypeLoc &getUnderlyingTypeLoc() const {
-    if (TypeAliasDeclBits.HasInterfaceUnderlyingType)
-      (void)computeUnderlyingContextType();
-
     return UnderlyingTy;
   }
 
-  /// Set the underlying type after deserialization.
-  void setDeserializedUnderlyingType(Type type);
+  /// Set the underlying type, for deserialization and synthesized
+  /// aliases.
+  void setUnderlyingType(Type type);
+
+  bool hasCompletedValidation() const {
+    return TypeAliasDeclBits.HasCompletedValidation;
+  }
+
+  void setHasCompletedValidation() {
+    TypeAliasDeclBits.HasCompletedValidation = 1;
+  }
 
-  /// getAliasType - Return the sugared version of this decl as a Type.
-  NameAliasType *getAliasType() const { return AliasTy; }
+  /// For generic typealiases, return the unbound generic type.
+  UnboundGenericType *getUnboundGenericType() const;
 
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::TypeAlias;
@@ -4164,10 +4144,7 @@ class VarDecl : public AbstractStorageDecl {
   /// This is the type specified, including location information.
   TypeLoc typeLoc;
 
-  mutable Type typeInContext;
-
-  /// Compute the type in context from the interface type.
-  Type computeTypeInContextSlow() const;
+  Type typeInContext;
 
 public:
   VarDecl(bool IsStatic, bool IsLet, SourceLoc NameLoc, Identifier Name,
@@ -4190,15 +4167,13 @@ class VarDecl : public AbstractStorageDecl {
   bool hasType() const {
     // We have a type if either the type has been computed already or if
     // this is a deserialized declaration with an interface type.
-    return typeInContext ||
-      (hasInterfaceType() && !getDeclContext()->getParentSourceFile());
+    return !typeInContext.isNull();
   }
 
   /// Get the type of the variable within its context. If the context is generic,
   /// this will use archetypes.
   Type getType() const {
-    if (!typeInContext)
-      return computeTypeInContextSlow();
+    assert(!typeInContext.isNull() && "no contextual type set yet");
     return typeInContext;
   }
 
@@ -4414,7 +4389,7 @@ class ParamDecl : public VarDecl {
   /// type wrapping it.
   Type getVarargBaseTy() const {
     assert(isVariadic());
-    return getVarargBaseTy(getType());
+    return getVarargBaseTy(getInterfaceType());
   }
 
   SourceRange getSourceRange() const;

lib/AST/ASTContext.cpp

@@ -3661,7 +3661,7 @@ static NominalTypeDecl *findUnderlyingTypeInModule(ASTContext &ctx,
     if (auto typealias = dyn_cast<TypeAliasDecl>(result)) {
       if (auto resolver = ctx.getLazyResolver())
         resolver->resolveDeclSignature(typealias);
-      return typealias->getUnderlyingType()->getAnyNominal();
+      return typealias->getDeclaredInterfaceType()->getAnyNominal();
     }
   }
 

lib/AST/ASTDumper.cpp

@@ -460,8 +460,8 @@ namespace {
     void visitTypeAliasDecl(TypeAliasDecl *TAD) {
       printCommon(TAD, "typealias");
       OS << " type='";
-      if (TAD->hasUnderlyingType())
-        OS << TAD->getUnderlyingType().getString();
+      if (TAD->getUnderlyingTypeLoc().getType())
+        OS << TAD->getUnderlyingTypeLoc().getType().getString();
       else
         OS << "<<<unresolved>>>";
       printInherited(TAD->getInherited());

lib/AST/ASTMangler.cpp

@@ -454,7 +454,7 @@ void ASTMangler::appendType(Type type) {
       TypeAliasDecl *decl = NameAliasTy->getDecl();
       if (decl->getModuleContext() == decl->getASTContext().TheBuiltinModule) {
         // It's not possible to mangle the context of the builtin module.
-        return appendType(decl->getUnderlyingType());
+        return appendType(decl->getDeclaredInterfaceType());
       }
 
       // For the DWARF output we want to mangle the type alias + context,

lib/AST/ASTPrinter.cpp

@@ -2141,9 +2141,8 @@ void PrintAST::visitTypeAliasDecl(TypeAliasDecl *decl) {
           printGenericSignature(genericSig, PrintParams | InnermostOnly);
     });
   bool ShouldPrint = true;
-  Type Ty;
-  if (decl->hasUnderlyingType())
-    Ty = decl->getUnderlyingType();
+  Type Ty = decl->getUnderlyingTypeLoc().getType();
+
   // If the underlying type is private, don't print it.
   if (Options.SkipPrivateStdlibDecls && Ty && Ty.isPrivateStdlibType())
     ShouldPrint = false;
@@ -2338,11 +2337,11 @@ void PrintAST::visitVarDecl(VarDecl *decl) {
     [&]{
       Printer.printName(decl->getName());
     });
-  if (decl->hasType()) {
+  if (decl->hasInterfaceType()) {
     Printer << ": ";
     auto tyLoc = decl->getTypeLoc();
     if (!tyLoc.getTypeRepr())
-      tyLoc = TypeLoc::withoutLoc(decl->getType());
+      tyLoc = TypeLoc::withoutLoc(decl->getInterfaceType());
     printTypeLoc(tyLoc);
   }
 
@@ -2395,12 +2394,8 @@ void PrintAST::printOneParameter(const ParamDecl *param,
 
   printArgName();
 
-  if (!TheTypeLoc.getTypeRepr() && param->hasType()) {
-    // FIXME: ParamDecls should have interface types instead
-    auto *DC = Current->getInnermostDeclContext();
-    auto type = ArchetypeBuilder::mapTypeOutOfContext(DC, param->getType());
-    TheTypeLoc = TypeLoc::withoutLoc(type);
-  }
+  if (!TheTypeLoc.getTypeRepr() && param->hasInterfaceType())
+    TheTypeLoc = TypeLoc::withoutLoc(param->getInterfaceType());
 
   // If the parameter is variadic, we will print the "..." after it, but we have
   // to strip off the added array type.

lib/AST/ASTVerifier.cpp

@@ -1704,15 +1704,15 @@ struct ASTNodeBase {};
 
       // Variables must have materializable type, unless they are parameters,
       // in which case they must either have l-value type or be anonymous.
-      if (!var->getType()->isMaterializable()) {
+      if (!var->getInterfaceType()->isMaterializable()) {
         if (!isa<ParamDecl>(var)) {
           Out << "Non-parameter VarDecl has non-materializable type: ";
           var->getType().print(Out);
           Out << "\n";
           abort();
         }
 
-        if (!var->getType()->is<InOutType>() && var->hasName()) {
+        if (!var->getInterfaceType()->is<InOutType>() && var->hasName()) {
           Out << "ParamDecl may only have non-materializable tuple type "
                  "when it is anonymous: ";
           var->getType().print(Out);
@@ -1724,15 +1724,15 @@ struct ASTNodeBase {};
       // The fact that this is *directly* be a reference storage type
       // cuts the code down quite a bit in getTypeOfReference.
       if (var->getAttrs().hasAttribute<OwnershipAttr>() !=
-          isa<ReferenceStorageType>(var->getType().getPointer())) {
+          isa<ReferenceStorageType>(var->getInterfaceType().getPointer())) {
         if (var->getAttrs().hasAttribute<OwnershipAttr>()) {
           Out << "VarDecl has an ownership attribute, but its type"
                  " is not a ReferenceStorageType: ";
         } else {
           Out << "VarDecl has no ownership attribute, but its type"
                  " is a ReferenceStorageType: ";
         }
-        var->getType().print(Out);
+        var->getInterfaceType().print(Out);
         abort();
       }
 

lib/AST/ArchetypeBuilder.cpp

@@ -413,19 +413,14 @@ auto ArchetypeBuilder::PotentialArchetype::getNestedType(
         // Resolve this nested type to this type alias.
         pa = new PotentialArchetype(this, alias);
 
-        if (!alias->hasUnderlyingType())
+        if (!alias->hasInterfaceType())
           builder.getLazyResolver()->resolveDeclSignature(alias);
-        if (!alias->hasUnderlyingType())
+        if (!alias->hasInterfaceType())
           continue;
 
-        auto type = alias->getUnderlyingType();
+        auto type = alias->getDeclaredInterfaceType();
         SmallVector<Identifier, 4> identifiers;
 
-        // Map the type out of its context.
-        if (auto genericEnv = alias->getGenericEnvironmentOfContext()) {
-          type = genericEnv->mapTypeOutOfContext(type);
-        }
-
         if (auto existingPA = builder.resolveArchetype(type)) {
           builder.addSameTypeRequirementBetweenArchetypes(pa, existingPA,
                                                           redundantSource);

lib/AST/Builtins.cpp

@@ -153,6 +153,7 @@ getBuiltinFunction(Identifier Id, ArrayRef<Type> argTypes, Type ResType,
                                       Identifier(), SourceLoc(),
                                       Identifier(), argType,
                                       DC);
+    PD->setInterfaceType(argType);
     PD->setImplicit();
     params.push_back(PD);
   }
@@ -204,10 +205,13 @@ getBuiltinGenericFunction(Identifier Id,
   DeclContext *DC = &M->getMainFile(FileUnitKind::Builtin);
 
   SmallVector<ParamDecl*, 4> params;
-  for (auto paramType : ArgBodyTypes) {
+  for (unsigned i = 0, e = ArgParamTypes.size(); i < e; i++) {
+    auto paramType = ArgBodyTypes[i];
+    auto paramIfaceType = ArgParamTypes[i].getType();
     auto PD = new (Context) ParamDecl(/*IsLet*/true, SourceLoc(), SourceLoc(),
                                       Identifier(), SourceLoc(),
                                       Identifier(), paramType, DC);
+    PD->setInterfaceType(paramIfaceType);
     PD->setImplicit();
     params.push_back(PD);
   }