Merge branch 'main' into wip-fix-for-real-ptr-auth

Author: ktoso

SwiftCompilerSources/Sources/AST/Declarations.swift

@@ -124,6 +124,8 @@ final public class TopLevelCodeDecl: Decl {}
 
 final public class ImportDecl: Decl {}
 
+final public class UsingDecl: Decl {}
+
 final public class PrecedenceGroupDecl: Decl {}
 
 final public class MissingDecl: Decl {}

SwiftCompilerSources/Sources/AST/Registration.swift

@@ -36,6 +36,7 @@ public func registerAST() {
   registerDecl(ExtensionDecl.self)
   registerDecl(TopLevelCodeDecl.self)
   registerDecl(ImportDecl.self)
+  registerDecl(UsingDecl.self)
   registerDecl(PrecedenceGroupDecl.self)
   registerDecl(MissingDecl.self)
   registerDecl(MissingMemberDecl.self)

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -64,7 +64,7 @@ private func optimizeFunctionsTopDown(using worklist: inout FunctionWorklist,
     // We need handle this case with a function signature optimization.
     removeMetatypeArgumentsInCallees(of: f, moduleContext)
 
-    worklist.addCallees(of: f)
+    worklist.addCallees(of: f, moduleContext)
   }
 }
 
@@ -496,29 +496,41 @@ fileprivate struct FunctionWorklist {
     return
   }
 
