Merge pull request #4544 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/Attr.h

@@ -1938,6 +1938,10 @@ class DerivativeAttr final
   friend TrailingObjects;
   friend class DerivativeAttrOriginalDeclRequest;
 
+  /// The declaration on which the `@derivative` attribute is declared.
+  /// May not be a valid declaration for `@derivative` attributes.
+  /// Resolved during parsing and deserialization.
+  Decl *OriginalDeclaration = nullptr;
   /// The base type for the referenced original declaration. This field is
   /// non-null only for parsed attributes that reference a qualified original
   /// declaration. This field is not serialized; type-checking uses it to
@@ -1991,6 +1995,12 @@ class DerivativeAttr final
                                 DeclNameRefWithLoc original,
                                 IndexSubset *parameterIndices);
 
+  Decl *getOriginalDeclaration() const { return OriginalDeclaration; }
+
+  /// Sets the original declaration on which this attribute is declared.
+  /// Should only be used by parsing and deserialization.
+  void setOriginalDeclaration(Decl *originalDeclaration);
+
   TypeRepr *getBaseTypeRepr() const { return BaseTypeRepr; }
   DeclNameRefWithLoc getOriginalFunctionName() const {
     return OriginalFunctionName;

include/swift/AST/Decl.h

@@ -6265,8 +6265,11 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   DerivativeFunctionConfigurationList *DerivativeFunctionConfigs = nullptr;
 
 public:
-  /// Get all derivative function configurations.
-  ArrayRef<AutoDiffConfig> getDerivativeFunctionConfigurations();
+  /// Get all derivative function configurations. If `lookInNonPrimarySources`
+  /// is true then lookup is done in non-primary sources as well. Note that
+  /// such lookup might end in cycles if done during sema stages.
+  ArrayRef<AutoDiffConfig>
+  getDerivativeFunctionConfigurations(bool lookInNonPrimarySources = true);
 
   /// Add the given derivative function configuration.
   void addDerivativeFunctionConfiguration(const AutoDiffConfig &config);

include/swift/Basic/SourceManager.h

@@ -16,6 +16,7 @@
 #include "swift/Basic/FileSystem.h"
 #include "swift/Basic/SourceLoc.h"
 #include "clang/Basic/FileManager.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/SourceMgr.h"
 #include <map>
@@ -55,6 +56,10 @@ class SourceManager {
   /// reusing compilation.
   llvm::DenseMap<SourceRange, SourceRange> ReplacedRanges;
 
+  /// The starting source locations of regex literals written in source. This
+  /// is an unfortunate hack needed to allow for correct re-lexing.
+  llvm::DenseSet<SourceLoc> RegexLiteralStartLocs;
+
   std::map<const char *, VirtualFile> VirtualFiles;
   mutable std::pair<const char *, const VirtualFile*> CachedVFile = {nullptr, nullptr};
 
@@ -107,6 +112,17 @@ class SourceManager {
     ReplacedRanges[Orig] = New;
   }
 
+  /// Record the starting source location of a regex literal.
+  void recordRegexLiteralStartLoc(SourceLoc loc) {
+    RegexLiteralStartLocs.insert(loc);
+  }
+
+  /// Checks whether a given source location is for the start of a regex
+  /// literal.
+  bool isRegexLiteralStart(SourceLoc loc) const {
+    return RegexLiteralStartLocs.contains(loc);
+  }
+
   /// Returns true if \c LHS is before \c RHS in the source buffer.
   bool isBeforeInBuffer(SourceLoc LHS, SourceLoc RHS) const {
     return LHS.Value.getPointer() < RHS.Value.getPointer();

lib/AST/Attr.cpp

@@ -2107,6 +2107,13 @@ void DerivativeAttr::setOriginalFunctionResolver(
   ResolverContextData = resolverContextData;
 }
 
+void DerivativeAttr::setOriginalDeclaration(Decl *originalDeclaration) {
+  assert(originalDeclaration && "Original declaration must be non-null");
+  assert(!OriginalDeclaration &&
+         "Original declaration cannot have already been set");
+  OriginalDeclaration = originalDeclaration;
+}
+
 TransposeAttr::TransposeAttr(bool implicit, SourceLoc atLoc,
                              SourceRange baseRange, TypeRepr *baseTypeRepr,
                              DeclNameRefWithLoc originalName,

lib/AST/Decl.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/ASTMangler.h"
+#include "swift/AST/Attr.h"
 #include "swift/AST/CaptureInfo.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSema.h"
@@ -8311,7 +8312,7 @@ void AbstractFunctionDecl::prepareDerivativeFunctionConfigurations() {
 }
 
 ArrayRef<AutoDiffConfig>
-AbstractFunctionDecl::getDerivativeFunctionConfigurations() {
+AbstractFunctionDecl::getDerivativeFunctionConfigurations(bool lookInNonPrimarySources) {
   prepareDerivativeFunctionConfigurations();
 
   // Resolve derivative function configurations from `@differentiable`
@@ -8334,6 +8335,37 @@ AbstractFunctionDecl::getDerivativeFunctionConfigurations() {
     ctx.loadDerivativeFunctionConfigurations(this, previousGeneration,
                                              *DerivativeFunctionConfigs);
   }
+
+  class DerivativeFinder : public ASTWalker {
+    const AbstractFunctionDecl *AFD;
+  public:
+    DerivativeFinder(const AbstractFunctionDecl *afd) : AFD(afd) {}
+
+    bool walkToDeclPre(Decl *D) override {
+      if (auto *afd = dyn_cast<AbstractFunctionDecl>(D)) {
+        for (auto *derAttr : afd->getAttrs().getAttributes<DerivativeAttr>()) {
+          // Resolve derivative function configurations from `@derivative`
+          // attributes by type-checking them.
+          if (AFD->getName().matchesRef(
+                derAttr->getOriginalFunctionName().Name.getFullName())) {
+            (void)derAttr->getOriginalFunction(afd->getASTContext());
+            return false;
+          }
+        }
+      }
+
+      return true;
+    }
+  };
+
+  // Load derivative configurations from @derivative attributes defined in
+  // non-primary sources. Note that it might trigger lookup cycles if called
+  // from inside Sema stages.
+  if (lookInNonPrimarySources) {
+    DerivativeFinder finder(this);
+    getParent()->walkContext(finder);
+  }
+
   return DerivativeFunctionConfigs->getArrayRef();
 }
 

lib/IDE/CodeCompletionResultPrinter.cpp

@@ -496,6 +496,10 @@ static void printCodeCompletionResultFilterName(
       case ChunkKind::DeclIntroducer:
         ++i;
         continue;
+      case ChunkKind::ParameterDeclExternalName:
+        // Skip '_' parameter external name.
+        shouldPrint = shouldPrint && C.hasText() && C.getText() != "_";
+        break;
       case ChunkKind::CallArgumentTypeBegin:
       case ChunkKind::ParameterDeclTypeBegin:
       case ChunkKind::TypeAnnotationBegin:

lib/Parse/Lexer.cpp

@@ -2677,6 +2677,16 @@ Token Lexer::getTokenAtLocation(const SourceManager &SM, SourceLoc Loc,
   // we need to lex just the comment token.
   Lexer L(FakeLangOpts, SM, BufferID, nullptr, LexerMode::Swift,
           HashbangMode::Allowed, CRM);
+
+  if (SM.isRegexLiteralStart(Loc)) {
+    // HACK: If this was previously lexed as a regex literal, make sure we
+    // re-lex with forward slash regex literals enabled to make sure we get an
+    // accurate length. We can force EnableExperimentalStringProcessing on, as
+    // we know it must have been enabled to parse the regex in the first place.
+    FakeLangOpts.EnableExperimentalStringProcessing = true;
+    L.ForwardSlashRegexMode = LexerForwardSlashRegexMode::Always;
+  }
+
   L.restoreState(State(Loc));
   return L.peekNextToken();
 }

lib/Parse/ParseDecl.cpp

@@ -4457,6 +4457,8 @@ setOriginalDeclarationForDifferentiableAttributes(DeclAttributes attrs,
                                                   Decl *D) {
   for (auto *attr : attrs.getAttributes<DifferentiableAttr>())
     const_cast<DifferentiableAttr *>(attr)->setOriginalDeclaration(D);
+  for (auto *attr : attrs.getAttributes<DerivativeAttr>())
+    const_cast<DerivativeAttr *>(attr)->setOriginalDeclaration(D);
 }
 
 /// Parse a single syntactic declaration and return a list of decl

lib/Parse/ParseRegex.cpp

@@ -54,6 +54,8 @@ ParserResult<Expr> Parser::parseExprRegexLiteral() {
                             /*diagBaseLoc*/ getBridgedSourceLoc(Tok.getLoc()),
                             getBridgedDiagnosticEngine(&Diags));
   auto loc = consumeToken();
+  SourceMgr.recordRegexLiteralStartLoc(loc);
+
   if (hadError) {
     return makeParserResult(new (Context) ErrorExpr(loc));
   }

lib/SIL/IR/SILPrinter.cpp

@@ -2774,6 +2774,10 @@ void SILInstruction::print(raw_ostream &OS) const {
   SILPrinter(Ctx).print(this);
 }
 
+void NonSingleValueInstruction::dump() const {
+  SILNode::dump();
+}
+
 /// Pretty-print the SILBasicBlock to errs.
 void SILBasicBlock::dump() const {
   print(llvm::errs());

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -1801,13 +1801,17 @@ void swift::salvageDebugInfo(SILInstruction *I) {
 
   if (auto *SI = dyn_cast<StoreInst>(I)) {
     if (SILValue DestVal = SI->getDest())
-      // TODO: Generalize this into "get the attached debug info
-      // on `DestVal`".
       if (auto *ASI = dyn_cast_or_null<AllocStackInst>(
               DestVal.getDefiningInstruction())) {
-        if (auto VarInfo = ASI->getVarInfo())
+        if (auto VarInfo = ASI->getVarInfo()) {
+          // Always propagate destination location for incoming arguments (as
+          // their location must be unique) as well as when store source
+          // location is compiler-generated.
+          bool UseDestLoc = VarInfo->ArgNo || SI->getLoc().isAutoGenerated();
           SILBuilder(SI, ASI->getDebugScope())
-              .createDebugValue(SI->getLoc(), SI->getSrc(), *VarInfo);
+            .createDebugValue(UseDestLoc ? ASI->getLoc() : SI->getLoc(),
+                              SI->getSrc(), *VarInfo);
+        }
       }
   }
 

lib/Sema/PlaygroundTransform.cpp

@@ -576,12 +576,14 @@ class Instrumenter : InstrumenterBase {
       } else if (auto *D = Element.dyn_cast<Decl *>()) {
         D->walk(CF);
         if (auto *PBD = dyn_cast<PatternBindingDecl>(D)) {
-          if (VarDecl *VD = PBD->getSingleVar()) {
-            if (VD->getParentInitializer()) {
-              Added<Stmt *> Log = logVarDecl(VD);
-              if (*Log) {
-                Elements.insert(Elements.begin() + (EI + 1), *Log);
-                ++EI;
+          if (!PBD->isAsyncLet()) {
+            if (VarDecl *VD = PBD->getSingleVar()) {
+              if (VD->getParentInitializer()) {
+                Added<Stmt *> Log = logVarDecl(VD);
+                if (*Log) {
+                  Elements.insert(Elements.begin() + (EI + 1), *Log);
+                  ++EI;
+                }
               }
             }
           }

lib/Sema/TypeCheckAttr.cpp

@@ -4956,10 +4956,11 @@ void AttributeChecker::visitDifferentiableAttr(DifferentiableAttr *attr) {
 /// - Stores the attribute in `ASTContext::DerivativeAttrs`.
 ///
 /// \returns true on error, false on success.
-static bool typeCheckDerivativeAttr(ASTContext &Ctx, Decl *D,
-                                    DerivativeAttr *attr) {
+static bool typeCheckDerivativeAttr(DerivativeAttr *attr) {
   // Note: Implementation must be idempotent because it may be called multiple
   // times for the same attribute.
+  Decl *D = attr->getOriginalDeclaration();
+  auto &Ctx = D->getASTContext();
   auto &diags = Ctx.Diags;
   // `@derivative` attribute requires experimental differentiable programming
   // to be enabled.
@@ -5372,13 +5373,18 @@ static bool typeCheckDerivativeAttr(ASTContext &Ctx, Decl *D,
 }
 
 void AttributeChecker::visitDerivativeAttr(DerivativeAttr *attr) {
-  if (typeCheckDerivativeAttr(Ctx, D, attr))
+  if (typeCheckDerivativeAttr(attr))
     attr->setInvalid();
 }
 
 AbstractFunctionDecl *
 DerivativeAttrOriginalDeclRequest::evaluate(Evaluator &evaluator,
                                             DerivativeAttr *attr) const {
+  // Try to resolve the original function.
+  if (attr->isValid() && attr->OriginalFunction.isNull())
+    if (typeCheckDerivativeAttr(attr))
+      attr->setInvalid();
+
   // If the typechecker has resolved the original function, return it.
   if (auto *FD = attr->OriginalFunction.dyn_cast<AbstractFunctionDecl *>())
     return FD;

lib/Sema/TypeCheckProtocol.cpp

@@ -379,7 +379,8 @@ matchWitnessDifferentiableAttr(DeclContext *dc, ValueDecl *req,
     bool foundExactConfig = false;
     Optional<AutoDiffConfig> supersetConfig = None;
     for (auto witnessConfig :
-         witnessAFD->getDerivativeFunctionConfigurations()) {
+           witnessAFD->getDerivativeFunctionConfigurations(
+             /*lookInNonPrimarySources*/ false)) {
       // All the witness's derivative generic requirements must be satisfied
       // by the requirement's derivative generic requirements OR by the
       // conditional conformance requirements.

lib/Serialization/DeclTypeRecordNodes.def

@@ -91,7 +91,6 @@ TYPE(METATYPE)
 TYPE(PRIMARY_ARCHETYPE)
 TYPE(OPENED_ARCHETYPE)
 TYPE(OPAQUE_ARCHETYPE)
-TYPE(NESTED_ARCHETYPE)
 TYPE(SEQUENCE_ARCHETYPE)
 TYPE(PROTOCOL_COMPOSITION)
 TYPE(PARAMETERIZED_PROTOCOL)
@@ -107,7 +106,6 @@ TYPE(OPTIONAL)
 TYPE(VARIADIC_SEQUENCE)
 TYPE(SIL_FUNCTION)
 TYPE(DYNAMIC_SELF)
-TYPE(OPENED_EXISTENTIAL)
 TYPE(EXISTENTIAL_METATYPE)
 TYPE(SIL_BLOCK_STORAGE)
 TYPE(SIL_BOX)