Merge pull request #6055 from slavapestov/param-decl-interface-types

AST: Assign interface types to ParamDecls

Author: slavapestov

include/swift/AST/Decl.h

@@ -4319,9 +4319,7 @@ class ParamDecl : public VarDecl {
   /// For a generic context, this also gives the parameter an unbound generic
   /// type with the expectation that type-checking will fill in the context
   /// generic parameters.
-  static ParamDecl *createUnboundSelf(SourceLoc loc, DeclContext *DC,
-                                      bool isStatic = false,
-                                      bool isInOut = false);
+  static ParamDecl *createUnboundSelf(SourceLoc loc, DeclContext *DC);
 
   /// Create an implicit 'self' decl for a method in the specified decl context.
   /// If 'static' is true, then this is self for a static method in the type.
@@ -4723,12 +4721,6 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
     return getParameterLists()[i];
   }
 
-  /// \brief If this is a method in a type or extension thereof, compute
-  /// and return the type to be used for the 'self' argument of the type, or an
-  /// empty Type() if no 'self' argument should exist.  This can
-  /// only be used after name binding has resolved types.
-  Type computeSelfType();
-
   /// \brief If this is a method in a type or extension thereof, compute
   /// and return the type to be used for the 'self' argument of the interface
   /// type, or an empty Type() if no 'self' argument should exist.  This can
@@ -4737,7 +4729,12 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
   /// \param isInitializingCtor Specifies whether we're computing the 'self'
   /// type of an initializing constructor, which accepts an instance 'self'
   /// rather than a metatype 'self'.
-  Type computeInterfaceSelfType(bool isInitializingCtor);
+  ///
+  /// \param wantDynamicSelf Specifies whether the 'self' type should be
+  /// wrapped in a DynamicSelfType, which is the case for the 'self' parameter
+  /// type inside a class method returning 'Self'.
+  Type computeInterfaceSelfType(bool isInitializingCtor=false,
+                                bool wantDynamicSelf=false);
 
   /// \brief This method returns the implicit 'self' decl.
   ///

include/swift/AST/DeclContext.h

@@ -289,12 +289,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// - Non-type contexts return a null type.
   Type getDeclaredInterfaceType() const;
 
-  /// Get the type of `self` in this context.
-  ///
-  /// - Protocol types return the `Self` archetype.
-  /// - Everything else falls back on getDeclaredTypeOfContext().
-  Type getSelfTypeOfContext() const;
-
   /// Get the type of `self` in this context.
   ///
   /// - Protocol types return the `Self` archetype.

include/swift/AST/ParameterList.h

@@ -73,9 +73,7 @@ class alignas(ParamDecl *) ParameterList final :
   /// DeclContext that needs to be set correctly.  This is automatically handled
   /// when a function is created with this as part of its argument list.
   ///
-  static ParameterList *createUnboundSelf(SourceLoc loc, DeclContext *DC,
-                                          bool isStaticMethod = false,
-                                          bool isInOut = false);
+  static ParameterList *createUnboundSelf(SourceLoc loc, DeclContext *DC);
 
   /// Create an implicit 'self' decl for a method in the specified decl context.
   /// If 'static' is true, then this is self for a static method in the type.

lib/AST/ASTDumper.cpp

@@ -756,13 +756,19 @@ namespace {
       if (!P->getArgumentName().empty())
         OS << " apiName=" << P->getArgumentName();
 
-      OS << " type=";
       if (P->hasType()) {
+        OS << " type=";
         OS << '\'';
         P->getType().print(OS);
         OS << '\'';
-      } else
-        OS << "<null type>";
+      }
+      
+      if (P->hasInterfaceType()) {
+        OS << " interface type=";
+        OS << '\'';
+        P->getInterfaceType().print(OS);
+        OS << '\'';
+      }
 
       if (!P->isLet())
         OS << " mutable";

lib/AST/ASTMangler.cpp

