Merge remote-tracking branch 'apple/main' into katei/merge-main-2023-01-05

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -98,6 +98,11 @@ private struct CollectedEffects {
       addDestroyEffects(of: inst.operands[0].value)
 
     case let da as DestroyAddrInst:
+      // A destroy_addr also involves a read from the address. It's equivalent to a `%x = load [take]` and `destroy_value %x`.
+      addEffects(.read, to: da.operand)
+      // Conceptually, it's also a write, because the stored value is not available anymore after the destroy
+      addEffects(.write, to: da.operand)
+
       addDestroyEffects(of: da.operand)
 
     case let copy as CopyAddrInst:
@@ -108,12 +113,16 @@ private struct CollectedEffects {
         addEffects(.copy, to: copy.source)
       }
       if !copy.isInitializationOfDest {
+        // Like for destroy_addr, the destroy also involves a read.
+        addEffects(.read, to: copy.destination)
         addDestroyEffects(of: copy.destination)
       }
 
     case let store as StoreInst:
       addEffects(.write, to: store.destination)
       if store.destinationOwnership == .assign {
+        // Like for destroy_addr, the destroy also involves a read.
+        addEffects(.read, to: store.destination)
         addDestroyEffects(of: store.destination)
       }
 
@@ -433,7 +442,8 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
       return .continueWalk
 
     // Warning: all instruction listed here, must also be handled in `CollectedEffects.addInstructionEffects`
-    case is StoreInst, is StoreWeakInst, is StoreUnownedInst, is ApplySite, is DestroyAddrInst:
+    case is StoreInst, is StoreWeakInst, is StoreUnownedInst, is ApplySite, is DestroyAddrInst,
+         is DebugValueInst:
       return .continueWalk
 
     default:

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -810,7 +810,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
         switch effect.kind {
         case .escapingToReturn(let toPath, let exclusive):
           if exclusive && path.projectionPath.matches(pattern: toPath) {
-            let arg = apply.arguments[effect.argumentIndex]
+            guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
+              return .abortWalk
+            }
+            let arg = apply.arguments[callerArgIdx]
 
             let p = Path(projectionPath: effect.pathPattern, followStores: path.followStores, knownType: nil)
             if walkUp(addressOrValue: arg, path: p) == .abortWalk {

docs/Lexicon.md

@@ -100,7 +100,7 @@ Apple term for "the person assigned to watch CI this week".
 
 ## canonical SIL
 
-SIL after the
+[SIL](#sil) after the
 [mandatory passes](#mandatory-passes--mandatory-optimizations) have run.
 This can be used as input to IRGen to generate LLVM IR or object files.
 
@@ -179,7 +179,7 @@ The other half is provided by corresponding
 ## DI (definite initialization / definitive initialization)
 
 The feature that no uninitialized variables, constants, or properties will
-be read by a program, or the analysis pass that operates on SIL to
+be read by a program, or the analysis pass that operates on [SIL](#sil) to
 guarantee this. This was 
 [discussed on Apple's Swift blog](https://developer.apple.com/swift/blog/?id=28).
 
@@ -284,6 +284,8 @@ perform structural modification, e.x.:
 2. `case let x:`.
 3. `case (_, _):`.
 
+Contrast with [refutable pattern](#refutable-pattern)
+
 ## IR
 
 1. "intermediate representation": a generic term for a format representing
@@ -327,7 +329,7 @@ The module for the file or files currently being compiled.
 
 ## mandatory passes / mandatory optimizations
 
-Transformations over SIL that run immediately after SIL generation. Once
+Transformations over [SIL](#sil) that run immediately after SIL generation. Once
 all mandatory passes have run (and if no errors are found), the SIL is
 considered [canonical](#canonical-SIL).
 
@@ -359,7 +361,7 @@ Has *many* uses in the Swift world. We may want to rename some of them.
 2. A compilation unit; that is, source files that are compiled together.
    These files may contain cross-references. Represented as "the main
    module" (a specific ModuleDecl).
-3. (as "SIL module") A container for SIL to be compiled together, along
+3. (as "[SIL](#sil) module") A container for SIL to be compiled together, along
    with various context for the compilation.
 4. (as "LLVM module") A collection of LLVM IR to be compiled together.
    Always created in an LLVMContext.
@@ -491,7 +493,7 @@ on that system.
 
 ## raw SIL
 
-SIL just after being generated, not yet in a form that can be used for
+[SIL](#sil) just after being generated, not yet in a form that can be used for
 IR generation.
 See [mandatory passes](#mandatory-passes--mandatory-optimizations).
 
@@ -540,6 +542,8 @@ A pattern that may not always match. These include patterns such as:
 2. Enum case check: e.g. `case .none:`.
 3. Expr pattern: e.g. `case foo():`.
 
+Contrast with [irrefutable pattern](#irrefutable-pattern)
+
 ## resilient
 
 Describes a type or function where making certain changes will not break
@@ -656,7 +660,7 @@ The value or type that satisfies a protocol requirement.
 
 ## witness table
 
-The SIL (and runtime) representation of a [conformance](#conformance); essentially a
+The [SIL](#sil) (and runtime) representation of a [conformance](#conformance); essentially a
 [vtable](#vtable-virtual-dispatch-table) but for a protocol instead of
 a class.
 

include/swift/ABI/Metadata.h

@@ -4740,7 +4740,7 @@ using AccessibleFunctionRecord = TargetAccessibleFunctionRecord<InProcess>;
 /// that relates a type attribute is attached to a generator function.
 template <typename Runtime>
 struct TargetRuntimeDiscoverableAttributeEntry {
-  ConstTargetMetadataPointer<Runtime, TargetMetadata> Type;
+  RelativeDirectPointer<const char, /*nullable*/ false> Type;
   RelativeDirectPointer<TargetAccessibleFunctionRecord<Runtime>> Generator;
 };
 
@@ -4759,7 +4759,10 @@ class RuntimeDiscoverableAttributeRecord
   uint32_t flags;
 
   /// The nominal type that describes the attribute.
-  TargetSignedContextPointer<Runtime, TargetTypeContextDescriptor> Attribute;
+  TargetRelativeIndirectablePointer<Runtime,
+                                    TargetTypeContextDescriptor<Runtime>,
+                                    /*nullable*/ false>
+      Attribute;
 
   /// The number of types this attribute is associated with.
   uint32_t numEntries;

include/swift/AST/ASTContext.h

@@ -991,18 +991,20 @@ class ASTContext final {
 
   /// Retrieve the module dependencies for the module with the given name.
   ///
-  /// \param isUnderlyingClangModule When true, only look for a Clang module
-  /// with the given name, ignoring any Swift modules.
-  Optional<ModuleDependencyInfo> getModuleDependencies(
+  Optional<const ModuleDependencyInfo*> getModuleDependencies(
       StringRef moduleName,
-      bool isUnderlyingClangModule,
       ModuleDependenciesCache &cache,
       InterfaceSubContextDelegate &delegate,
-      bool cacheOnly = false,
       llvm::Optional<std::pair<std::string, swift::ModuleDependencyKind>> dependencyOf = None);
 
+  /// Retrieve the module dependencies for the Clang module with the given name.
+  Optional<const ModuleDependencyInfo*> getClangModuleDependencies(
+      StringRef moduleName,
+      ModuleDependenciesCache &cache,
+      InterfaceSubContextDelegate &delegate);
+
   /// Retrieve the module dependencies for the Swift module with the given name.
-  Optional<ModuleDependencyInfo> getSwiftModuleDependencies(
+  Optional<const ModuleDependencyInfo*> getSwiftModuleDependencies(
       StringRef moduleName,
       ModuleDependenciesCache &cache,
       InterfaceSubContextDelegate &delegate);

include/swift/AST/ConstTypeInfo.h

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -102,16 +102,6 @@ class BuilderValue : public CompileTimeValue {
   std::vector<CompileTimeValue> Members;
 };
 
-/// A dictionary literal value representation
-class DictionaryValue : public CompileTimeValue {
-public:
-  DictionaryValue() : CompileTimeValue(ValueKind::Dictionary) {}
-
-  static bool classof(const CompileTimeValue *T) {
-    return T->getKind() == ValueKind::Dictionary;
-  }
-};
-
 struct TupleElement {
   Optional<std::string> Label;
   swift::Type Type;
@@ -151,6 +141,24 @@ class ArrayValue : public CompileTimeValue {
   std::vector<std::shared_ptr<CompileTimeValue>> Elements;
 };
 
+/// A dictionary literal value representation
+class DictionaryValue : public CompileTimeValue {
+public:
+  DictionaryValue(std::vector<std::shared_ptr<TupleValue>> elements)
+      : CompileTimeValue(ValueKind::Dictionary), Elements(elements) {}
+
+  static bool classof(const CompileTimeValue *T) {
+    return T->getKind() == ValueKind::Dictionary;
+  }
+
+  std::vector<std::shared_ptr<TupleValue>> getElements() const {
+    return Elements;
+  }
+
+private:
+  std::vector<std::shared_ptr<TupleValue>> Elements;
+};
+
 /// A representation of an arbitrary value that does not fall under
 /// any of the above categories.
 class RuntimeValue : public CompileTimeValue {

include/swift/AST/DiagnosticsFrontend.def

@@ -180,6 +180,12 @@ ERROR(error_stdlib_module_name,none,
       "module name \"%0\" is reserved for the standard library"
       "%select{|; use -module-name flag to specify an alternate name}1",
       (StringRef, bool))
+ERROR(error_bad_package_name,none,
+      "package name \"%0\" is not a valid identifier",
+      (StringRef))
+ERROR(error_stdlib_package_name,none,
+      "package name \"%0\" is reserved for the standard library",
+      (StringRef))
 ERROR(error_stdlib_not_found,Fatal,
       "unable to load standard library for target '%0'", (StringRef))
 ERROR(error_module_alias_invalid_format,none,

include/swift/AST/DiagnosticsSema.def

@@ -2035,10 +2035,12 @@ NOTE(objc_generic_extension_using_type_parameter_here,none,
      "generic parameter used here", ())
 NOTE(objc_generic_extension_using_type_parameter_try_objc,none,
      "add '@objc' to allow uses of 'self' within the function body", ())
+ERROR(unsupported_existential_extension,none,
+      "extension of existential type %0 is not supported", (Type))
 ERROR(invalid_nominal_extension,none,
       "extension of type %0 must be declared as an extension of %1",
       (Type, Type))
-NOTE(invalid_nominal_extension_rewrite,none,
+NOTE(invalid_extension_rewrite,none,
      "did you mean to extend %0 instead?", (Type))
 ERROR(synthesized_nominal_extension,none,
       "cannot extend synthesized type %0", (Type))

include/swift/AST/Expr.h

@@ -3339,7 +3339,7 @@ class ErasureExpr final : public ImplicitConversionExpr,
   /// this array will be empty
   ArrayRef<ConversionPair> getArgumentConversions() const {
     return {getTrailingObjects<ConversionPair>(),
-            Bits.ErasureExpr.NumArgumentConversions };
+            static_cast<size_t>(Bits.ErasureExpr.NumArgumentConversions) };
   }
 
   /// Retrieve the conversion expressions mapping requirements from any
@@ -3349,7 +3349,7 @@ class ErasureExpr final : public ImplicitConversionExpr,
   /// this array will be empty
   MutableArrayRef<ConversionPair> getArgumentConversions() {
     return {getTrailingObjects<ConversionPair>(),
-            Bits.ErasureExpr.NumArgumentConversions };
+            static_cast<size_t>(Bits.ErasureExpr.NumArgumentConversions) };
   }
 
   void setArgumentConversion(unsigned i, const ConversionPair &p) {