Merge pull request #4423 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

docs/CppInteroperability/CppInteroperabilityStatus.md

@@ -108,7 +108,7 @@ Unless stated otherwise (i.e., imported reference types) all Swift features work
 
 ### C++ Standard Library Support
 
-Parts of libc++ can be imported and used from Swift.
+Parts of libc++ can be imported and used from Swift. C++ standard library types are bridged directly to Swift, and there is not automatic bridging to native Swift types. This means that if an imported C++ API returns `std::string`, you will get a `std::string` value in Swift as well, and not Swift's `String`.
 
 This status table describes which of the following C++ standard library features have some experimental support for using them in Swift. Please note that this is not a comprehensive list and other libc++ APIs that use the above supported C++ language features could be imported into Swift.
 

docs/CppInteroperability/InteropOddities.md

@@ -0,0 +1,23 @@
+# C++ Interoperability Oddities
+
+C++ APIs may have slightly different behavior than other C++ APIs. This is a general catch-all document where these 
+oddities are recorded along with a few other things that are good to know when using C++ interop.
+
+**Parameters with reference types**
+
+Parameters that have mutable reference types are bridged as inout. Parameters with immutable reference types (const ref) 
+are bridged as value types. ⚠️ This will change as soon as Swift has a way to represent immutable borrows. ⚠️ 
+
+**Lifetimes**
+
+Currently, lifetimes are extended to the end of the lexical scope if any unsafe pointers are used in that scope. TODO: 
+this should be updated to extend lifetimes whenever a C++ type is used in that scope. Currently, if there is no 
+unsafe pointer used in teh scope, then normal Swift lifetime rules apply.   
+
+**Borrowing Self**
+
+For mutating methods, self is borrowed and the access to self lasts for the duration of the call. For non-mutating 
+methods, the access to self is currently instantanious. ⚠️ In the very near future we plan to borrow self in both cases. 
+This will be a source breaking change from what native Swift methods do. ⚠️
+
+_More to come soon :)_

docs/HowToGuides/GettingStarted.md