@@ -1382,13 +1382,7 @@ Type ASTMangler::getDeclTypeForMangling(const ValueDecl *decl,
   if (!decl->hasInterfaceType())
     return ErrorType::get(C)->getCanonicalType();
 
-  // FIXME: Interface types for ParamDecls
   Type type = decl->getInterfaceType();
-  if (type->hasArchetype()) {
-    assert(isa<ParamDecl>(decl));
-    type = ArchetypeBuilder::mapTypeOutOfContext(
-        decl->getDeclContext(), type);
-  }
 
   initialParamDepth = 0;
   CanGenericSignature sig;

lib/AST/ASTVerifier.cpp

@@ -414,7 +414,7 @@ struct ASTNodeBase {};
 
       // Check for type variables that escaped the type checker.
       if (type->hasTypeVariable()) {
-        Out << "a type variable escaped the type checker";
+        Out << "a type variable escaped the type checker\n";
         abort();
       }
 

lib/AST/Decl.cpp

@@ -1645,33 +1645,27 @@ ValueDecl::getSatisfiedProtocolRequirements(bool Sorted) const {
 }
 
 bool ValueDecl::hasInterfaceType() const {
-  // getInterfaceType() returns the contextual type for ParamDecls which
-  // don't have an explicit interface type.
-  if (auto *PD = dyn_cast<ParamDecl>(this))
-    return PD->hasType();
-
   return !!InterfaceTy;
 }
 
 Type ValueDecl::getInterfaceType() const {
-  if (InterfaceTy)
-    return InterfaceTy;
-
-  // FIXME: ParamDecls are funky and don't always have an interface type
-  if (auto *PD = dyn_cast<ParamDecl>(this))
-    return PD->getType();
-
-  llvm_unreachable("no interface type was set");
+  assert(InterfaceTy && "No interface type was set");
+  return InterfaceTy;
 }
 
 void ValueDecl::setInterfaceType(Type type) {
-  assert((type.isNull() || !type->hasTypeVariable()) &&
-         "Type variable in interface type");
-
   // lldb creates global typealiases with archetypes in them.
   // FIXME: Add an isDebugAlias() flag, like isDebugVar().
-  if (!isa<TypeAliasDecl>(this)) {
-    assert((type.isNull() || !type->hasArchetype()) &&
+  //
+  // Also, ParamDecls in closure contexts can have type variables
+  // archetype in them during constraint generation.
+  if (!type.isNull() &&
+      !isa<TypeAliasDecl>(this) &&
+      !(isa<ParamDecl>(this) &&
+        isa<AbstractClosureExpr>(getDeclContext()))) {
+    assert(!type->hasArchetype() &&
+           "Archetype in interface type");
+    assert(!type->hasTypeVariable() &&
            "Archetype in interface type");
   }
 
@@ -2174,8 +2168,7 @@ Type AbstractTypeParamDecl::getSuperclass() const {
   if (!dc->isValidGenericContext())
     return nullptr;
 
-  auto contextTy = ArchetypeBuilder::mapTypeIntoContext(
-      dc, getDeclaredInterfaceType());
+  auto contextTy = dc->mapTypeIntoContext(getDeclaredInterfaceType());
   if (auto *archetype = contextTy->getAs<ArchetypeType>())
     return archetype->getSuperclass();
 
@@ -2189,8 +2182,7 @@ AbstractTypeParamDecl::getConformingProtocols() const {
   if (!dc->isValidGenericContext())
     return nullptr;
 
-  auto contextTy = ArchetypeBuilder::mapTypeIntoContext(
-      dc, getDeclaredInterfaceType());
+  auto contextTy = dc->mapTypeIntoContext(getDeclaredInterfaceType());
   if (auto *archetype = contextTy->getAs<ArchetypeType>())
     return archetype->getConformsTo();
 
@@ -3667,6 +3659,8 @@ ParamDecl::ParamDecl(ParamDecl *PD)
     IsTypeLocImplicit(PD->IsTypeLocImplicit),
     defaultArgumentKind(PD->defaultArgumentKind) {
   typeLoc = PD->getTypeLoc();
+  if (PD->hasInterfaceType())
+    setInterfaceType(PD->getInterfaceType());
 }
 
 
@@ -3697,22 +3691,6 @@ Type DeclContext::getSelfInterfaceType() const {
   return getDeclaredInterfaceType();
 }
 
-/// \brief Retrieve the type of 'self' for the given context.
-Type DeclContext::getSelfTypeOfContext() const {
-  // For a protocol or extension thereof, the type is 'Self'.
-  if (auto *proto = getAsProtocolOrProtocolExtensionContext()) {
-    auto *genericEnv = proto->getGenericEnvironment();
-
-    // In the parser, generic parameters won't be wired up yet, just give up on
-    // producing a type.
-    if (genericEnv == nullptr)
-      return Type();
-
-    return genericEnv->mapTypeIntoContext(getProtocolSelfType());
-  }
-  return getDeclaredTypeOfContext();
-}
-
 /// Create an implicit 'self' decl for a method in the specified decl context.
 /// If 'static' is true, then this is self for a static method in the type.
 ///
@@ -3722,24 +3700,10 @@ Type DeclContext::getSelfTypeOfContext() const {
 /// For a generic context, this also gives the parameter an unbound generic
 /// type with the expectation that type-checking will fill in the context
 /// generic parameters.
-ParamDecl *ParamDecl::createUnboundSelf(SourceLoc loc, DeclContext *DC,
-                                        bool isStaticMethod, bool isInOut) {
+ParamDecl *ParamDecl::createUnboundSelf(SourceLoc loc, DeclContext *DC) {
   ASTContext &C = DC->getASTContext();
-  auto selfType = DC->getSelfTypeOfContext();
-
-  // If we have a valid selfType (i.e. we're not in the parser before we
-  // know such things, or we're nested inside an invalid extension),
-  // configure it.
-  if (selfType && !selfType->hasError()) {
-    if (isStaticMethod)
-      selfType = MetatypeType::get(selfType);
-    
-    if (isInOut)
-      selfType = InOutType::get(selfType);
-  }
-    
-  auto *selfDecl = new (C) ParamDecl(/*IsLet*/!isInOut, SourceLoc(),SourceLoc(),
-                                     Identifier(), loc, C.Id_self, selfType,DC);
+  auto *selfDecl = new (C) ParamDecl(/*IsLet*/true, SourceLoc(), SourceLoc(),
+                                     Identifier(), loc, C.Id_self, Type(), DC);
   selfDecl->setImplicit();
   return selfDecl;
 }
@@ -3758,21 +3722,16 @@ ParamDecl *ParamDecl::createSelf(SourceLoc loc, DeclContext *DC,
   ASTContext &C = DC->getASTContext();
   auto selfType = DC->getSelfTypeInContext();
   auto selfInterfaceType = DC->getSelfInterfaceType();
+  assert(selfType && selfInterfaceType);
 
-  assert(!!selfType == !!selfInterfaceType);
-
-  // If we have a selfType (i.e. we're not in the parser before we know such
-  // things, configure it.
-  if (selfType && selfInterfaceType) {
-    if (isStaticMethod) {
-      selfType = MetatypeType::get(selfType);
-      selfInterfaceType = MetatypeType::get(selfInterfaceType);
-    }
+  if (isStaticMethod) {
+    selfType = MetatypeType::get(selfType);
+    selfInterfaceType = MetatypeType::get(selfInterfaceType);
+  }
 
-    if (isInOut) {
-      selfType = InOutType::get(selfType);
-      selfInterfaceType = InOutType::get(selfInterfaceType);
-    }
+  if (isInOut) {
+    selfType = InOutType::get(selfType);
+    selfInterfaceType = InOutType::get(selfInterfaceType);
   }
 
   auto *selfDecl = new (C) ParamDecl(/*IsLet*/!isInOut, SourceLoc(),SourceLoc(),
@@ -3947,39 +3906,31 @@ SourceRange SubscriptDecl::getSourceRange() const {
   return { getSubscriptLoc(), ElementTy.getSourceRange().End };
 }
 
-static Type getSelfTypeForContainer(AbstractFunctionDecl *theMethod,
-                                    bool isInitializingCtor,
-                                    bool wantInterfaceType) {
-  auto *dc = theMethod->getDeclContext();
+Type AbstractFunctionDecl::computeInterfaceSelfType(bool isInitializingCtor,
+                                                    bool wantDynamicSelf) {
+  auto *dc = getDeclContext();
   auto &Ctx = dc->getASTContext();
 
   // Determine the type of the container.
-  auto containerTy = wantInterfaceType ? dc->getDeclaredInterfaceType()
-                                       : dc->getDeclaredTypeInContext();
+  auto containerTy = dc->getDeclaredInterfaceType();
   if (!containerTy || containerTy->hasError())
     return ErrorType::get(Ctx);
 
   // Determine the type of 'self' inside the container.
-  auto selfTy = wantInterfaceType ? dc->getSelfInterfaceType()
-                                  : dc->getSelfTypeInContext();
+  auto selfTy = dc->getSelfInterfaceType();
   if (!selfTy || selfTy->hasError())
     return ErrorType::get(Ctx);
 
   bool isStatic = false;
   bool isMutating = false;
-  Type selfTypeOverride;
-  
-  if (auto *FD = dyn_cast<FuncDecl>(theMethod)) {
+
+  if (auto *FD = dyn_cast<FuncDecl>(this)) {
     isStatic = FD->isStatic();
     isMutating = FD->isMutating();
 
-    // The non-interface type of a method that returns DynamicSelf
-    // uses DynamicSelf for the type of 'self', which is important
-    // when type checking the body of the function.
-    if (!wantInterfaceType && FD->hasDynamicSelf()) {
+    if (wantDynamicSelf && FD->hasDynamicSelf())
       selfTy = DynamicSelfType::get(selfTy, Ctx);
-    }
-  } else if (isa<ConstructorDecl>(theMethod)) {
+  } else if (isa<ConstructorDecl>(this)) {
     if (isInitializingCtor) {
       // initializing constructors of value types always have an implicitly
       // inout self.
@@ -3988,7 +3939,7 @@ static Type getSelfTypeForContainer(AbstractFunctionDecl *theMethod,
       // allocating constructors have metatype 'self'.
       isStatic = true;
     }
-  } else if (isa<DestructorDecl>(theMethod)) {
+  } else if (isa<DestructorDecl>(this)) {
     // destructors of value types always have an implicitly inout self.
     isMutating = true;
   }
@@ -4064,14 +4015,6 @@ void AbstractFunctionDecl::setGenericParams(GenericParamList *GP) {
 }
 
 
-Type AbstractFunctionDecl::computeSelfType() {
-  return getSelfTypeForContainer(this, true, false);
-}
-
-Type AbstractFunctionDecl::computeInterfaceSelfType(bool isInitializingCtor) {
-  return getSelfTypeForContainer(this, isInitializingCtor, true);
-}
-
 /// \brief This method returns the implicit 'self' decl.
 ///
 /// Note that some functions don't have an implicit 'self' decl, for example,
@@ -4561,8 +4504,7 @@ bool EnumElementDecl::computeType() {
 
   // The type of the enum element is either (T) -> T or (T) -> ArgType -> T.
   if (auto inputTy = getArgumentType()) {
-    resultTy = FunctionType::get(
-        ArchetypeBuilder::mapTypeOutOfContext(ED, inputTy), resultTy);
+    resultTy = FunctionType::get(ED->mapTypeOutOfContext(inputTy), resultTy);
   }
 
   if (auto *genericSig = ED->getGenericSignatureOfContext())

lib/AST/Mangle.cpp

@@ -489,13 +489,7 @@ Type Mangler::getDeclTypeForMangling(const ValueDecl *decl,
   if (!decl->hasInterfaceType())
     return ErrorType::get(C);
 
-  // FIXME: Interface types for ParamDecls
   Type type = decl->getInterfaceType();
-  if (type->hasArchetype()) {
-    assert(isa<ParamDecl>(decl));
-    type = ArchetypeBuilder::mapTypeOutOfContext(
-        decl->getDeclContext(), type);
-  }
 
   initialParamDepth = 0;
   CanGenericSignature sig;

lib/AST/Parameter.cpp

@@ -50,10 +50,8 @@ ParameterList::create(const ASTContext &C, SourceLoc LParenLoc,
 /// type with the expectation that type-checking will fill in the context
 /// generic parameters.
 ParameterList *ParameterList::createUnboundSelf(SourceLoc loc,
-                                                DeclContext *DC,
-                                                bool isStaticMethod,
-                                                bool isInOut) {
-  auto *PD = ParamDecl::createUnboundSelf(loc, DC, isStaticMethod, isInOut);
+                                                DeclContext *DC) {
+  auto *PD = ParamDecl::createUnboundSelf(loc, DC);
   return create(DC->getASTContext(), PD);
 }
 
@@ -141,17 +139,7 @@ Type ParameterList::getInterfaceType(DeclContext *DC) const {
   SmallVector<TupleTypeElt, 8> argumentInfo;
 
   for (auto P : *this) {
-    assert(P->hasType());
-
-    Type type;
-    // FIXME: Awful predicate because hasInterfaceType() now always
-    // returns true on ParamDecls.
-    if (!P->getInterfaceType()->hasArchetype())
-      type = P->getInterfaceType();
-    else if (!P->getTypeLoc().hasLocation())
-      type = ArchetypeBuilder::mapTypeOutOfContext(DC, P->getType());
-    else
-      type = P->getType();
+    auto type = P->getInterfaceType();
     assert(!type->hasArchetype());
 
     argumentInfo.emplace_back(