-  mutating func addCallees(of function: Function) {
+  mutating func addCallees(of function: Function, _ context: ModulePassContext) {
     for inst in function.instructions {
       switch inst {
-      case let apply as ApplySite:
-        if let callee = apply.referencedFunction {
-          pushIfNotVisited(callee)
+      case let fri as FunctionRefInst:
+        pushIfNotVisited(fri.referencedFunction)
+      case let alloc as AllocRefInst:
+        if context.options.enableEmbeddedSwift {
+          addVTableMethods(forClassType: alloc.type, context)
         }
-      case let bi as BuiltinInst:
-        switch bi.id {
-        case .Once, .OnceWithContext:
-          if let fri = bi.operands[1].value as? FunctionRefInst {
-            pushIfNotVisited(fri.referencedFunction)
+      case let metatype as MetatypeInst:
+        if context.options.enableEmbeddedSwift {
+          let instanceType = metatype.type.loweredInstanceTypeOfMetatype(in: function)
+          if instanceType.isClass {
+            addVTableMethods(forClassType: instanceType, context)
           }
-          break;
-        default:
-          break
         }
+
       default:
         break
       }
     }
   }
 
+  mutating func addVTableMethods(forClassType classType: Type, _ context: ModulePassContext) {
+    guard let vtable = classType.isGenericAtAnyLevel ?
+                        context.lookupSpecializedVTable(for: classType) :
+                        context.lookupVTable(for: classType.nominal!)
+    else {
+      return
+    }
+    for entry in vtable.entries where !entry.implementation.isGeneric {
+      pushIfNotVisited(entry.implementation)
+    }
+  }
+
   mutating func addWitnessMethods(of witnessTable: WitnessTable) {
     for entry in witnessTable.entries {
       if case .method(_, let witness) = entry,

include/swift/AST/ASTBridging.h

@@ -1744,6 +1744,19 @@ BridgedImportDecl BridgedImportDecl_createParsed(
     BridgedSourceLoc cImportKeywordLoc, BridgedImportKind cImportKind,
     BridgedSourceLoc cImportKindLoc, BridgedArrayRef cImportPathElements);
 
+enum ENUM_EXTENSIBILITY_ATTR(open) BridgedUsingSpecifier {
+  BridgedUsingSpecifierMainActor,
+  BridgedUsingSpecifierNonisolated,
+};
+
+SWIFT_NAME("BridgedUsingDecl.createParsed(_:declContext:usingKeywordLoc:"
+           "specifierLoc:specifier:)")
+BridgedUsingDecl BridgedUsingDecl_createParsed(BridgedASTContext cContext,
+                                               BridgedDeclContext cDeclContext,
+                                               BridgedSourceLoc usingKeywordLoc,
+                                               BridgedSourceLoc specifierLoc,
+                                               BridgedUsingSpecifier specifier);
+
 SWIFT_NAME("BridgedSubscriptDecl.createParsed(_:declContext:staticLoc:"
            "staticSpelling:subscriptKeywordLoc:genericParamList:parameterList:"
            "arrowLoc:returnType:genericWhereClause:)")

include/swift/AST/Decl.h

@@ -213,7 +213,8 @@ enum class DescriptiveDeclKind : uint8_t {
   OpaqueResultType,
   OpaqueVarType,
   Macro,
-  MacroExpansion
+  MacroExpansion,
+  Using
 };
 
 /// Describes which spelling was used in the source for the 'static' or 'class'
@@ -267,6 +268,16 @@ static_assert(uint8_t(SelfAccessKind::LastSelfAccessKind) <
               "Self Access Kind is too small to fit in SelfAccess kind bits. "
               "Please expand ");
 
+enum class UsingSpecifier : uint8_t {
+  MainActor,
+  Nonisolated,
+  LastSpecifier = Nonisolated,
+};
+enum : unsigned {
+  NumUsingSpecifierBits =
+      countBitsUsed(static_cast<unsigned>(UsingSpecifier::LastSpecifier))
+};
+
 /// Diagnostic printing of \c SelfAccessKind.
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, SelfAccessKind SAK);
 
@@ -827,6 +838,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     NumPathElements : 8
   );
 
+  SWIFT_INLINE_BITFIELD(UsingDecl, Decl, NumUsingSpecifierBits,
+    Specifier : NumUsingSpecifierBits
+  );
+
   SWIFT_INLINE_BITFIELD(ExtensionDecl, Decl, 4+1,
     /// An encoding of the default and maximum access level for this extension.
     /// The value 4 corresponds to AccessLevel::Public
@@ -9737,6 +9752,34 @@ class MacroExpansionDecl : public Decl, public FreestandingMacroExpansion {
   }
 };
 
+/// UsingDecl - This represents a single `using` declaration, e.g.:
+///   using @MainActor
+class UsingDecl : public Decl {
+  friend class Decl;
+
+private:
+  SourceLoc UsingLoc, SpecifierLoc;
+
+  UsingDecl(SourceLoc usingLoc, SourceLoc specifierLoc,
+            UsingSpecifier specifier, DeclContext *parent);
+
+public:
+  UsingSpecifier getSpecifier() const {
+    return static_cast<UsingSpecifier>(Bits.UsingDecl.Specifier);
+  }
+
+  std::string getSpecifierName() const;
+
+  SourceLoc getLocFromSource() const { return UsingLoc; }
+  SourceRange getSourceRange() const { return {UsingLoc, SpecifierLoc}; }
+
+  static UsingDecl *create(ASTContext &ctx, SourceLoc usingLoc,
+                           SourceLoc specifierLoc, UsingSpecifier specifier,
+                           DeclContext *parent);
+
+  static bool classof(const Decl *D) { return D->getKind() == DeclKind::Using; }
+};
+
 inline void
 AbstractStorageDecl::overwriteSetterAccess(AccessLevel accessLevel) {
   Accessors.setInt(accessLevel);

include/swift/AST/DeclExportabilityVisitor.h

@@ -158,6 +158,7 @@ class DeclExportabilityVisitor
   UNREACHABLE(MissingMember);
   UNREACHABLE(GenericTypeParam);
   UNREACHABLE(Param);
+  UNREACHABLE(Using);
 
 #undef UNREACHABLE
 

include/swift/AST/DeclNodes.def

@@ -190,6 +190,7 @@ DECL(Missing, Decl)
 DECL(MissingMember, Decl)
 DECL(PatternBinding, Decl)
 DECL(EnumCase, Decl)
+DECL(Using, Decl)
 
 ABSTRACT_DECL(Operator, Decl)
   OPERATOR_DECL(InfixOperator, OperatorDecl)

include/swift/AST/DiagnosticsParse.def

@@ -2187,5 +2187,14 @@ ERROR(nonisolated_nonsending_expected_rparen,PointsToFirstBadToken,
 ERROR(nonisolated_nonsending_repeated,none,
       "parameter may have at most one 'nonisolated(nonsending)' specifier", ())
 
+//------------------------------------------------------------------------------
+// MARK: using @<attribute> or using <identifier>
+//------------------------------------------------------------------------------
+ERROR(using_decl_invalid_specifier,PointsToFirstBadToken,
+      "default isolation can only be set to '@MainActor' or 'nonisolated'",
+      ())
+ERROR(experimental_using_decl_disabled,PointsToFirstBadToken,
+      "'using' is an experimental feature that is currently disabled", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSema.def

@@ -8293,8 +8293,8 @@ ERROR(lifetime_dependence_immortal_alone, none,
       "cannot specify any other dependence source along with immortal", ())
 ERROR(lifetime_dependence_invalid_inherit_escapable_type, none,
       "cannot copy the lifetime of an Escapable type, use "
-      "'@lifetime(borrow %0)' instead",
-      (StringRef))
+      "'@lifetime(%1%0)' instead",
+      (StringRef, StringRef))
 ERROR(lifetime_dependence_cannot_use_parsed_borrow_consuming, none,
       "invalid use of %0 dependence with %1 ownership",
       (StringRef, StringRef))
@@ -8782,5 +8782,13 @@ ERROR(extensible_attr_on_internal_type,none,
 ERROR(pre_enum_extensibility_without_extensible,none,
       "%0 can only be used together with '@extensible' attribute", (DeclAttribute))
 
+//===----------------------------------------------------------------------===//
+// MARK: `using` declaration
+//===----------------------------------------------------------------------===//
+ERROR(invalid_redecl_of_file_isolation,none,
+      "invalid redeclaration of file-level default actor isolation", ())
+NOTE(invalid_redecl_of_file_isolation_prev,none,
+     "default isolation was previously declared here", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/SourceFile.h

@@ -32,6 +32,7 @@ class GeneratedSourceInfo;
 class PersistentParserState;
 struct SourceFileExtras;
 class Token;
+enum class DefaultIsolation : uint8_t;
 
 /// Kind of import affecting how a decl can be reexported.
 ///
@@ -690,6 +691,11 @@ class SourceFile final : public FileUnit {
     DelayedParserState = std::move(state);
   }
 
+  /// Retrieve default action isolation to be used for this source file.
+  /// It's determine based on on top-level `using <<isolation>>` declaration
+  /// found in the file.
+  std::optional<DefaultIsolation> getDefaultIsolation() const;
+
   SWIFT_DEBUG_DUMP;
   void
   dump(raw_ostream &os,

include/swift/AST/TypeCheckRequests.h

@@ -5332,6 +5332,23 @@ class SemanticAvailabilitySpecRequest
   void cacheResult(std::optional<SemanticAvailabilitySpec> value) const;
 };
 
+class DefaultIsolationInSourceFileRequest
+    : public SimpleRequest<DefaultIsolationInSourceFileRequest,
+                           std::optional<DefaultIsolation>(const SourceFile *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  std::optional<DefaultIsolation> evaluate(Evaluator &evaluator,
+                                           const SourceFile *file) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -629,3 +629,7 @@ SWIFT_REQUEST(TypeChecker, SemanticAvailabilitySpecRequest,
               std::optional<SemanticAvailabilitySpec>
               (const AvailabilitySpec *, const DeclContext *),
               SeparatelyCached, NoLocationInfo)
+
+SWIFT_REQUEST(TypeChecker, DefaultIsolationInSourceFileRequest,
+              std::optional<DefaultIsolation>(const SourceFile *),
+              Cached, NoLocationInfo)

include/swift/AST/TypeMemberVisitor.h

@@ -41,6 +41,7 @@ class TypeMemberVisitor : public DeclVisitor<ImplClass, RetTy> {
   BAD_MEMBER(Operator)
   BAD_MEMBER(PrecedenceGroup)
   BAD_MEMBER(Macro)
+  BAD_MEMBER(Using)
 
   RetTy visitMacroExpansionDecl(MacroExpansionDecl *D) {
     // Expansion already visited as auxiliary decls.

include/swift/Basic/Features.def

@@ -521,6 +521,10 @@ SUPPRESSIBLE_EXPERIMENTAL_FEATURE(ExtensibleAttribute, false)
 /// Allow use of `Module::name` syntax
 EXPERIMENTAL_FEATURE(ModuleSelector, false)
 
+/// Allow use of `using` declaration that control default isolation
+/// in a file scope.
+EXPERIMENTAL_FEATURE(DefaultIsolationPerFile, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/IDE/CodeCompletionResult.h

@@ -190,6 +190,7 @@ enum class CodeCompletionKeywordKind : uint8_t {
 enum class CompletionKind : uint8_t {
   None,
   Import,
+  Using,
   UnresolvedMember,
   DotExpr,
   StmtOrExpr,

include/swift/IDE/CompletionLookup.h

@@ -325,6 +325,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void addImportModuleNames();
 
+  void addUsingSpecifiers();
+
   SemanticContextKind getSemanticContext(const Decl *D,
                                          DeclVisibilityKind Reason,
                                          DynamicLookupInfo dynamicLookupInfo);

include/swift/Parse/IDEInspectionCallbacks.h

@@ -255,6 +255,10 @@ class CodeCompletionCallbacks {
   virtual void
   completeImportDecl(ImportPath::Builder &Path) {};
 
+  /// Complete the 'using' decl with supported specifiers.
+  virtual void
+  completeUsingDecl() {};
+
   /// Complete unresolved members after dot.
   virtual void completeUnresolvedMember(CodeCompletionExpr *E,
                                         SourceLoc DotLoc) {};

include/swift/Parse/Parser.h

@@ -1223,6 +1223,9 @@ class Parser {
   ParserResult<ImportDecl> parseDeclImport(ParseDeclOptions Flags,
                                            DeclAttributes &Attributes);
 
+  ParserResult<UsingDecl> parseDeclUsing(ParseDeclOptions Flags,
+                                         DeclAttributes &Attributes);
+
   /// Parse an inheritance clause into a vector of InheritedEntry's.
   ///
   /// \param allowClassRequirement whether to permit parsing of 'class'

include/swift/Parse/Token.h

@@ -196,8 +196,9 @@ class Token {
 #define CONTEXTUAL_SIMPLE_DECL_ATTR(KW, ...) CONTEXTUAL_CASE(KW)
 #include "swift/AST/DeclAttr.def"
 #undef CONTEXTUAL_CASE
-      .Case("macro", true)
-      .Default(false);
+        .Case("macro", true)
+        .Case("using", true)
+        .Default(false);
   }
 
   bool isContextualPunctuator(StringRef ContextPunc) const {

lib/AST/ASTDumper.cpp

@@ -2114,6 +2114,11 @@ namespace {
       printFoot();
     }
 
+    void visitUsingDecl(UsingDecl *UD, Label label) {
+      printCommon(UD, "using_decl", label);
+      printFieldQuoted(UD->getSpecifierName(), Label::always("specifier"));
+    }
+
     void visitExtensionDecl(ExtensionDecl *ED, Label label) {
       printCommon(ED, "extension_decl", label, ExtensionColor);
       printFlag(!ED->hasBeenBound(), "unbound");

lib/AST/ASTMangler.cpp

@@ -5426,6 +5426,7 @@ ASTMangler::BaseEntitySignature::BaseEntitySignature(const Decl *decl)
     case DeclKind::PrefixOperator:
     case DeclKind::PostfixOperator:
     case DeclKind::MacroExpansion:
+    case DeclKind::Using:
       break;
     };
   }

lib/AST/ASTPrinter.cpp

@@ -383,6 +383,11 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
         }
       }
 
+      // The `using` declarations are private to the file at the moment
+      // and shouldn't appear in swift interfaces.
+      if (isa<UsingDecl>(D))
+        return false;
+
       return ShouldPrintChecker::shouldPrint(D, options);
     }
   };
@@ -3052,6 +3057,11 @@ void PrintAST::visitImportDecl(ImportDecl *decl) {
                    [&] { Printer << "."; });
 }
 
+void PrintAST::visitUsingDecl(UsingDecl *decl) {
+  Printer.printIntroducerKeyword("using", Options, " ");
+  Printer << decl->getSpecifierName();
+}
+
 void PrintAST::printExtendedTypeName(TypeLoc ExtendedTypeLoc) {
   bool OldFullyQualifiedTypesIfAmbiguous =
     Options.FullyQualifiedTypesIfAmbiguous;