[AST] Add Type::wrapInPointer(PointerTypeKind)

jrose-apple · jrose-apple · commit b34d2c5eb920 · 2019-09-27T14:27:33.000-07:00
...replacing a similar utility in the type checker and one I just
added in ClangImporter earlier in this patch series. This is an
ever-so-slight regression in functionality because a missing pointer
declaration used to print a diagnostic and now it will just crash on
an invalid standard library, but I don't think we should be optimizing
for an invalid standard library anyway.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -3647,9 +3647,6 @@ ERROR(sugar_type_not_found,none,
       "broken standard library: cannot find "
       "%select{Array|Optional|ImplicitlyUnwrappedOptional|Dictionary|"
       "Error}0 type", (unsigned))
-ERROR(pointer_type_not_found,none,
-      "broken standard library: cannot find "
-      "%select{UnsafePointer|UnsafeMutablePointer}0 type", (unsigned))
 ERROR(optional_intrinsics_not_found,none,
       "broken standard library: cannot find intrinsic operations on "
       "Optional<T>", ())
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -706,6 +706,12 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     PointerTypeKind Ignore;
     return getAnyPointerElementType(Ignore);
   }
+
+  /// Returns a type representing a pointer to \c this.
+  ///
+  /// \p kind must not be a raw pointer kind, since that would discard the
+  /// current type.
+  Type wrapInPointer(PointerTypeKind kind);
   
   /// Determine whether the given type is "specialized", meaning that
   /// it involves generic types for which generic arguments have been provided.
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -624,6 +624,28 @@ Type TypeBase::getAnyPointerElementType(PointerTypeKind &PTK) {
   return Type();
 }
 
