Merge pull request #5529 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -58,17 +58,15 @@ private func optimize(function: Function, _ context: FunctionPassContext) {
     switch instruction {
     case let apply as FullApplySite:
       inlineAndDevirtualize(apply: apply, context, simplifyCtxt)
-    case let mt as MetatypeInst:
-      if mt.isTriviallyDeadIgnoringDebugUses {
-        simplifyCtxt.erase(instructionIncludingDebugUses: mt)
-      }
     default:
       break
     }
   }
 
   _ = context.specializeApplies(in: function, isMandatory: true)
 
+  removeUnusedMetatypeInstructions(in: function, context)
+
   // If this is a just specialized function, try to optimize copy_addr, etc.
   if context.optimizeMemoryAccesses(in: function) {
     _ = context.eliminateDeadAllocations(in: function)
@@ -103,6 +101,15 @@ private func inlineAndDevirtualize(apply: FullApplySite, _ context: FunctionPass
   }
 }
 
+private func removeUnusedMetatypeInstructions(in function: Function, _ context: FunctionPassContext) {
+  for inst in function.instructions {
+    if let mt = inst as? MetatypeInst,
+       mt.isTriviallyDeadIgnoringDebugUses {
+      context.erase(instructionIncludingDebugUses: mt)
+    }
+  }
+}
+
 private func shouldInline(apply: FullApplySite, callee: Function) -> Bool {
   if callee.isTransparent {
     return true

include/swift/AST/DiagnosticEngine.h

@@ -564,6 +564,15 @@ namespace swift {
     /// until the next major language version.
     InFlightDiagnostic &warnUntilSwiftVersion(unsigned majorVersion);
 
+    /// Limit the diagnostic behavior to warning if the context is a
+    /// swiftinterface.
+    ///
+    /// This is useful for diagnostics for restrictions that may be lifted by a
+    /// future version of the compiler. In such cases, it may be helpful to
+    /// avoid failing to build a module from its interface if the interface was
+    /// emitted using a compiler that no longer has the restriction.
+    InFlightDiagnostic &warnInSwiftInterface(const DeclContext *context);
+
     /// Conditionally limit the diagnostic behavior to warning until
     /// the specified version.  If the condition is false, no limit is
     /// imposed, meaning (presumably) it is treated as an error.

include/swift/AST/DiagnosticsSema.def

@@ -7053,6 +7053,10 @@ ERROR(attr_incompatible_with_back_deploy,none,
       "'%0' cannot be applied to a back deployed %1",
       (DeclAttribute, DescriptiveDeclKind))
 
+ERROR(backdeployed_opaque_result_not_supported,none,
+      "'%0' is unsupported on a %1 with a 'some' return type",
+      (DeclAttribute, DescriptiveDeclKind))
+
 //------------------------------------------------------------------------------
 // MARK: Implicit opening of existential types
 //------------------------------------------------------------------------------

include/swift/AST/PluginLoader.h

@@ -52,30 +52,19 @@ class PluginLoader {
   void setRegistry(PluginRegistry *newValue);
   PluginRegistry *getRegistry();
 
-  /// Lookup a library plugin that can handle \p moduleName and return the path
-  /// to it from `-load-plugin-library`.
-  /// The path returned can be loaded by 'loadLibraryPlugin' method.
-  llvm::Optional<std::string>
-  lookupExplicitLibraryPluginByModuleName(Identifier moduleName);
-
-  /// Lookup a library plugin that can handle \p moduleName and return the path
-  /// to it from `-plugin-path`.
-  /// The path returned can be loaded by 'loadLibraryPlugin' method.
-  llvm::Optional<std::string>
-  lookupLibraryPluginInSearchPathByModuleName(Identifier moduleName);
-
-  /// Lookup an executable plugin that is declared to handle \p moduleName
-  /// module by '-load-plugin-executable'.
-  /// The path returned can be loaded by 'loadExecutablePlugin' method.
-  llvm::Optional<StringRef>
-  lookupExecutablePluginByModuleName(Identifier moduleName);
-
-  /// Look for dynamic libraries in paths from `-external-plugin-path` and
-  /// return a pair of `(library path, plugin server executable)` if found.
-  /// These paths are valid within the VFS, use `FS.getRealPath()` for their
-  /// underlying path.
-  llvm::Optional<std::pair<std::string, std::string>>
-  lookupExternalLibraryPluginByModuleName(Identifier moduleName);
+  /// Lookup a plugin that can handle \p moduleName and return the path(s) to
+  /// it. The path returned can be loaded by 'load(Library|Executable)Plugin()'.
+  /// The return value is a pair of a "library path" and a "executable path".
+  ///
+  ///  * (libPath: empty, execPath: empty) - plugin not found.
+  ///  * (libPath: some,  execPath: empty) - load the library path by
+  ///    'loadLibraryPlugin()'.
+  ///  * (libPath: empty, execPath: some) - load the executable path by
+  ///    'loadExecutablePlugin()'.
+  ///  * (libPath: some,  execPath: some) - load the executable path by
+  ///    'loadExecutablePlugin()' and let the plugin load the libPath via IPC.
+  std::pair<std::string, std::string>
+  lookupPluginByModuleName(Identifier moduleName);
 
   /// Load the specified dylib plugin path resolving the path with the
   /// current VFS. If it fails to load the plugin, a diagnostic is emitted, and

include/swift/AST/SearchPathOptions.h

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/ArrayRefView.h"
 #include "swift/Basic/PathRemapper.h"
+#include "swift/Basic/TaggedUnion.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringMap.h"
@@ -34,7 +35,6 @@ enum class ModuleSearchPathKind {
   Framework,
   DarwinImplicitFramework,
   RuntimeLibrary,
-  CompilerPlugin,
 };
 
 /// A single module search path that can come from different sources, e.g.
@@ -187,6 +187,26 @@ struct ExternalPluginSearchPathAndServerPath {
   std::string ServerPath;
 };
 
+namespace PluginSearchOption {
+struct LoadPluginLibrary {
+  std::string LibraryPath;
+};
+struct LoadPluginExecutable {
+  std::string ExecutablePath;
+  std::vector<std::string> ModuleNames;
+};
+struct PluginPath {
+  std::string SearchPath;
+};
+struct ExternalPluginPath {
+  std::string SearchPath;
+  std::string ServerPath;
+};
+
+using Value = TaggedUnion<LoadPluginLibrary, LoadPluginExecutable, PluginPath,
+                          ExternalPluginPath>;
+} // namespace PluginSearchOption
+
 /// Options for controlling search path behavior.
 class SearchPathOptions {
   /// To call \c addImportSearchPath and \c addFrameworkSearchPath from
@@ -259,14 +279,6 @@ class SearchPathOptions {
                            ImportSearchPaths.size() - 1);
   }
 
-  void addCompilerPluginLibraryPath(StringRef Path, llvm::vfs::FileSystem *FS) {
-    CompilerPluginLibraryPaths.push_back(Path.str());
-    Lookup.searchPathAdded(FS, CompilerPluginLibraryPaths.back(),
-                           ModuleSearchPathKind::CompilerPlugin,
-                           /*isSystem=*/false,
-                           CompilerPluginLibraryPaths.size() - 1);
-  }
-
   /// Add a single framework search path. Must only be called from
   /// \c ASTContext::addSearchPath.
   void addFrameworkSearchPath(FrameworkSearchPath NewPath,
@@ -355,27 +367,6 @@ class SearchPathOptions {
     Lookup.searchPathsDidChange();
   }
 
-  void setCompilerPluginLibraryPaths(
-      std::vector<std::string> NewCompilerPluginLibraryPaths) {
-    CompilerPluginLibraryPaths = NewCompilerPluginLibraryPaths;
-    Lookup.searchPathsDidChange();
-  }
-
-  ArrayRef<std::string> getCompilerPluginLibraryPaths() const {
-    return CompilerPluginLibraryPaths;
-  }
-
-  void setCompilerPluginExecutablePaths(
-      std::vector<PluginExecutablePathAndModuleNames> &&newValue) {
-    CompilerPluginExecutablePaths = std::move(newValue);
-    Lookup.searchPathsDidChange();
-  }
-
-  ArrayRef<PluginExecutablePathAndModuleNames>
-  getCompilerPluginExecutablePaths() const {
-    return CompilerPluginExecutablePaths;
-  }
-
   /// Path(s) to virtual filesystem overlay YAML files.
   std::vector<std::string> VFSOverlayFiles;
 
@@ -391,15 +382,8 @@ class SearchPathOptions {
   /// preference.
   std::vector<std::string> RuntimeLibraryPaths;
 
-  /// Paths that contain compiler plugins loaded on demand for, e.g.,
-  /// macro implementations.
-  std::vector<std::string> PluginSearchPaths;
-
-  /// Pairs of external compiler plugin search paths and the corresponding
-  /// plugin server executables.
-  /// e.g. {"/path/to/usr/lib/swift/host/plugins",
-  ///       "/path/to/usr/bin/plugin-server"}
-  std::vector<ExternalPluginSearchPathAndServerPath> ExternalPluginSearchPaths;
+  /// Plugin search path options.
+  std::vector<PluginSearchOption::Value> PluginSearchOpts;
 
   /// Don't look in for compiler-provided modules.
   bool SkipRuntimeLibraryImportPaths = false;

include/swift/Frontend/Frontend.h

@@ -198,14 +198,6 @@ class CompilerInvocation {
     SearchPathOpts.VFSOverlayFiles = Overlays;
   }
 
-  void setCompilerPluginLibraryPaths(const std::vector<std::string> &Paths) {
-    SearchPathOpts.setCompilerPluginLibraryPaths(Paths);
-  }
-
-  ArrayRef<std::string> getCompilerPluginLibraryPaths() {
-    return SearchPathOpts.getCompilerPluginLibraryPaths();
-  }
-
   void setExtraClangArgs(const std::vector<std::string> &Args) {
     ClangImporterOpts.ExtraArgs = Args;
   }

include/swift/Option/Options.td

@@ -304,15 +304,6 @@ def I : JoinedOrSeparate<["-"], "I">,
 def I_EQ : Joined<["-"], "I=">, Flags<[FrontendOption, ArgumentIsPath]>,
   Alias<I>;
 
-def plugin_path : Separate<["-"], "plugin-path">,
-  Flags<[FrontendOption, ArgumentIsPath, SwiftAPIExtractOption, SwiftSymbolGraphExtractOption, SwiftAPIDigesterOption]>,
-  HelpText<"Add directory to the plugin search path">;
-
-def external_plugin_path : Separate<["-"], "external-plugin-path">,
-  Flags<[FrontendOption, ArgumentIsPath, SwiftAPIExtractOption, SwiftSymbolGraphExtractOption, SwiftAPIDigesterOption]>,
-  HelpText<"Add directory to the plugin search path with a plugin server executable">,
-  MetaVarName<"<path>#<plugin-server-path>">;
-
 def import_underlying_module : Flag<["-"], "import-underlying-module">,
   Flags<[FrontendOption, NoInteractiveOption]>,
   HelpText<"Implicitly imports the Objective-C half of a module">;
@@ -1852,15 +1843,27 @@ def clang_include_tree_root: Separate<["-"], "clang-include-tree-root">,
   Flags<[FrontendOption, NoDriverOption]>,
   HelpText<"Clang Include Tree CASID">, MetaVarName<"<cas-id>">;
 
+
+def plugin_search_Group : OptionGroup<"<plugin search options>">;
+
+def plugin_path : Separate<["-"], "plugin-path">, Group<plugin_search_Group>,
+  Flags<[FrontendOption, ArgumentIsPath, SwiftAPIExtractOption, SwiftSymbolGraphExtractOption, SwiftAPIDigesterOption]>,
+  HelpText<"Add directory to the plugin search path">;
+
+def external_plugin_path : Separate<["-"], "external-plugin-path">, Group<plugin_search_Group>,
+  Flags<[FrontendOption, ArgumentIsPath, SwiftAPIExtractOption, SwiftSymbolGraphExtractOption, SwiftAPIDigesterOption]>,
+  HelpText<"Add directory to the plugin search path with a plugin server executable">,
+  MetaVarName<"<path>#<plugin-server-path>">;
+
 def load_plugin_library:
-  Separate<["-"], "load-plugin-library">,
+  Separate<["-"], "load-plugin-library">, Group<plugin_search_Group>,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild, ArgumentIsPath]>,
   HelpText<"Path to a dynamic library containing compiler plugins such as "
            "macros">,
   MetaVarName<"<path>">;
 
 def load_plugin_executable:
-  Separate<["-"], "load-plugin-executable">,
+  Separate<["-"], "load-plugin-executable">, Group<plugin_search_Group>,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild, ArgumentIsPath]>,
   HelpText<"Path to an executable compiler plugins and providing module names "
            "such as macros">,

include/swift/SIL/AbstractionPatternGenerators.h

@@ -291,6 +291,22 @@ class TupleElementGenerator {
     }
   }
 
+  /// Like `getSubstTypes`, but uses a different and possibly
+  /// non-canonical tuple type.
+  TupleEltTypeArrayRef getSubstTypes(Type ncSubstType) const {
+    assert(!isFinished());
+    if (!origTupleVanishes) {
+      return ncSubstType->castTo<TupleType>()
+               ->getElementTypes().slice(substEltIndex,
+                                         numSubstEltsForOrigElt);
+    } else if (numSubstEltsForOrigElt == 0) {
+      return TupleEltTypeArrayRef();
+    } else {
+      scratchSubstElt = TupleTypeElt(ncSubstType);
+      return TupleEltTypeArrayRef(scratchSubstElt);
+    }
+  }
+
   /// Call this to finalize the traversal and assert that it was done
   /// properly.
   void finish() {

include/swift/SIL/GenericSpecializationMangler.h

@@ -88,7 +88,8 @@ class GenericSpecializationMangler : public SpecializationMangler {
       : SpecializationMangler(SpecializationPass::GenericSpecializer,
                               Serialized, F) {}
 
-  std::string mangleNotReabstracted(SubstitutionMap subs);
+  std::string mangleNotReabstracted(SubstitutionMap subs,
+                                    bool metatyeParamsRemoved);
 
   /// Mangle a generic specialization with re-abstracted parameters.
   ///

include/swift/SILOptimizer/Utils/Generics.h

@@ -157,10 +157,6 @@ class ReabstractionInfo {
     LoadableAndTrivial
   };
 
-  unsigned param2ArgIndex(unsigned ParamIdx) const  {
-    return ParamIdx + NumFormalIndirectResults;
-  }
-
   // Create a new substituted type with the updated signature.
   CanSILFunctionType createSubstitutedType(SILFunction *OrigF,
                                            SubstitutionMap SubstMap,
@@ -199,8 +195,8 @@ class ReabstractionInfo {
                     ApplySite Apply, SILFunction *Callee,
                     SubstitutionMap ParamSubs,
                     IsSerialized_t Serialized,
-                    bool ConvertIndirectToDirect = true,
-                    bool dropMetatypeArgs = false,
+                    bool ConvertIndirectToDirect,
+                    bool dropMetatypeArgs,
                     OptRemark::Emitter *ORE = nullptr);
 
   /// Constructs the ReabstractionInfo for generic function \p Callee with
@@ -214,7 +210,11 @@ class ReabstractionInfo {
   IsSerialized_t isSerialized() const {
     return Serialized;
   }
-  
+
+  unsigned param2ArgIndex(unsigned ParamIdx) const  {
+    return ParamIdx + NumFormalIndirectResults;
+  }
+
   /// Returns true if the specialized function needs an alternative mangling.
   /// See hasConvertedResilientParams.
   bool needAlternativeMangling() const {
@@ -314,6 +314,8 @@ class ReabstractionInfo {
   CanSILFunctionType createSpecializedType(CanSILFunctionType SubstFTy,
                                            SILModule &M) const;
 
+  CanSILFunctionType createThunkType(PartialApplyInst *forPAI) const;
+
   SILFunction *getNonSpecializedFunction() const { return Callee; }
 
   /// Map type into a context of the specialized function.