AST: Don't call hasType()/getType()/setType() on AbstractTypeParamDecls

slavapestov · slavapestov · commit 07780bd60cc2 · 2016-12-01T13:00:18.000-08:00
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -2004,22 +2004,8 @@ class ValueDecl : public Decl {
   SourceLoc getNameLoc() const { return NameLoc; }
   SourceLoc getLoc() const { return NameLoc; }
 
-  bool hasType() const {
-    assert(!isa<AbstractFunctionDecl>(this) &&
-           !isa<EnumElementDecl>(this) &&
-           !isa<SubscriptDecl>(this) &&
-           "functions and enum case constructors only have an interface type");
-    return !TypeAndAccess.getPointer().isNull();
-  }
-
-  Type getType() const {
-    assert(!isa<AbstractFunctionDecl>(this) &&
-           !isa<EnumElementDecl>(this) &&
-           !isa<SubscriptDecl>(this) &&
-           "functions and enum case constructors only have an interface type");
-    assert(hasType() && "declaration has no type set yet");
-    return TypeAndAccess.getPointer();
-  }
+  bool hasType() const;
+  Type getType() const;
 
   /// Set the type of this declaration for the first time.
   void setType(Type T);
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -516,7 +516,8 @@ namespace {
 
       if (!isa<AbstractFunctionDecl>(VD) &&
           !isa<EnumElementDecl>(VD) &&
-          !isa<SubscriptDecl>(VD)) {
+          !isa<SubscriptDecl>(VD) &&
+          !isa<AbstractTypeParamDecl>(VD)) {
         OS << " type='";
         if (VD->hasType())
           VD->getType().print(OS);
diff --git a/lib/AST/ArchetypeBuilder.cpp b/lib/AST/ArchetypeBuilder.cpp
@@ -1453,8 +1453,8 @@ bool ArchetypeBuilder::addAbstractTypeParamRequirements(
   };
 
   if (isa<AssociatedTypeDecl>(decl) &&
-      decl->hasType() &&
-      decl->getType()->is<ErrorType>())
+      decl->hasInterfaceType() &&
+      decl->getInterfaceType()->is<ErrorType>())
     return false;
 
   // If this is an associated type that already has an archetype assigned,
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -1644,6 +1644,25 @@ ValueDecl::getSatisfiedProtocolRequirements(bool Sorted) const {
   return NTD->getSatisfiedProtocolRequirementsForMember(this, Sorted);
 }
 
+bool ValueDecl::hasType() const {
+  assert(!isa<AbstractFunctionDecl>(this) &&
+         !isa<EnumElementDecl>(this) &&
+         !isa<SubscriptDecl>(this) &&
+         !isa<AbstractTypeParamDecl>(this) &&
+         "functions and enum case constructors only have an interface type");
+  return !TypeAndAccess.getPointer().isNull();
+}
+
+Type ValueDecl::getType() const {
+  assert(!isa<AbstractFunctionDecl>(this) &&
+         !isa<EnumElementDecl>(this) &&
+         !isa<SubscriptDecl>(this) &&
+         !isa<AbstractTypeParamDecl>(this) &&
+         "functions and enum case constructors only have an interface type");
+  assert(hasType() && "declaration has no type set yet");
+  return TypeAndAccess.getPointer();
+}
+
 void ValueDecl::setType(Type T) {
   assert(!hasType() && "changing type of declaration");
   overwriteType(T);
@@ -1653,6 +1672,7 @@ void ValueDecl::overwriteType(Type T) {
   assert(!isa<AbstractFunctionDecl>(this) &&
          !isa<EnumElementDecl>(this) &&
          !isa<SubscriptDecl>(this) &&
+         !isa<AbstractTypeParamDecl>(this) &&
          "functions and enum case constructors only have an interface type");
 
   TypeAndAccess.setPointer(T);
@@ -1661,13 +1681,6 @@ void ValueDecl::overwriteType(Type T) {
 }
 
 bool ValueDecl::hasInterfaceType() const {
-  // getInterfaceType() always returns something for associated types.
-  if (isa<AssociatedTypeDecl>(this)) {
-    auto proto = cast<ProtocolDecl>(getDeclContext());
-    auto selfTy = proto->getSelfInterfaceType();
-    return !!selfTy;
-  }
-
   // getInterfaceType() returns the contextual type for ParamDecls which
   // don't have an explicit interface type.
   if (isa<ParamDecl>(this))
@@ -1680,19 +1693,6 @@ Type ValueDecl::getInterfaceType() const {
   if (InterfaceTy)
     return InterfaceTy;
 
-  if (auto assocType = dyn_cast<AssociatedTypeDecl>(this)) {
-    auto proto = cast<ProtocolDecl>(getDeclContext());
-    auto selfTy = proto->getSelfInterfaceType();
-    if (!selfTy)
-      return Type();
-    auto &ctx = getASTContext();
-    InterfaceTy = DependentMemberType::get(
-                    selfTy,
-                    const_cast<AssociatedTypeDecl *>(assocType));
-    InterfaceTy = MetatypeType::get(InterfaceTy, ctx);
-    return InterfaceTy;
-  }
-
   if (!hasType())
     return Type();
 
@@ -2257,7 +2257,6 @@ GenericTypeParamDecl::GenericTypeParamDecl(DeclContext *dc, Identifier name,
 {
   auto &ctx = dc->getASTContext();
   auto type = new (ctx, AllocationArena::Permanent) GenericTypeParamType(this);
-  setType(MetatypeType::get(type, ctx));
   setInterfaceType(MetatypeType::get(type, ctx));
 }
 
@@ -2301,8 +2300,12 @@ AssociatedTypeDecl::AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc,
 
 void AssociatedTypeDecl::computeType() {
   auto &ctx = getASTContext();
-  auto type = new (ctx, AllocationArena::Permanent) AssociatedTypeType(this);
-  setType(MetatypeType::get(type, ctx));
+  auto proto = cast<ProtocolDecl>(getDeclContext());
+  auto selfTy = proto->getSelfInterfaceType();
+  if (!selfTy)
+    selfTy = ErrorType::get(ctx);
+  auto interfaceTy = DependentMemberType::get(selfTy, this);
+  setInterfaceType(MetatypeType::get(interfaceTy, ctx));
 }
 
 TypeLoc &AssociatedTypeDecl::getDefaultDefinitionLoc() {
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -319,7 +319,11 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
   // If this is a decl that we have an lvalue for, produce and return it.
   ValueDecl *decl = declRef.getDecl();
   
-  if (!ncRefType) ncRefType = decl->getType();
+  if (!ncRefType) {
+    ncRefType = ArchetypeBuilder::mapTypeIntoContext(
+        decl->getInnermostDeclContext(),
+        decl->getInterfaceType());
+  }
   CanType refType = ncRefType->getCanonicalType();
 
   auto getUnmanagedRValue = [&](SILValue value) -> RValue {
@@ -335,7 +339,7 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
 
   // If this is a reference to a type, produce a metatype.
   if (isa<TypeDecl>(decl)) {
-    assert(decl->getType()->is<MetatypeType>() &&
+    assert(refType->is<MetatypeType>() &&
            "type declref does not have metatype type?!");
     return getUnmanagedRValue(B.createMetatype(loc, getLoweredType(refType)));
   }
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -945,7 +945,8 @@ static void checkRedeclaration(TypeChecker &tc, ValueDecl *current) {
       current->setInvalid();
       if (!isa<AbstractFunctionDecl>(current) &&
           !isa<EnumElementDecl>(current) &&
-          !isa<SubscriptDecl>(current))
+          !isa<SubscriptDecl>(current) &&
+          !isa<AbstractTypeParamDecl>(current))
         if (current->hasType())
           current->overwriteType(ErrorType::get(tc.Context));
       if (current->hasInterfaceType())
@@ -6879,12 +6880,12 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
 
     DeclContext *DC = typeParam->getDeclContext();
 
+    if (assocType && !assocType->hasInterfaceType())
+        assocType->computeType();
+
     if (!resolveTypeParams || DC->isValidGenericContext()) {
       if (assocType) {
         DeclChecker(*this, false, false).visitAssociatedTypeDecl(assocType);
-
-        if (!assocType->hasType())
-          assocType->computeType();
       }
 
       break;
@@ -6903,9 +6904,6 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
     case DeclContextKind::GenericTypeDecl: {
       auto nominal = cast<GenericTypeDecl>(DC);
       validateDecl(nominal);
-      if (auto assocType = dyn_cast<AssociatedTypeDecl>(typeParam))
-        if (!assocType->hasType())
-          assocType->computeType();
       if (!typeParam->hasAccessibility())
         typeParam->setAccessibility(std::max(nominal->getFormalAccess(),
                                              Accessibility::Internal));
@@ -6925,9 +6923,7 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
         typeCheckDecl(extension, true);
       auto fn = cast<AbstractFunctionDecl>(DC);
       typeCheckDecl(fn, true);
-      if (auto assocType = dyn_cast<AssociatedTypeDecl>(typeParam))
-        if (!assocType->hasType())
-          assocType->computeType();
+      assert(!assocType && "Associated type inside function?");
       if (!typeParam->hasAccessibility())
         typeParam->setAccessibility(std::max(fn->getFormalAccess(),
                                              Accessibility::Internal));
@@ -7049,7 +7045,7 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
     // appropriate archetype.
     for (auto member : proto->getMembers()) {
       if (auto assocType = dyn_cast<AssociatedTypeDecl>(member)) {
-        if (!assocType->hasType())
+        if (!assocType->hasInterfaceType())
           assocType->computeType();
       }
     }
diff --git a/lib/Sema/TypeCheckNameLookup.cpp b/lib/Sema/TypeCheckNameLookup.cpp
@@ -331,7 +331,7 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
 
     // FIXME: This should happen before we attempt shadowing checks.
     validateDecl(typeDecl);
-    if (!typeDecl->hasType()) // FIXME: recursion-breaking hack
+    if (!typeDecl->hasInterfaceType()) // FIXME: recursion-breaking hack
       continue;
 
     // If we're looking up a member of a protocol, we must take special care.
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -661,7 +661,7 @@ static Type resolveTypeDecl(TypeChecker &TC, TypeDecl *typeDecl, SourceLoc loc,
     TC.validateDecl(typeDecl);
 
     // FIXME: More principled handling of circularity.
-    if (!isa<AssociatedTypeDecl>(typeDecl) && !typeDecl->hasType())
+    if (!typeDecl->hasInterfaceType())
       return ErrorType::get(TC.Context);
   }
 
@@ -1107,6 +1107,7 @@ static Type resolveNestedIdentTypeComponent(
   // Phase 2: If a declaration has already been bound, use it.
   if (ValueDecl *decl = comp->getBoundDecl()) {
     auto *typeDecl = cast<TypeDecl>(decl);
+    auto *assocType = dyn_cast<AssociatedTypeDecl>(typeDecl);
 
     Type memberType;
 
@@ -1126,18 +1127,18 @@ static Type resolveNestedIdentTypeComponent(
       return memberType;
     }
 
-    if (isa<AssociatedTypeDecl>(typeDecl) &&
-        !parentTy->is<ArchetypeType>()) {
-      assert(!parentTy->isExistentialType());
+    if (assocType && !assocType->hasInterfaceType())
+      assocType->computeType();
 
-      auto assocType = cast<AssociatedTypeDecl>(typeDecl);
+    if (assocType && !parentTy->is<ArchetypeType>()) {
+      assert(!parentTy->isExistentialType());
 
       // Find the conformance and dig out the type witness.
       ConformanceCheckOptions conformanceOptions;
       if (options.contains(TR_InExpression))
         conformanceOptions |= ConformanceCheckFlags::InExpression;
 
-      auto *protocol = cast<ProtocolDecl>(assocType->getDeclContext());
+      auto *protocol = assocType->getProtocol();
       auto conformance = TC.conformsToProtocol(parentTy, protocol, DC,
                                                conformanceOptions);
       if (!conformance || conformance->isAbstract()) {