+Type TypeBase::wrapInPointer(PointerTypeKind kind) {
+  ASTContext &ctx = getASTContext();
+  NominalTypeDecl *pointerDecl = ([&ctx, kind] {
+    switch (kind) {
+    case PTK_UnsafeMutableRawPointer:
+    case PTK_UnsafeRawPointer:
+      llvm_unreachable("these pointer types don't take arguments");
+    case PTK_UnsafePointer:
+      return ctx.getUnsafePointerDecl();
+    case PTK_UnsafeMutablePointer:
+      return ctx.getUnsafeMutablePointerDecl();
+    case PTK_AutoreleasingUnsafeMutablePointer:
+      return ctx.getAutoreleasingUnsafeMutablePointerDecl();
+    }
+    llvm_unreachable("bad kind");
+  }());
+
+  assert(pointerDecl);
+  return BoundGenericType::get(pointerDecl, /*parent*/nullptr, Type(this));
+}
+
+
 Type TypeBase::lookThroughAllOptionalTypes() {
   Type type(this);
   while (auto objType = type->getOptionalObjectType())
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
@@ -60,36 +60,6 @@ bool ClangImporter::Implementation::isOverAligned(clang::QualType type) {
   return align > clang::CharUnits::fromQuantity(MaximumAlignment);
 }
 
-/// Returns a specialization of the given pointer type for the given pointee.
-///
-/// \p kind must not be a raw pointer kind.
-static Type getPointerTo(Type pointee, PointerTypeKind kind) {
-  ASTContext &ctx = pointee->getASTContext();
-  NominalTypeDecl *pointerDecl = ([&ctx, kind] {
-    switch (kind) {
-    case PTK_UnsafeMutableRawPointer:
-    case PTK_UnsafeRawPointer:
-      llvm_unreachable("these pointer types don't take arguments");
-    case PTK_UnsafePointer:
-      return ctx.getUnsafePointerDecl();
-    case PTK_UnsafeMutablePointer:
-      return ctx.getUnsafeMutablePointerDecl();
-    case PTK_AutoreleasingUnsafeMutablePointer:
-      return ctx.getAutoreleasingUnsafeMutablePointerDecl();
-    }
-    llvm_unreachable("bad kind");
-  }());
-
-  // Specifically handle AUMP being missing to allow testing more of ObjC
-  // interop on non-Apple platforms.
-  assert((pointerDecl || kind == PTK_AutoreleasingUnsafeMutablePointer) &&
-         "could not find standard pointer type");
-  if (!pointerDecl)
-    return Type();
-
-  return BoundGenericType::get(pointerDecl, /*parent*/nullptr, pointee);
-}
-
 namespace {
   /// Various types that we want to do something interesting to after
   /// importing them.
@@ -438,22 +408,35 @@ namespace {
         };
       }
 
+      PointerTypeKind pointerKind;
       if (quals.hasConst()) {
-        return {getPointerTo(pointeeType, PTK_UnsafePointer),
-                ImportHint::OtherPointer};
-      }
+        pointerKind = PTK_UnsafePointer;
+      } else {
+        switch (quals.getObjCLifetime()) {
+        case clang::Qualifiers::OCL_Autoreleasing:
+        case clang::Qualifiers::OCL_ExplicitNone:
+          // Mutable pointers with __autoreleasing or __unsafe_unretained
+          // ownership map to AutoreleasingUnsafeMutablePointer<T>.
+          pointerKind = PTK_AutoreleasingUnsafeMutablePointer;
+
+          // FIXME: We have tests using a non-Apple stdlib that nevertheless
+          // exercise ObjC interop. Fail softly for those tests.
+          if (!Impl.SwiftContext.getAutoreleasingUnsafeMutablePointerDecl())
+            return Type();
+          break;
 
-      // Mutable pointers with __autoreleasing or __unsafe_unretained
-      // ownership map to AutoreleasingUnsafeMutablePointer<T>.
-      if (quals.getObjCLifetime() == clang::Qualifiers::OCL_Autoreleasing ||
-          quals.getObjCLifetime() == clang::Qualifiers::OCL_ExplicitNone) {
-        return {
-          getPointerTo(pointeeType, PTK_AutoreleasingUnsafeMutablePointer),
-          ImportHint::OtherPointer};
+        case clang::Qualifiers::OCL_Weak:
+          // FIXME: We should refuse to import this.
+          LLVM_FALLTHROUGH;
+
+        case clang::Qualifiers::OCL_None:
+        case clang::Qualifiers::OCL_Strong:
+          // All other mutable pointers map to UnsafeMutablePointer.
+          pointerKind = PTK_UnsafeMutablePointer;
+        }
       }
 
-      // All other mutable pointers map to UnsafeMutablePointer.
-      return {getPointerTo(pointeeType, PTK_UnsafeMutablePointer),
+      return {pointeeType->wrapInPointer(pointerKind),
               ImportHint::OtherPointer};
     }
 
@@ -1269,7 +1252,7 @@ static Type maybeImportCFOutParameter(ClangImporter::Implementation &impl,
   else
     pointerKind = PTK_AutoreleasingUnsafeMutablePointer;
 
-  resultTy = getPointerTo(resultTy, pointerKind);
+  resultTy = resultTy->wrapInPointer(pointerKind);
   return resultTy;
 }
 
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -3770,11 +3770,11 @@ static Type buildAddressorResultType(TypeChecker &TC,
   assert(addressor->getAccessorKind() == AccessorKind::Address ||
          addressor->getAccessorKind() == AccessorKind::MutableAddress);
 
-  Type pointerType =
+  PointerTypeKind pointerKind =
     (addressor->getAccessorKind() == AccessorKind::Address)
-      ? TC.getUnsafePointerType(addressor->getLoc(), valueType)
-      : TC.getUnsafeMutablePointerType(addressor->getLoc(), valueType);
-  return pointerType;
+      ? PTK_UnsafePointer
+      : PTK_UnsafeMutablePointer;
+  return valueType->wrapInPointer(pointerKind);
 }
 
 
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -385,47 +385,6 @@ Type TypeChecker::getOptionalType(SourceLoc loc, Type elementType) {
   return OptionalType::get(elementType);
 }
 
-static Type getPointerType(TypeChecker &tc, SourceLoc loc, Type pointeeType,
-                           PointerTypeKind kind) {
-  auto pointerDecl = [&] {
-    switch (kind) {
-    case PTK_UnsafeMutableRawPointer:
-    case PTK_UnsafeRawPointer:
-      llvm_unreachable("these pointer types don't take arguments");
-    case PTK_UnsafePointer:
-      return tc.Context.getUnsafePointerDecl();
-    case PTK_UnsafeMutablePointer:
-      return tc.Context.getUnsafeMutablePointerDecl();
-    case PTK_AutoreleasingUnsafeMutablePointer:
-      return tc.Context.getAutoreleasingUnsafeMutablePointerDecl();
-    }
-    llvm_unreachable("bad kind");
-  }();
-  if (!pointerDecl) {
-    tc.diagnose(loc, diag::pointer_type_not_found,
-                kind == PTK_UnsafePointer ? 0 :
-                kind == PTK_UnsafeMutablePointer ? 1 : 2);
-    return Type();
-  }
-
-  // FIXME(InterfaceTypeRequest): isInvalid() should be based on the interface type.
-  (void)pointerDecl->getInterfaceType();
-  if (pointerDecl->isInvalid())
-    return Type();
-
-  // TODO: validate generic signature?
-
-  return BoundGenericType::get(pointerDecl, nullptr, pointeeType);
-}
-
-Type TypeChecker::getUnsafePointerType(SourceLoc loc, Type pointeeType) {
-  return getPointerType(*this, loc, pointeeType, PTK_UnsafePointer);
-}
-
-Type TypeChecker::getUnsafeMutablePointerType(SourceLoc loc, Type pointeeType) {
-  return getPointerType(*this, loc, pointeeType, PTK_UnsafeMutablePointer);
-}
-
 Type TypeChecker::getStringType(DeclContext *dc) {
   if (auto typeDecl = Context.getStringDecl())
     return typeDecl->getDeclaredInterfaceType();
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -735,8 +735,6 @@ class TypeChecker final : public LazyResolver {
   static Type getArraySliceType(SourceLoc loc, Type elementType);
   static Type getDictionaryType(SourceLoc loc, Type keyType, Type valueType);
   static Type getOptionalType(SourceLoc loc, Type elementType);
-  Type getUnsafePointerType(SourceLoc loc, Type pointeeType);
-  Type getUnsafeMutablePointerType(SourceLoc loc, Type pointeeType);
   Type getStringType(DeclContext *dc);
   Type getSubstringType(DeclContext *dc);
   Type getIntType(DeclContext *dc);