@@ -25,6 +25,7 @@ toolchain as a one-off, there are a couple of differences:
 - [Editing code](#editing-code)
   - [Setting up your fork](#setting-up-your-fork)
   - [First time Xcode setup](#first-time-xcode-setup)
+  - [Other IDEs setup](#other-ides-setup)
   - [Editing](#editing)
   - [Incremental builds with Ninja](#incremental-builds-with-ninja)
   - [Incremental builds with Xcode](#incremental-builds-with-xcode)
@@ -358,6 +359,28 @@ select the following schemes:
   run.
 <!-- TODO: Insert SourceKit/stdlib specific instructions? -->
 
+### Other IDEs setup
+
+You can also use other editors and IDEs to work on Swift.
+
+#### IntelliJ CLion
+
+CLion supports CMake and Ninja. In order to configure it properly, build the swift project first using the `build-script`, then open the `swift` directory with CLion and proceed to project settings (`cmd + ,`).
+
+In project settings, locate `Build, Execution, Deployment > CMake`. You will need to create a new profile named `RelWithDebInfoAssert` (or `Debug` if going to point it at the debug build). Enter the following information:
+
+- Name: mirror the name of the build configuration here, e.g. `RelWithDebInfoAssert` or `Debug`
+- Build type: This corresponds to `CMAKE_BUILD_TYPE` so should be e.g. `RelWithDebInfoAssert` or `Debug`
+    - latest versions of the IDE suggest valid values here. Generally `RelWithDebInfoAssert` is a good one to work with
+- Toolchain: Default should be fine
+- Generator: Ninja
+- CMake options:
+    - `-D SWIFT_PATH_TO_CMARK_BUILD=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/cmark-macosx-arm64 -D LLVM_DIR=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/llvm-macosx-arm64/lib/cmake/llvm -D Clang_DIR=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/llvm-macosx-arm64/lib/cmake/clang -D CMAKE_BUILD_TYPE=RelWithDebInfoAssert -G Ninja -S .`
+    - replace the `SOME_PATH` to the path where your `swift-project` directory is
+    - the CMAKE_BUILD_TYPE should match the build configuration name, so if you named this profile `RelWithDebInfo` the CMAKE_BUILD_TYPE should also be `RelWithDebInfo`
+
+With this done, CLion should be able to successfully import the project and have full autocomplete and code navigation powers.
+
 ### Editing
 
 Make changes to the code as appropriate. Implement a shiny new feature!

include/swift/AST/TypeCheckRequests.h

@@ -604,7 +604,6 @@ struct WhereClauseOwner {
     return !(lhs == rhs);
   }
 
-public:
   /// Retrieve the array of requirements.
   MutableArrayRef<RequirementRepr> getRequirements() const;
 
@@ -1903,8 +1902,7 @@ class InferredGenericSignatureRequest :
 /// InferredGenericSignatureRequest.
 class InferredGenericSignatureRequestRQM :
     public SimpleRequest<InferredGenericSignatureRequestRQM,
-                         GenericSignatureWithError (ModuleDecl *,
-                                                    const GenericSignatureImpl *,
+                         GenericSignatureWithError (const GenericSignatureImpl *,
                                                     GenericParamList *,
                                                     WhereClauseOwner,
                                                     SmallVector<Requirement, 2>,
@@ -1920,7 +1918,6 @@ class InferredGenericSignatureRequestRQM :
   // Evaluation.
   GenericSignatureWithError
   evaluate(Evaluator &evaluator,
-           ModuleDecl *parentModule,
            const GenericSignatureImpl *baseSignature,
            GenericParamList *genericParams,
            WhereClauseOwner whereClause,

include/swift/IDE/CodeCompletionResult.h

@@ -223,6 +223,7 @@ enum class CompletionKind : uint8_t {
   StmtLabel,
   ForEachPatternBeginning,
   TypeAttrBeginning,
+  OptionalBinding,
 };
 
 enum class CodeCompletionDiagnosticSeverity : uint8_t {

include/swift/IDE/CompletionLookup.h

@@ -33,12 +33,15 @@
 namespace swift {
 namespace ide {
 
-using DeclFilter = std::function<bool(ValueDecl *, DeclVisibilityKind)>;
+using DeclFilter =
+    std::function<bool(ValueDecl *, DeclVisibilityKind, DynamicLookupInfo)>;
 
 /// A filter that always returns \c true.
-bool DefaultFilter(ValueDecl *VD, DeclVisibilityKind Kind);
+bool DefaultFilter(ValueDecl *VD, DeclVisibilityKind Kind,
+                   DynamicLookupInfo dynamicLookupInfo);
 
-bool KeyPathFilter(ValueDecl *decl, DeclVisibilityKind);
+bool KeyPathFilter(ValueDecl *decl, DeclVisibilityKind,
+                   DynamicLookupInfo dynamicLookupInfo);
 
 /// Returns \c true only if the completion is happening for top-level
 /// declrarations. i.e.:
@@ -528,7 +531,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
         : Consumer(Consumer), Filter(Filter) {}
     void foundDecl(ValueDecl *VD, DeclVisibilityKind Kind,
                    DynamicLookupInfo dynamicLookupInfo) override {
-      if (Filter(VD, Kind))
+      if (Filter(VD, Kind, dynamicLookupInfo))
         Consumer.foundDecl(VD, Kind, dynamicLookupInfo);
     }
   };
@@ -588,6 +591,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
                                  bool ResultsHaveLeadingDot);
 
   void getStmtLabelCompletions(SourceLoc Loc, bool isContinue);
+
+  void getOptionalBindingCompletions(SourceLoc Loc);
 };
 
 } // end namespace ide

include/swift/Parse/CodeCompletionCallbacks.h

@@ -236,6 +236,8 @@ class CodeCompletionCallbacks {
 
   virtual void completeTypeAttrBeginning() {};
 
+  virtual void completeOptionalBinding(){};
+
   /// Signals that the AST for the all the delayed-parsed code was
   /// constructed.  No \c complete*() callbacks will be done after this.
   virtual void doneParsing() = 0;

lib/AST/DeclContext.cpp

@@ -85,10 +85,11 @@ ProtocolDecl *DeclContext::getExtendedProtocolDecl() const {
 
 VarDecl *DeclContext::getNonLocalVarDecl() const {
   if (auto *init = dyn_cast<PatternBindingInitializer>(this)) {
-   if (auto *var =
-         init->getBinding()->getAnchoringVarDecl(init->getBindingIndex())) {
-      return var;
-     }
+    if (auto binding = init->getBinding()) {
+      if (auto *var = binding->getAnchoringVarDecl(init->getBindingIndex())) {
+        return var;
+      }
+    }
   }
   return nullptr;
 }

lib/AST/GenericSignatureBuilder.cpp

@@ -8464,7 +8464,6 @@ InferredGenericSignatureRequest::evaluate(
     return evaluateOrDefault(
         ctx.evaluator,
         InferredGenericSignatureRequestRQM{
-          parentModule,
           parentSig,
           genericParams,
           whereClause,

lib/AST/RequirementMachine/KnuthBendix.cpp

@@ -157,8 +157,66 @@ RewriteSystem::computeCriticalPair(ArrayRef<Symbol>::const_iterator from,
       return false;
     }
 
-    // Add the pair (X, TYV).
-    pairs.emplace_back(x, tyv, path);
+    // If X == TUW for some W, then the critical pair is (TUW, TYV),
+    // and we have
+    // - lhs == (TUV => TUW)
+    // - rhs == (U => Y).
+    //
+    // We explicitly apply the rewrite step (Y => U) to the beginning of the
+    // rewrite path, transforming the critical pair to (TYW, TYV).
+    //
+    // In particular, if V == W.[P] for some protocol P, then we in fact have
+    // a property rule and a same-type rule:
+    //
+    // - lhs == (TUW.[P] => TUW)
+    // - rhs == (U => Y)
+    //
+    // Without this hack, the critical pair would be:
+    //
+    // (TUW => TYW.[P])
+    //
+    // With this hack, the critical pair becomes:
+    //
+    // (TYW.[P] => TYW)
+    //
+    // This ensures that the newly-added rule is itself a property rule;
+    // otherwise, this would only be the case if addRule() reduced TUW
+    // into TYW without immediately reducing some subterm of TUW first.
+    //
+    // While completion will eventually simplify all such rules down into
+    // property rules, their existance in the first place breaks subtle
+    // invariants in the minimal conformances algorithm, which expects
+    // homotopy generators describing redundant protocol conformance rules
+    // to have a certain structure.
+    if (t.size() + rhs.getLHS().size() <= x.size() &&
+        std::equal(rhs.getLHS().begin(),
+                   rhs.getLHS().end(),
+                   x.begin() + t.size())) {
+      // We have a path from TUW to TYV. Invert to get a path from TYV to
+      // TUW.
+      path.invert();
+
+      // Compute the term W.
+      MutableTerm w(x.begin() + t.size() + rhs.getLHS().size(), x.end());
+
+      // Now add a rewrite step T.(U => Y).W to get a path from TYV to
+      // TYW.
+      path.add(RewriteStep::forRewriteRule(/*startOffset=*/t.size(),
+                                           /*endOffset=*/w.size(),
+                                           getRuleID(rhs),
+                                           /*inverse=*/false));
+
+      // Compute the term TYW.
+      MutableTerm tyw(t);
+      tyw.append(rhs.getRHS());
+      tyw.append(w);
+
+      // Add the pair (TYV, TYW).
+      pairs.emplace_back(tyv, tyw, path);
+    } else {
+      // Add the pair (X, TYV).
+      pairs.emplace_back(x, tyv, path);
+    }
   } else {
     // lhs == TU -> X, rhs == UV -> Y.
 
@@ -217,7 +275,7 @@ RewriteSystem::computeCriticalPair(ArrayRef<Symbol>::const_iterator from,
     // - lhs == (TU -> X)
     // - rhs == (UV -> UW).
     //
-    // We explicitly apply the rewrite step (TU = X) to the rewrite path,
+    // We explicitly apply the rewrite step (TU => X) to the rewrite path,
     // transforming the critical pair to (XV, XW).
     //
     // In particular, if T == X, U == [P] for some protocol P, and
@@ -229,15 +287,15 @@ RewriteSystem::computeCriticalPair(ArrayRef<Symbol>::const_iterator from,
     //
     // Without this hack, the critical pair would be:
     //
-    // (T.w.[p] => T.[P].w)
+    // (T.W.[p] => T.[P].W)
     //
     // With this hack, the critical pair becomes:
     //
-    // (T.w.[p] => T.w)
+    // (T.W.[p] => T.W)
     //
     // This ensures that the newly-added rule is itself a property rule;
-    // otherwise, this would only be the case if addRule() reduced T.[P].w
-    // into T.w without immediately reducing some subterm of T first.
+    // otherwise, this would only be the case if addRule() reduced T.[P].W
+    // into T.W without immediately reducing some subterm of T first.
     //
     // While completion will eventually simplify all such rules down into
     // property rules, their existance in the first place breaks subtle