Merge pull request #3967 from swiftwasm/main

Author: MaxDesiatov

CMakeLists.txt

@@ -674,6 +674,9 @@ set(SWIFT_DARWIN_PLATFORMS "IOS" "IOS_SIMULATOR" "TVOS" "TVOS_SIMULATOR" "WATCHO
 set(SWIFT_APPLE_PLATFORMS ${SWIFT_DARWIN_PLATFORMS})
 if(SWIFT_FREESTANDING_FLAVOR STREQUAL "apple")
   list(APPEND SWIFT_APPLE_PLATFORMS "FREESTANDING")
+  if(SWIFT_FREESTANDING_IS_DARWIN)
+    list(APPEND SWIFT_DARWIN_PLATFORMS "FREESTANDING")
+  endif()
 endif()
 
 # Configuration flags passed to all of our invocations of gyb.  Try to

include/swift/AST/Decl.h

@@ -28,6 +28,7 @@
 #include "swift/AST/GenericParamKey.h"
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/LayoutConstraint.h"
+#include "swift/AST/ReferenceCounting.h"
 #include "swift/AST/StorageImpl.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/TypeWalker.h"
@@ -37,10 +38,10 @@
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/InlineBitfield.h"
+#include "swift/Basic/Located.h"
 #include "swift/Basic/NullablePtr.h"
 #include "swift/Basic/OptionalEnum.h"
 #include "swift/Basic/Range.h"
-#include "swift/Basic/Located.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <type_traits>
@@ -3906,7 +3907,8 @@ class ClassDecl final : public NominalTypeDecl {
   ///
   /// \see getForeignClassKind
   bool isForeign() const {
-    return getForeignClassKind() != ForeignKind::Normal;
+    return getForeignClassKind() != ForeignKind::Normal ||
+      const_cast<ClassDecl *>(this)->isForeignReferenceType();
   }
 
   /// Whether the class is (known to be) a default actor.
@@ -3941,9 +3943,22 @@ class ClassDecl final : public NominalTypeDecl {
   bool isNativeNSObjectSubclass() const;
 
   /// Whether the class uses the ObjC object model (reference counting,
-  /// allocation, etc.) instead of the Swift model.
-  bool usesObjCObjectModel() const {
-    return checkAncestry(AncestryFlags::ObjCObjectModel);
+  /// allocation, etc.), the Swift model, or has no reference counting at all.
+  ReferenceCounting getObjectModel() {
+    if (isForeignReferenceType())
+      return ReferenceCounting::None;
+
+    if (checkAncestry(AncestryFlags::ObjCObjectModel))
+      return ReferenceCounting::ObjC;
+
+    return ReferenceCounting::Native;
+  }
+
+  LayoutConstraintKind getLayoutConstraintKind() {
+    if (getObjectModel() == ReferenceCounting::ObjC)
+      return LayoutConstraintKind::Class;
+
+    return LayoutConstraintKind::NativeClass;
   }
 
   /// Returns true if the class has designated initializers that are not listed
@@ -4065,6 +4080,11 @@ class ClassDecl final : public NominalTypeDecl {
   bool hasKnownSwiftImplementation() const {
     return !hasClangNode();
   }
+
+  /// Used to determine if this class decl is a foriegn reference type. I.e., a
+  /// non-reference-counted swift reference type that was imported from a C++
+  /// record.
+  bool isForeignReferenceType();
 };
 
 /// A convenience wrapper around the \c SelfReferencePosition::Kind enum.

include/swift/AST/DiagnosticsIRGen.def

@@ -59,5 +59,10 @@ ERROR(temporary_allocation_alignment_not_positive,none,
 ERROR(temporary_allocation_alignment_not_power_of_2,none,
       "alignment value must be a power of two", ())
 
+ERROR(foreign_reference_types_unsupported,none,
+      "attempt to use a foreign reference type in a generic context. "
+      "Foreign reference types are currently not supported. Using foreign "
+      "reference types in a generic context is not yet implemented.", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/Module.h

@@ -882,8 +882,19 @@ class ModuleEntity {
   ModuleEntity(const ModuleDecl *Mod) : Mod(Mod) {}
   ModuleEntity(const clang::Module *Mod) : Mod(static_cast<const void *>(Mod)){}
 
-  StringRef getName() const;
-  std::string getFullName() const;
+  /// @param useRealNameIfAliased Whether to use the module's real name in case
+  ///                             module aliasing is used. For example, if a file
+  ///                             has `import Foo` and `-module-alias Foo=Bar` is
+  ///                             passed, treat Foo as an alias and Bar as the real
+  ///                             module name as its dependency. This only applies
+  ///                             to Swift modules.
+  /// @return The module name; for Swift modules, the real module name could be
+  ///         different from the name if module aliasing is used.
+  StringRef getName(bool useRealNameIfAliased = false) const;
+
+  /// For Swift modules, it returns the same result as \c ModuleEntity::getName(bool).
+  /// For Clang modules, it returns the result of \c clang::Module::getFullModuleName.
+  std::string getFullName(bool useRealNameIfAliased = false) const;
 
   bool isSystemModule() const;
   bool isBuiltinModule() const;

include/swift/AST/ReferenceCounting.h

@@ -29,6 +29,10 @@ enum class ReferenceCounting : uint8_t {
   /// Blocks are always ObjC reference counting compatible.
   ObjC,
 
+  /// The object has no reference counting. This is used by foreign reference
+  /// types.
+  None,
+
   /// The object uses _Block_copy/_Block_release reference counting.
   ///
   /// This is a strict subset of ObjC; all blocks are also ObjC reference

include/swift/AST/Type.h

@@ -488,6 +488,8 @@ class CanType : public Type {
   NominalTypeDecl *getAnyNominal() const;
   GenericTypeDecl *getAnyGeneric() const;
 
+  bool isForeignReferenceType(); // in Types.h
+
   CanType getOptionalObjectType() const {
     return getOptionalObjectTypeImpl(*this);
   }

include/swift/AST/Types.h

@@ -811,16 +811,19 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   /// If this is a class type or a bound generic class type, returns the
   /// (possibly generic) class.
-  ClassDecl *getClassOrBoundGenericClass();
-  
+  ClassDecl *getClassOrBoundGenericClass() const;
+
   /// If this is a struct type or a bound generic struct type, returns
   /// the (possibly generic) class.
   StructDecl *getStructOrBoundGenericStruct();
 
   /// If this is an enum or a bound generic enum type, returns the
   /// (possibly generic) enum.
   EnumDecl *getEnumOrBoundGenericEnum();
-  
+
+  /// If this is a class, check if this class is a foreign reference type.
+  bool isForeignReferenceType();
+
   /// Determine whether this type may have a superclass, which holds for
   /// classes, bound generic classes, and archetypes that are only instantiable
   /// with a class type.
@@ -6198,7 +6201,7 @@ inline bool TypeBase::canDynamicallyBeOptionalType(bool includeExistential) {
   return isArchetypeOrExistential && !T.isAnyClassReferenceType();
 }
 
-inline ClassDecl *TypeBase::getClassOrBoundGenericClass() {
+inline ClassDecl *TypeBase::getClassOrBoundGenericClass() const {
   return getCanonicalType().getClassOrBoundGenericClass();
 }
 
@@ -6262,8 +6265,6 @@ inline GenericTypeDecl *TypeBase::getAnyGeneric() {
   return getCanonicalType().getAnyGeneric();
 }
 
-  
-  
 inline bool TypeBase::isBuiltinIntegerType(unsigned n) {
   if (auto intTy = dyn_cast<BuiltinIntegerType>(getCanonicalType()))
     return intTy->getWidth().isFixedWidth()

include/swift/AST/USRGeneration.h

@@ -47,6 +47,10 @@ bool printDeclTypeUSR(const ValueDecl *D, raw_ostream &OS);
 bool printValueDeclUSR(const ValueDecl *D, raw_ostream &OS);
 
 /// Prints out the USR for the given ModuleEntity.
+/// In case module aliasing is used, it prints the real module name. For example,
+/// if a file has `import Foo` and `-module-alias Foo=Bar` is passed, treat Foo as
+/// an alias and Bar as the real module name as its dependency. Note that the
+/// aliasing only applies to Swift modules.
 /// \returns true if it failed, false on success.
 bool printModuleUSR(ModuleEntity Mod, raw_ostream &OS);
 

include/swift/Basic/BlotSetVector.h

@@ -113,6 +113,8 @@ class BlotSetVector {
     return {index, true};
   }
 
+  bool count(const ValueT &value) { return map.count(value); }
+
   /// Replace \p value1 with \p value2 placing \p value2 into the position in
   /// the array where value1 used to be. If \p value2 is already in the set,
   /// this just erases \p value1.

include/swift/ClangImporter/ClangImporterRequests.h

@@ -132,10 +132,10 @@ class CXXNamespaceMemberLookup
 
 /// The input type for a record member lookup request.
 struct ClangRecordMemberLookupDescriptor final {
-  StructDecl *recordDecl;
+  NominalTypeDecl *recordDecl;
   DeclName name;
 
-  ClangRecordMemberLookupDescriptor(StructDecl *recordDecl, DeclName name)
+  ClangRecordMemberLookupDescriptor(NominalTypeDecl *recordDecl, DeclName name)
       : recordDecl(recordDecl), name(name) {
     assert(isa<clang::RecordDecl>(recordDecl->getClangDecl()));
   }

include/swift/Reflection/MetadataSource.h

@@ -178,7 +178,7 @@ class MetadataSource {
   }
 
   void dump() const;
-  void dump(FILE *file, unsigned Indent = 0) const;
+  void dump(std::ostream &stream, unsigned Indent = 0) const;
   template <typename Allocator>
   static const MetadataSource *decode(Allocator &A, const std::string &str) {
     auto begin = str.begin();

include/swift/Reflection/TypeLowering.h

@@ -145,7 +145,7 @@ class TypeInfo {
   bool isBitwiseTakable() const { return BitwiseTakable; }
 
   void dump() const;
-  void dump(FILE *file, unsigned Indent = 0) const;
+  void dump(std::ostream &stream, unsigned Indent = 0) const;
 
   // Using the provided reader, inspect our value.
   // Return false if we can't inspect value.

include/swift/Reflection/TypeRef.h

@@ -25,7 +25,7 @@
 #include "swift/ABI/MetadataValues.h"
 #include "swift/Remote/MetadataReader.h"
 #include "swift/Basic/Unreachable.h"
-
+#include <ostream>
 namespace swift {
 namespace reflection {
 
@@ -177,7 +177,7 @@ class alignas(8) TypeRef {
   }
 
   void dump() const;
-  void dump(FILE *file, unsigned Indent = 0) const;
+  void dump(std::ostream &stream, unsigned Indent = 0) const;
 
   /// Build a demangle tree from this TypeRef.
   Demangle::NodePointer getDemangling(Demangle::Demangler &Dem) const;

include/swift/Reflection/TypeRefBuilder.h

@@ -24,8 +24,9 @@
 #include "swift/Reflection/TypeLowering.h"
 #include "swift/Reflection/TypeRef.h"
 #include "llvm/ADT/Optional.h"
-#include <vector>
+#include <ostream>
 #include <unordered_map>
+#include <vector>
 
 namespace swift {
 namespace reflection {
@@ -209,7 +210,7 @@ struct ClosureContextInfo {
   unsigned NumBindings = 0;
 
   void dump() const;
-  void dump(FILE *file) const;
+  void dump(std::ostream &stream) const;
 };
 
 struct FieldTypeInfo {
@@ -643,6 +644,10 @@ class TypeRefBuilder {
 
 private:
   std::vector<ReflectionInfo> ReflectionInfos;
+
+  /// Index of the next Reflection Info that should be processed.
+  /// This assumes that Reflection Infos are never removed from the vector.
+  size_t FirstUnprocessedReflectionInfoIndex = 0;
 
   llvm::Optional<std::string> normalizeReflectionName(RemoteRef<char> name);
   bool reflectionNameMatches(RemoteRef<char> reflectionName,
@@ -728,12 +733,12 @@ class TypeRefBuilder {
   ///
 
   void dumpTypeRef(RemoteRef<char> MangledName,
-                   FILE *file, bool printTypeName = false);
-  void dumpFieldSection(FILE *file);
-  void dumpAssociatedTypeSection(FILE *file);
-  void dumpBuiltinTypeSection(FILE *file);
-  void dumpCaptureSection(FILE *file);
-  void dumpAllSections(FILE *file);
+                   std::ostream &stream, bool printTypeName = false);
+  void dumpFieldSection(std::ostream &stream);
+  void dumpAssociatedTypeSection(std::ostream &stream);
+  void dumpBuiltinTypeSection(std::ostream &stream);
+  void dumpCaptureSection(std::ostream &stream);
+  void dumpAllSections(std::ostream &stream);
 };
 
 

include/swift/SIL/OwnershipUtils.h

@@ -31,6 +31,7 @@ class SILModule;
 class SILValue;
 class DeadEndBlocks;
 class PrunedLiveness;
+struct BorrowedValue;
 
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);
@@ -103,6 +104,15 @@ inline bool isForwardingConsume(SILValue value) {
 bool findInnerTransitiveGuaranteedUses(
     SILValue guaranteedValue, SmallVectorImpl<Operand *> *usePoints = nullptr);
 
+/// Like findInnerTransitiveGuaranteedUses except that rather than it being a
+/// precondition that the provided value not be a BorrowedValue, it is a [type-
+/// system-enforced] precondition that the provided value be a BorrowedValue.
+///
+/// TODO: Merge with findInnerTransitiveGuaranteedUses.
+bool findInnerTransitiveGuaranteedUsesOfBorrowedValue(
+    BorrowedValue borrowedValue,
+    SmallVectorImpl<Operand *> *usePoints = nullptr);
+
 /// Find leaf "use points" of a guaranteed value within its enclosing borrow
 /// scope (without looking through reborrows). To find the use points of the
 /// extended borrow scope, after looking through reborrows, use
@@ -1196,6 +1206,14 @@ void visitTransitiveEndBorrows(
     BorrowedValue beginBorrow,
     function_ref<void(EndBorrowInst *)> visitEndBorrow);
 
+/// Whether the specified lexical begin_borrow instruction is nested.
+///
+/// A begin_borrow [lexical] is nested if the borrowed value's lifetime is
+/// guaranteed by another lexical scope.  That happens if:
+/// - the value is a guaranteed argument to the function
+/// - the value is itself a begin_borrow [lexical]
+bool isNestedLexicalBeginBorrow(BeginBorrowInst *bbi);
+
 } // namespace swift
 
 #endif

include/swift/SIL/SILInstruction.h

@@ -630,6 +630,12 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// Can this instruction abort the program in some manner?
   bool mayTrap() const;
 
+  /// Involves a synchronization point like a memory barrier, lock or syscall.
+  ///
+  /// TODO: We need side-effect analysis and library annotation for this to be
+  ///       a reasonable API.  For now, this is just a placeholder.
+  bool maySynchronize() const;
+
   /// Returns true if the given instruction is completely identical to RHS.
   bool isIdenticalTo(const SILInstruction *RHS) const {
     return isIdenticalTo(RHS,

include/swift/SIL/SILType.h

@@ -236,7 +236,13 @@ class SILType {
   NominalTypeDecl *getNominalOrBoundGenericNominal() const {
     return getASTType().getNominalOrBoundGenericNominal();
   }
-  
+
+  /// If this type maps to a Swift class, check if that class is a foreign
+  /// reference type.
+  bool isForeignReferenceType() const {
+    return getASTType().isForeignReferenceType();
+  }
+
   /// True if the type is an address type.
   bool isAddress() const { return getCategory() == SILValueCategory::Address; }
 

include/swift/SILOptimizer/Utils/CanonicalizeBorrowScope.h

@@ -16,11 +16,8 @@
 /// deleted, which in turn allows canonicalization of the outer owned values
 /// (via CanonicalizeOSSALifetime).
 ///
-/// This does not shrink borrow scopes; it does not rewrite end_borrows.
-///
-/// TODO: A separate utility to shrink borrow scopes should eventually run
-/// before this utility. It should hoist end_borrow up to the latest "destroy
-/// barrier" whenever the scope does not contain a PointerEscape.
+/// This does not shrink borrow scopes; it does not rewrite end_borrows.  For
+/// that, see ShrinkBorrowScope.
 ///
 //===----------------------------------------------------------------------===//
 
@@ -150,6 +147,8 @@ class CanonicalizeBorrowScope {
   bool consolidateBorrowScope();
 };
 
+bool shrinkBorrowScope(BeginBorrowInst *bbi, InstructionDeleter &deleter);
+
 } // namespace swift
 
 #endif // SWIFT_SILOPTIMIZER_UTILS_CANONICALIZEBORROWSCOPES_H

lib/AST/ClangTypeConverter.cpp

@@ -545,7 +545,8 @@ ClangTypeConverter::visitBoundGenericType(BoundGenericType *type) {
     auto args = type->getGenericArgs();
     assert((args.size() == 1) && "Optional should have 1 generic argument.");
     clang::QualType innerTy = convert(args[0]);
-    if (swift::canImportAsOptional(innerTy.getTypePtrOrNull()))
+    if (swift::canImportAsOptional(innerTy.getTypePtrOrNull()) ||
+        args[0]->isForeignReferenceType())
       return innerTy;
     return clang::QualType();
   }