Merge pull request #5493 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/DiagnosticsSema.def

@@ -4616,6 +4616,9 @@ ERROR(unknown_case_multiple_patterns,none,
 ERROR(unknown_case_must_be_last,none,
       "'@unknown' can only be applied to the last case in a switch", ())
 
+WARNING(move_only_pattern_match_not_consumed,none,
+        "noncopyable binding being pattern-matched must have the 'consume' operator applied", ())
+
 WARNING(where_on_one_item, none,
         "'where' only applies to the second pattern match in this case", ())
 

include/swift/SIL/SILBuilder.h

@@ -413,18 +413,18 @@ class SILBuilder {
   AllocStackInst *createAllocStack(SILLocation Loc, SILType elementType,
                                    Optional<SILDebugVariable> Var = None,
                                    bool hasDynamicLifetime = false,
-                                   bool isLexical = false, bool wasMoved = false
-#ifndef NDEBUG
-                                   ,
+                                   bool isLexical = false,
+                                   bool wasMoved = false,
                                    bool skipVarDeclAssert = false
-#endif
   ) {
     llvm::SmallString<4> Name;
     Loc.markAsPrologue();
 #ifndef NDEBUG
     if (dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()))
       assert((skipVarDeclAssert || Loc.isSynthesizedAST() || Var) &&
              "location is a VarDecl, but SILDebugVariable is empty");
+#else
+    (void)skipVarDeclAssert;
 #endif
     return insert(AllocStackInst::create(
         getSILDebugLocation(Loc, true), elementType, getFunction(),
@@ -473,19 +473,20 @@ class SILBuilder {
     return createAllocBox(loc, SILBoxType::get(fieldType.getASTType()), Var,
                           hasDynamicLifetime, reflection,
                           usesMoveableValueDebugInfo,
-                          /*skipVarDeclAssert*/ false, hasPointerEscape);
+                          /*skipVarDeclAssert*/ false,
+                          hasPointerEscape);
   }
 
   AllocBoxInst *createAllocBox(SILLocation Loc, CanSILBoxType BoxType,
                                Optional<SILDebugVariable> Var = None,
                                bool hasDynamicLifetime = false,
                                bool reflection = false,
-                               bool usesMoveableValueDebugInfo = false
-#ifndef NDEBUG
-                               ,
+                               bool usesMoveableValueDebugInfo = false,
                                bool skipVarDeclAssert = false,
-#endif
                                bool hasPointerEscape = false) {
+#if NDEBUG
+    (void)skipVarDeclAssert;
+#endif
     llvm::SmallString<4> Name;
     Loc.markAsPrologue();
     assert((skipVarDeclAssert ||

lib/AST/Module.cpp

@@ -403,6 +403,13 @@ void SourceLookupCache::populateAuxiliaryDeclCache() {
     for (auto macroNames : introducedNames) {
       auto macroRef = macroNames.getFirst();
       for (auto name : macroNames.getSecond()) {
+
+        // If this macro isn't in a module-scope context, and the introduced
+        // name isn't an operator, we shouldn't be able to see it.
+        if (!decl->getDeclContext()->isModuleScopeContext() &&
+            !name.getBaseName().isOperator())
+          continue;
+
         auto *placeholder = MissingDecl::forUnexpandedMacro(macroRef, decl);
         name.addToLookupTable(TopLevelAuxiliaryDecls, placeholder);
       }
@@ -485,6 +492,12 @@ void SourceLookupCache::lookupValue(DeclName Name, NLKind LookupKind,
   for (auto *unexpandedDecl : unexpandedDecls) {
     unexpandedDecl->forEachMacroExpandedDecl(
         [&](ValueDecl *decl) {
+          // If the declaration is not a module-scope declaration, and
+          // isn't an operator, ignore it.
+          if (!decl->getDeclContext()->isModuleScopeContext() &&
+              !decl->getName().getBaseName().isOperator())
+            return;
+
           if (decl->getName().matchesRef(Name)) {
             if (macroExpandedDecls.insert(decl).second)
               Result.push_back(decl);

lib/ClangImporter/ClangImporter.cpp

@@ -5049,7 +5049,8 @@ DeclAttributes cloneImportedAttributes(ValueDecl *decl, ASTContext &context) {
   return attrs;
 }
 
-ValueDecl *cloneBaseMemberDecl(ValueDecl *decl, DeclContext *newContext) {
+static ValueDecl *
+cloneBaseMemberDecl(ValueDecl *decl, DeclContext *newContext) {
   if (auto fn = dyn_cast<FuncDecl>(decl)) {
     // TODO: function templates are specialized during type checking so to
     // support these we need to tell Swift to type check the synthesized bodies.
@@ -6333,16 +6334,23 @@ Decl *ClangImporter::importDeclDirectly(const clang::NamedDecl *decl) {
   return Impl.importDecl(decl, Impl.CurrentVersion);
 }
 
-ValueDecl *ClangImporter::importBaseMemberDecl(ValueDecl *decl,
-                                               DeclContext *newContext) {
+ValueDecl *ClangImporter::Implementation::importBaseMemberDecl(
+    ValueDecl *decl, DeclContext *newContext) {
   // Make sure we don't clone the decl again for this class, as that would
   // result in multiple definitions of the same symbol.
   std::pair<ValueDecl *, DeclContext *> key = {decl, newContext};
-  if (!Impl.clonedBaseMembers.count(key)) {
+  auto known = clonedBaseMembers.find(key);
+  if (known == clonedBaseMembers.end()) {
     ValueDecl *cloned = cloneBaseMemberDecl(decl, newContext);
-    Impl.clonedBaseMembers[key] = cloned;
+    known = clonedBaseMembers.insert({key, cloned}).first;
   }
-  return Impl.clonedBaseMembers[key];
+
+  return known->second;
+}
+
+ValueDecl *ClangImporter::importBaseMemberDecl(ValueDecl *decl,
+                                               DeclContext *newContext) {
+  return Impl.importBaseMemberDecl(decl, newContext);
 }
 
 void ClangImporter::diagnoseTopLevelValue(const DeclName &name) {

lib/ClangImporter/ImportDecl.cpp

@@ -3581,6 +3581,12 @@ namespace {
       if (!dc)
         return nullptr;
 
+      // While importing the DeclContext, we might have imported the decl
+      // itself.
+      auto known = Impl.importDeclCached(decl, getVersion());
+      if (known.has_value())
+        return known.value();
+
       // TODO: do we want to emit a diagnostic here?
       // Types that are marked as foreign references cannot be stored by value.
       if (auto recordType =
@@ -8761,8 +8767,6 @@ static void loadAllMembersOfSuperclassIfNeeded(ClassDecl *CD) {
     E->loadAllMembers();
 }
 
-ValueDecl *cloneBaseMemberDecl(ValueDecl *decl, DeclContext *newContext);
-
 void ClangImporter::Implementation::loadAllMembersOfRecordDecl(
     NominalTypeDecl *swiftDecl, const clang::RecordDecl *clangRecord) {
   // Import all of the members.
@@ -8793,7 +8797,7 @@ void ClangImporter::Implementation::loadAllMembersOfRecordDecl(
     // This means we found a member in a C++ record's base class.
     if (swiftDecl->getClangDecl() != clangRecord) {
       // So we need to clone the member into the derived class.
-      if (auto newDecl = cloneBaseMemberDecl(cast<ValueDecl>(member), swiftDecl)) {
+      if (auto newDecl = importBaseMemberDecl(cast<ValueDecl>(member), swiftDecl)) {
         swiftDecl->addMember(newDecl);
       }
       continue;

lib/ClangImporter/ImporterImpl.h

@@ -642,10 +642,14 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   llvm::MapVector<std::pair<NominalTypeDecl *, Type>,
                   std::pair<FuncDecl *, FuncDecl *>> cxxSubscripts;
 
+private:
   // Keep track of the decls that were already cloned for this specific class.
   llvm::DenseMap<std::pair<ValueDecl *, DeclContext *>, ValueDecl *>
       clonedBaseMembers;
 
+  ValueDecl *importBaseMemberDecl(ValueDecl *decl, DeclContext *newContext);
+
+public:
   // Cache for already-specialized function templates and any thunks they may
   // have.
   llvm::DenseMap<clang::FunctionDecl *, ValueDecl *>

lib/SILGen/SILGenExpr.cpp

@@ -6183,6 +6183,11 @@ RValue RValueEmitter::visitConsumeExpr(ConsumeExpr *E, SGFContext C) {
     mv = SGF.B.createMoveValue(E, mv);
     // Set the flag so we check this.
     cast<MoveValueInst>(mv.getValue())->setAllowsDiagnostics(true);
+    if (subType.isMoveOnly()) {
+      // We need to move-only-check the moved value.
+      mv = SGF.B.createMarkMustCheckInst(E, mv,
+                         MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
+    }
     return RValue(SGF, {mv}, subType.getASTType());
   }
 

lib/SILOptimizer/Mandatory/MoveOnlyObjectCheckerUtils.cpp

@@ -133,12 +133,10 @@ bool swift::siloptimizer::searchForCandidateObjectMarkMustChecks(
           }
         }
 
-        // Any time we have a lexical move_value, we can process it.
+        // Any time we have a move_value, we can process it.
         if (auto *mvi = dyn_cast<MoveValueInst>(mmci->getOperand())) {
-          if (mvi->isLexical()) {
-            moveIntroducersToProcess.insert(mmci);
-            continue;
-          }
+          moveIntroducersToProcess.insert(mmci);
+          continue;
         }
 
         if (auto *arg = dyn_cast<SILFunctionArgument>(mmci->getOperand())) {

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -526,6 +526,22 @@ static void replaceProjectBoxUsers(SILValue heapBox, SILValue stackBox) {
   }
 }
 
+static void replaceAllNonDebugUsesWith(SILValue value,
+                                       SILValue with) {
+  auto useI = value->use_begin();
+  while (useI != value->use_end()) {
+    Operand *op = *useI;
+    ++useI;
+    // Leave debug instructions on the original value.
+    if (op->getUser()->isDebugInstruction()) {
+      continue;
+    }
+    
+    // Rewrite all other uses.
+    op->set(with);
+  }
+}
+
 static void hoistMarkMustCheckInsts(SILValue stackBox,
                                     MarkMustCheckInst::CheckKind checkKind) {
   StackList<Operand *> worklist(stackBox->getFunction());
@@ -571,7 +587,9 @@ static void hoistMarkMustCheckInsts(SILValue stackBox,
   auto *undef = SILUndef::get(stackBox->getType(), *stackBox->getModule());
 
   auto *mmci = builder.createMarkMustCheckInst(loc, undef, checkKind);
-  stackBox->replaceAllUsesWith(mmci);
+  // Leave debug uses on the to-be-promoted box, but hoist all other uses to the
+  // new mark_must_check.
+  replaceAllNonDebugUsesWith(stackBox, mmci);
   mmci->setOperand(stackBox);
 }
 

lib/Sema/MiscDiagnostics.cpp

@@ -4052,9 +4052,40 @@ void swift::performAbstractFuncDeclDiagnostics(AbstractFunctionDecl *AFD) {
   }
 }
 
+static void
+diagnoseMoveOnlyPatternMatchSubject(ASTContext &C,
+                                    Expr *subjectExpr) {
+  // For now, move-only types must use the `consume` operator to be
+  // pattern matched. Pattern matching is only implemented as a consuming
+  // operation today, but we don't want to be stuck with that as the default
+  // in the fullness of time when we get borrowing pattern matching later.
+  
+  // Don't bother if the subject wasn't given a valid type, or is a copyable
+  // type.
+  auto subjectType = subjectExpr->getType();
+  if (!subjectType
+      || subjectType->hasError()
+      || !subjectType->isPureMoveOnly()) {
+    return;
+  }
+
+  // A bare reference to, or load from, a move-only binding must be consumed.
+  subjectExpr = subjectExpr->getSemanticsProvidingExpr();
+  if (auto load = dyn_cast<LoadExpr>(subjectExpr)) {
+    subjectExpr = load->getSubExpr()->getSemanticsProvidingExpr();
+  }
+  if (isa<DeclRefExpr>(subjectExpr)) {
+    C.Diags.diagnose(subjectExpr->getLoc(),
+                           diag::move_only_pattern_match_not_consumed)
+      .fixItInsert(subjectExpr->getStartLoc(), "consume ");
+  }
+}
+
 // Perform MiscDiagnostics on Switch Statements.
 static void checkSwitch(ASTContext &ctx, const SwitchStmt *stmt,
                         DeclContext *DC) {
+  diagnoseMoveOnlyPatternMatchSubject(ctx, stmt->getSubjectExpr());
+                        
   // We want to warn about "case .Foo, .Bar where 1 != 100:" since the where
   // clause only applies to the second case, and this is surprising.
   for (auto cs : stmt->getCases()) {
@@ -4816,7 +4847,9 @@ static void checkLabeledStmtConditions(ASTContext &ctx,
 
     switch (elt.getKind()) {
     case StmtConditionElement::CK_Boolean:
+      break;
     case StmtConditionElement::CK_PatternBinding:
+      diagnoseMoveOnlyPatternMatchSubject(ctx, elt.getInitializer());
       break;
     case StmtConditionElement::CK_Availability: {
       auto info = elt.getAvailability();

lib/Sema/TypeCheckStmt.cpp

@@ -876,6 +876,7 @@ bool TypeChecker::typeCheckStmtConditionElement(StmtConditionElement &elt,
   bool hadError = TypeChecker::typeCheckBinding(pattern, init, dc, patternType);
   elt.setPattern(pattern);
   elt.setInitializer(init);
+  
   isFalsable |= pattern->isRefutablePattern();
   return hadError;
 }

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -1531,3 +1531,37 @@ public struct UseIdentifierMacro: DeclarationMacro {
     ]
   }
 }
+
+public struct StaticFooFuncMacro: DeclarationMacro {
+  public static func expansion(
+    of node: some FreestandingMacroExpansionSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    return [
+      "static func foo() {}",
+    ]
+  }
+}
+
+public struct SelfAlwaysEqualOperator: DeclarationMacro {
+  public static func expansion(
+    of node: some FreestandingMacroExpansionSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    return [
+      "static func ==(lhs: Self, rhs: Bool) -> Bool { true }",
+    ]
+  }
+}
+
+extension SelfAlwaysEqualOperator: MemberMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingMembersOf decl: some DeclGroupSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    return [
+      "static func ==(lhs: Self, rhs: Bool) -> Bool { true }",
+    ]
+  }
+}

test/Macros/macro_expand.swift

@@ -425,3 +425,58 @@ func testLocalVarsFromDeclarationMacros() {
 struct TakesVariadic {
   #emptyDecl("foo", "bar")
 }
+
+// Funkiness with static functions introduced via macro expansions.
+@freestanding(declaration, names: named(foo())) public macro staticFooFunc() = #externalMacro(module: "MacroDefinition", type: "StaticFooFuncMacro")
+@freestanding(declaration, names: arbitrary) public macro staticFooFuncArbitrary() = #externalMacro(module: "MacroDefinition", type: "StaticFooFuncMacro")
+
+class HasAnExpandedStatic {
+  #staticFooFunc()
+}
+
+class HasAnExpandedStatic2 {
+  #staticFooFuncArbitrary()
+}
+
+func testHasAnExpandedStatic() {
+#if TEST_DIAGNOSTICS
+  foo() // expected-error{{cannot find 'foo' in scope}}
+#endif
+}
+
+@freestanding(declaration, names: named(==)) public macro addSelfEqualsOperator() = #externalMacro(module: "MacroDefinition", type: "SelfAlwaysEqualOperator")
+@freestanding(declaration, names: arbitrary) public macro addSelfEqualsOperatorArbitrary() = #externalMacro(module: "MacroDefinition", type: "SelfAlwaysEqualOperator")
+@attached(member, names: named(==)) public macro AddSelfEqualsMemberOperator() = #externalMacro(module: "MacroDefinition", type: "SelfAlwaysEqualOperator")
+@attached(member, names: arbitrary) public macro AddSelfEqualsMemberOperatorArbitrary() = #externalMacro(module: "MacroDefinition", type: "SelfAlwaysEqualOperator")
+
+struct HasEqualsSelf {
+  #addSelfEqualsOperator
+}
+
+struct HasEqualsSelf2 {
+  #addSelfEqualsOperatorArbitrary
+}
+
+@AddSelfEqualsMemberOperator
+struct HasEqualsSelf3 {
+}
+
+@AddSelfEqualsMemberOperatorArbitrary
+struct HasEqualsSelf4 {
+}
+
+func testHasEqualsSelf(
+  x: HasEqualsSelf, y: HasEqualsSelf2, z: HasEqualsSelf3, w: HasEqualsSelf4
+) {
+  _ = (x == true)
+  _ = (y == true)
+#if TEST_DIAGNOSTICS
+  // FIXME: This is technically a bug, because we should be able to find the
+  // == operator introduced through a member operator. However, we might
+  // want to change the rule rather than implement this.
+  _ = (z == true) // expected-error{{binary operator '==' cannot be applied to operands}}
+  // expected-note@-1{{overloads for '==' exist with these partially matching parameter lists}}
+  _ = (w == true) // expected-error{{binary operator '==' cannot be applied to operands}}
+  // expected-note@-1{{overloads for '==' exist with these partially matching parameter lists}}
+  #endif
+}