Merge pull request #2603 from swiftwasm/katei/merge-main-2021-01-29

Merge main 2021-01-29

Author: kateinoigakukun

CMakeLists.txt

@@ -336,10 +336,6 @@ set(SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS "2.0" CACHE STRING
 # User-configurable debugging options.
 #
 
-option(SWIFT_AST_VERIFIER
-    "Enable the AST verifier in the built compiler, and run it on every compilation"
-    TRUE)
-
 option(SWIFT_SIL_VERIFY_ALL
     "Run SIL verification after each transform when building Swift files in the build process"
     FALSE)

CODE_OWNERS.TXT

@@ -47,6 +47,11 @@ E: [email protected]
 G: rjmccall
 D: Demangler, IRGen, Runtime
 
+N: Victoria Mitchell
+E: [email protected]
+G: QuietMisdreavus
+D: SymbolGraphGen
+
 N: Max Moiseev
 E: [email protected]
 G: moiseev

docs/HowToGuides/GettingStarted.md

@@ -68,15 +68,17 @@ toolchain as a one-off, there are a couple of differences:
      If you plan on contributing regularly, cloning over SSH provides a better
      experience. After you've [uploaded your SSH keys to GitHub][]:
      ```sh
-     git clone [email protected]:apple/swift.git .
+     git clone [email protected]:apple/swift.git swift
+     cd swift
      utils/update-checkout --clone-with-ssh
      ```
    - Via HTTPS:
      If you want to check out the sources as read-only,
      or are not familiar with setting up SSH,
      you can use HTTPS instead:
      ```sh
-     git clone https://github.com/apple/swift.git .
+     git clone https://github.com/apple/swift.git swift
+     cd swift
      utils/update-checkout --clone
      ```
    **Note:** If you've already forked the project on GitHub at this stage,

docs/OptimizationTips.rst

@@ -245,7 +245,7 @@ this allows the compiler to elide unnecessary copies by retaining the container
 instead of performing a deep copy. This is done by only copying the underlying
 container if the reference count of the container is greater than 1 and the
 container is mutated. For instance in the following, no copying will occur when
-``d`` is assigned to ``c``, but when ``d`` undergoes structural mutation by
+``c`` is assigned to ``d``, but when ``d`` undergoes structural mutation by
 appending ``2``, ``d`` will be copied and then ``2`` will be appended to ``d``:
 
 ::

include/swift/ABI/Task.h

@@ -343,16 +343,16 @@ class AsyncTask : public HeapObject, public Job {
     };
 
     struct GroupStatus {
-        static const unsigned long maskReady      = 0x00FFFFF0000000000l;
-        static const unsigned long oneReadyTask   = 0x00000010000000000l;
+        static const uint64_t maskReady      = 0x00FFFFF0000000000ll;
+        static const uint64_t oneReadyTask   = 0x00000010000000000ll;
 
-        static const unsigned long maskPending    = 0x0000000FFFFF00000l;
-        static const unsigned long onePendingTask = 0x00000000000100000l;
+        static const uint64_t maskPending    = 0x0000000FFFFF00000ll;
+        static const uint64_t onePendingTask = 0x00000000000100000ll;
 
-        static const unsigned long maskWaiting    = 0x000000000000FFFFFl;
-        static const unsigned long oneWaitingTask = 0x00000000000000001l;
+        static const uint64_t maskWaiting    = 0x000000000000FFFFFll;
+        static const uint64_t oneWaitingTask = 0x00000000000000001ll;
 
-        unsigned long status;
+        uint64_t status;
 
         unsigned int readyTasks() {
           return (status & maskReady) >> 40;
@@ -436,7 +436,7 @@ class AsyncTask : public HeapObject, public Job {
     mutable std::mutex mutex;
 
     /// Used for queue management, counting number of waiting and ready tasks
-    std::atomic<unsigned long> status;
+    std::atomic<uint64_t> status;
 
     /// Queue containing completed tasks offered into this channel.
     ///

include/swift/AST/ASTContext.h

@@ -1154,6 +1154,10 @@ class ASTContext final {
   /// standard library's String implementation.
   bool isASCIIString(StringRef s) const;
 
+  /// Retrieve the name of to be used for the entry point, either main or an
+  /// alternative specified via the -entry-point-function-name frontend flag.
+  std::string getEntryPointFunctionName() const;
+
 private:
   friend Decl;
   Optional<RawComment> getRawComment(const Decl *D);

include/swift/AST/ClangModuleLoader.h

@@ -177,6 +177,16 @@ class ClangModuleLoader : public ModuleLoader {
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) = 0;
 
+  /// Instantiate and import class template using given arguments.
+  ///
+  /// This method will find the clang::ClassTemplateSpecialization decl if
+  /// it already exists, or it will create one. Then it will import this
+  /// decl the same way as we import typedeffed class templates - using
+  /// the hidden struct prefixed with `__CxxTemplateInst`.
+  virtual StructDecl *
+  instantiateCXXClassTemplate(clang::ClassTemplateDecl *decl,
+                      ArrayRef<clang::TemplateArgument> arguments) = 0;
+
   /// Try to parse the string as a Clang function type.
   ///
   /// Returns null if there was a parsing failure.

include/swift/AST/Decl.h

@@ -3402,6 +3402,42 @@ class EnumDecl final : public NominalTypeDecl {
 class StructDecl final : public NominalTypeDecl {
   SourceLoc StructLoc;
 
+  // We import C++ class templates as generic structs. Then when in Swift code
+  // we want to substitude generic parameters with actual arguments, we
+  // convert the arguments to C++ equivalents and ask Clang to instantiate the
+  // C++ template. Then we import the C++ class template instantiation
+  // as a non-generic structs with a name prefixed with `__CxxTemplateInst`.
+  //
+  // To reiterate:
+  // 1) We need to have a C++ class template declaration in the Clang AST. This
+  //    declaration is simply imported from a Clang module.
+  // 2) We need a Swift generic struct in the Swift AST. This will provide
+  //    template arguments to Clang.
+  // 3) We produce a C++ class template instantiation in the Clang AST
+  //    using 1) and 2). This declaration does not exist in the Clang module
+  //    AST initially in the general case, it's added there on instantiation.
+  // 4) We import the instantiation as a Swift struct, with the name prefixed
+  //    with `__CxxTemplateInst`.
+  //
+  // This causes a problem for serialization/deserialization of the Swift
+  // module. Imagine the Swift struct from 4) is used in the function return
+  // type. We cannot just serialize the non generic Swift struct, because on
+  // deserialization we would need to find its backing Clang declaration
+  // (the C++ class template instantiation), and it won't be found in the
+  // general case. Only the C++ class template from step 1) is in the Clang
+  // AST.
+  //
+  // What we need is to serialize enough information to be
+  // able to instantiate C++ class template on deserialization. It turns out
+  // that all that information is conveniently covered by the BoundGenericType,
+  // which we store in this field. The field is set during the typechecking at
+  // the time when we instantiate the C++ class template.
+  //
+  // Alternative, and likely better solution long term, is to serialize the
+  // C++ class template instantiation into a synthetic Clang module, and load
+  // this Clang module on deserialization.
+  Type TemplateInstantiationType = Type();
+
 public:
   StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
              ArrayRef<TypeLoc> Inherited,
@@ -3445,6 +3481,9 @@ class StructDecl final : public NominalTypeDecl {
   bool isCxxNonTrivial() const { return Bits.StructDecl.IsCxxNonTrivial; }
 
   void setIsCxxNonTrivial(bool v) { Bits.StructDecl.IsCxxNonTrivial = v; }
+
+  Type getTemplateInstantiationType() const { return TemplateInstantiationType; }
+  void setTemplateInstantiationType(Type t) { TemplateInstantiationType = t; }
 };
 
 /// This is the base type for AncestryOptions. Each flag describes possible

include/swift/AST/DiagnosticsParse.def

@@ -960,7 +960,6 @@ ERROR(snake_case_deprecated,none,
       "%0 has been replaced with %1 in Swift 3",
       (StringRef, StringRef))
 
-
 // Assignment statement
 ERROR(expected_expr_assignment,none,
       "expected expression in assignment", ())
@@ -988,6 +987,10 @@ NOTE(indent_expression_to_silence,none,
 ERROR(expected_expr_throw,PointsToFirstBadToken,
       "expected expression in 'throw' statement", ())
 
+// Await/Async
+ERROR(expected_await_not_async,none,
+      "found 'async' in expression; did you mean 'await'?", ())
+
 // Yield Statment
 ERROR(expected_expr_yield,PointsToFirstBadToken,
       "expected expression in 'yield' statement", ())

include/swift/AST/DiagnosticsSema.def

@@ -2788,6 +2788,10 @@ ERROR(unexportable_clang_function_type,none,
       "it may use anonymous types or types defined outside of a module",
       (Type))
 
+ERROR(cxx_class_instantiation_failed,none,
+      "couldn't instantiate a C++ class template",
+      ())
+
 WARNING(warn_implementation_only_conflict,none,
         "%0 inconsistently imported as implementation-only",
         (Identifier))