Merge pull request #4272 from swiftwasm/katei/merge-main-2022-02-18

Author: MaxDesiatov

CHANGELOG.md

@@ -5,6 +5,35 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [SE-0341][]:
+
+  Opaque types can now be used in the parameters of functions and subscripts, wher they provide a shorthand syntax for the introduction of a generic parameter. For example, the following:
+
+  ```swift
+  func horizontal(_ v1: some View, _ v2: some View) -> some View {
+    HStack {
+      v1
+      v2
+    }
+  }
+  ```
+
+  is equivalent to
+
+  ```swift
+  func horizontal<V1: View, V2: View>(_ v1: V1, _ v2: V2) -> some View {
+    HStack {
+      v1
+      v2
+    }
+  }
+  ```
+
+  With this, `some` in a parameter type provides a generalization where the
+  caller chooses the parameter's type as well as its value, whereas `some` in
+  the result type provides a generalization where the callee chooses the
+  resulting type and value.
+
 * The compiler now correctly emits warnings for more kinds of expressions where a protocol conformance is used and may be unavailable at runtime. Previously, member reference expressions and type erasing expressions that used potentially unavailable conformances were not diagnosed, leading to potential crashes at runtime.
 
   ```swift
@@ -8962,6 +8991,7 @@ Swift 1.0
 [SE-0331]: <https://github.com/apple/swift-evolution/blob/main/proposals/0331-remove-sendable-from-unsafepointer.md>
 [SE-0337]: <https://github.com/apple/swift-evolution/blob/main/proposals/0337-support-incremental-migration-to-concurrency-checking.md>
 [SE-0335]: <https://github.com/apple/swift-evolution/blob/main/proposals/0335-existential-any.md>
+[SE-0341]: <https://github.com/apple/swift-evolution/blob/main/proposals/0341-opaque-parameters.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -220,7 +220,7 @@ final public class DeallocStackInst : Instruction, UnaryInstruction {
 }
 
 final public class DeallocStackRefInst : Instruction, UnaryInstruction {
-  public var allocRef: AllocRefInst { operand as! AllocRefInst }
+  public var allocRef: AllocRefInstBase { operand as! AllocRefInstBase }
 }
 
 final public class CondFailInst : Instruction, UnaryInstruction {

include/swift/AST/ASTContext.h

@@ -674,20 +674,30 @@ class ASTContext final {
   FuncDecl *getRecordGenericSubstitutionOnDistributedInvocationEncoder(
       NominalTypeDecl *nominal) const;
 
-  // Retrieve the declaration of DistributedInvocationEncoder.recordArgument(_:).
+  // Retrieve the declaration of DistributedTargetInvocationEncoder.recordArgument(_:).
   //
   // \param nominal optionally provide a 'NominalTypeDecl' from which the
   // function decl shall be extracted. This is useful to avoid witness calls
   // through the protocol which is looked up when nominal is null.
-  FuncDecl *getRecordArgumentOnDistributedInvocationEncoder(
+  AbstractFunctionDecl *getRecordArgumentOnDistributedInvocationEncoder(
       NominalTypeDecl *nominal) const;
 
-  // Retrieve the declaration of DistributedInvocationEncoder.recordErrorType(_:).
-  FuncDecl *getRecordErrorTypeOnDistributedInvocationEncoder(
+  // Retrieve the declaration of DistributedTargetInvocationEncoder.recordReturnType(_:).
+  AbstractFunctionDecl *getRecordReturnTypeOnDistributedInvocationEncoder(
       NominalTypeDecl *nominal) const;
 
-  // Retrieve the declaration of DistributedInvocationEncoder.recordReturnType(_:).
-  FuncDecl *getRecordReturnTypeOnDistributedInvocationEncoder(
+  // Retrieve the declaration of DistributedTargetInvocationEncoder.recordErrorType(_:).
+  AbstractFunctionDecl *getRecordErrorTypeOnDistributedInvocationEncoder(
+      NominalTypeDecl *nominal) const;
+
+  // Retrieve the declaration of
+  // DistributedTargetInvocationDecoder.getDecodeNextArgumentOnDistributedInvocationDecoder(_:).
+  AbstractFunctionDecl *getDecodeNextArgumentOnDistributedInvocationDecoder(
+      NominalTypeDecl *nominal) const;
+
+  // Retrieve the declaration of
+  // getOnReturnOnDistributedTargetInvocationResultHandler.onReturn(_:).
+  AbstractFunctionDecl *getOnReturnOnDistributedTargetInvocationResultHandler(
       NominalTypeDecl *nominal) const;
 
   // Retrieve the declaration of DistributedInvocationEncoder.doneRecording().
@@ -876,6 +886,10 @@ class ASTContext final {
   /// compiler for the target platform.
   AvailabilityContext getSwift56Availability();
 
+  /// Get the runtime availability of features introduced in the Swift 5.7
+  /// compiler for the target platform.
+  AvailabilityContext getSwift57Availability();
+
   // Note: Update this function if you add a new getSwiftXYAvailability above.
   /// Get the runtime availability for a particular version of Swift (5.0+).
   AvailabilityContext
@@ -1337,11 +1351,8 @@ class ASTContext final {
   /// alternative specified via the -entry-point-function-name frontend flag.
   std::string getEntryPointFunctionName() const;
 
-  /// Find the type of SerializationRequirement on the passed nominal.
-  ///
-  /// This type exists as a typealias/associatedtype on all distributed actors,
-  /// actor systems, and related serialization types.
-  Type getDistributedSerializationRequirementType(NominalTypeDecl *);
+  Type getAssociatedTypeOfDistributedSystemOfActor(NominalTypeDecl *actor,
+                                            Identifier member);
 
   /// Find the concrete invocation decoder associated with the given actor.
   NominalTypeDecl *

include/swift/AST/ASTNode.h

@@ -10,7 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the ASTNode, which is a union of Stmt, Expr, and Decl.
+// This file defines the ASTNode, which is a union of Stmt, Expr, Decl,
+// Pattern, TypeRepr, StmtCondition, and CaseLabelItem.
 //
 //===----------------------------------------------------------------------===//
 
@@ -43,11 +44,9 @@ namespace swift {
   enum class PatternKind : uint8_t;
   enum class StmtKind;
 
-  using StmtCondition = llvm::MutableArrayRef<StmtConditionElement>;
-
   struct ASTNode
       : public llvm::PointerUnion<Expr *, Stmt *, Decl *, Pattern *, TypeRepr *,
-                                  StmtCondition *, CaseLabelItem *> {
+                                  StmtConditionElement *, CaseLabelItem *> {
     // Inherit the constructors from PointerUnion.
     using PointerUnion::PointerUnion;
 

include/swift/AST/ASTPrinter.h

@@ -385,10 +385,14 @@ void getInheritedForPrinting(
 
 StringRef getAccessorKindString(AccessorKind value);
 
-bool printCompatibilityFeatureChecksPre(ASTPrinter &printer, Decl *decl);
-void printCompatibilityFeatureChecksPost(
-    ASTPrinter &printer,
-    llvm::function_ref<void()> printElse = []() -> void {});
+/// Call the given function nested appropriately within #if checks
+/// for the compiler features that it uses.  Note that printBody
+/// may be called multiple times if the declaration uses suppressible
+/// features.
+bool printWithCompatibilityFeatureChecks(ASTPrinter &printer,
+                                         PrintOptions &options,
+                                         Decl *decl,
+                                         llvm::function_ref<void()> printBody);
 
 } // namespace swift
 

include/swift/AST/Decl.h

@@ -6412,6 +6412,31 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// 'DistributedActorSystem' protocol.
   bool isDistributedActorSystemRemoteCall(bool isVoidReturn) const;
 
+  /// Determines if this function is a 'recordArgument' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedTargetInvocationEncoder' protocol.
+  bool isDistributedTargetInvocationEncoderRecordArgument() const;
+
+  /// Determines if this function is a 'recordReturnType' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedTargetInvocationEncoder' protocol.
+  bool isDistributedTargetInvocationEncoderRecordReturnType() const;
+
+  /// Determines if this function is a 'recordErrorType' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedTargetInvocationEncoder' protocol.
+  bool isDistributedTargetInvocationEncoderRecordErrorType() const;
+
+  /// Determines if this function is a 'decodeNextArgument' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedTargetInvocationDecoder' protocol.
+  bool isDistributedTargetInvocationDecoderDecodeNextArgument() const;
+
+  /// Determines if this function is a 'onReturn' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedTargetInvocationResultHandler' protocol.
+  bool isDistributedTargetInvocationResultHandlerOnReturn() const;
+
   /// For a method of a class, checks whether it will require a new entry in the
   /// vtable.
   bool needsNewVTableEntry() const;

include/swift/AST/DiagnosticsSema.def

@@ -4707,10 +4707,6 @@ ERROR(any_not_existential,none,
 ERROR(existential_requires_any,none,
       "protocol %0 as a type must be explicitly marked as 'any'",
       (Identifier))
-ERROR(explicit_existential_not_supported,none,
-       "explicit 'any' not supported; use frontend flag "
-       "-enable-explicit-existential-types to enable this feature",
-       ())
 
 ERROR(nonisolated_let,none,
       "'nonisolated' is meaningless on 'let' declarations because "
@@ -4988,7 +4984,7 @@ ERROR(unable_to_parse_c_function_type,none,
 
 // Opaque types
 ERROR(unsupported_opaque_type,none,
-      "'some' types are only implemented for the declared type of properties and subscripts and the return type of functions", ())
+      "'some' types are only permitted in properties, subscripts, and functions", ())
 
 ERROR(opaque_type_unsupported_pattern,none,
       "'some' type can only be declared on a single property declaration", ())
@@ -4997,9 +4993,9 @@ ERROR(opaque_type_in_protocol_requirement,none,
       "'some' type cannot be the return type of a protocol requirement; did you mean to add an associated type?",
       ())
 ERROR(opaque_type_in_parameter,none,
-      "'some' cannot appear in parameter position in result "
-      "type %0",
-      (Type))
+      "'some' cannot appear in parameter position in %select{result|parameter}0"
+      " type %1",
+      (bool, Type))
 
 // Function differentiability
 ERROR(attr_only_on_parameters_of_differentiable,none,

include/swift/AST/DistributedDecl.h

@@ -0,0 +1,103 @@
+//===-- DistributedDecl.h - Distributed declaration utils -------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides functions for working with declarations of distributed
+// actors and declarations related to them, like associated types and protocols.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_DECL_TYPECHECKDISTRIBUTED_H
+#define SWIFT_DECL_TYPECHECKDISTRIBUTED_H
+
+#include "swift/AST/ConcreteDeclRef.h"
+#include "swift/AST/DiagnosticEngine.h"
+#include "swift/AST/Type.h"
+
+namespace swift {
+
+class ClassDecl;
+class ConstructorDecl;
+class Decl;
+class DeclContext;
+class FuncDecl;
+class NominalTypeDecl;
+
+/// Determine the `ActorSystem` type for the given actor.
+Type getDistributedActorSystemType(NominalTypeDecl *actor);
+
+/// Determine the `ID` type for the given actor.
+Type getDistributedActorIDType(NominalTypeDecl *actor);
+
+/// Get specific 'SerializationRequirement' as defined in 'nominal'
+/// type, which must conform to the passed 'protocol' which is expected
+/// to require the 'SerializationRequirement'.
+Type getDistributedSerializationRequirementType(
+    NominalTypeDecl *nominal, ProtocolDecl *protocol);
+
+///// Determine the serialization requirement for the given actor, actor system
+///// or other type that has the SerializationRequirement associated type.
+//Type getDistributedSerializationRequirementType(
+//    NominalTypeDecl *nominal, ProtocolDecl *protocol);
+
+Type getDistributedActorSystemActorIDRequirementType(
+    NominalTypeDecl *system);
+
+
+/// Get the specific protocols that the `SerializationRequirement` specifies,
+/// and all parameters / return types of distributed targets must conform to.
+///
+/// E.g. if a system declares `typealias SerializationRequirement = Codable`
+/// then this will return `{encodableProtocol, decodableProtocol}`.
+///
+/// Returns an empty set if the requirement was `Any`.
+llvm::SmallPtrSet<ProtocolDecl *, 2>
+getDistributedSerializationRequirementProtocols(
+    NominalTypeDecl *decl, ProtocolDecl* protocol);
+
+/// Desugar and flatten the `SerializationRequirement` type into a set of
+/// specific protocol declarations.
+llvm::SmallPtrSet<ProtocolDecl *, 2>
+flattenDistributedSerializationTypeToRequiredProtocols(
+    TypeBase *serializationRequirement);
+
+/// Check if the `allRequirements` represent *exactly* the
+/// `Encodable & Decodable` (also known as `Codable`) requirement.
+///
+/// If so, we can emit slightly nicer diagnostics.
+bool checkDistributedSerializationRequirementIsExactlyCodable(
+    ASTContext &C,
+    const llvm::SmallPtrSetImpl<ProtocolDecl *> &allRequirements);
+
+/// Get the `SerializationRequirement`, explode it into the specific
+/// protocol requirements and insert them into `requirements`.
+///
+/// The passed `protocol` must be conformed to by the `decl`, e.g. a specific
+/// actor system implementation and the `DistributedActorSystem` protocol,
+/// or any of the specific encoder/decoder and the respective
+/// Distributed...Encoder/Decoder protocol etc.
+///
+/// Returns false if failed to get the protocol decls.
+bool
+getDistributedSerializationRequirements(
+    NominalTypeDecl *decl,
+    ProtocolDecl *protocol,
+    llvm::SmallPtrSetImpl<ProtocolDecl *> &requirementProtos);
+
+/// Given any set of generic requirements, locate those which are about the
+/// `SerializationRequirement`. Those need to be applied in the parameter and
+/// return type checking of distributed targets.
+llvm::SmallPtrSet<ProtocolDecl *, 2>
+extractDistributedSerializationRequirements(
+    ASTContext &C, ArrayRef<Requirement> allRequirements);
+}
+
+#endif /* SWIFT_DECL_TYPECHECKDISTRIBUTED_H */

include/swift/AST/KnownIdentifiers.def

@@ -276,6 +276,7 @@ IDENTIFIER(invocation)
 IDENTIFIER(invocationDecoder)
 IDENTIFIER(makeInvocationEncoder)
 IDENTIFIER(on)
+IDENTIFIER(onReturn)
 IDENTIFIER(recordArgument)
 IDENTIFIER(recordErrorType)
 IDENTIFIER(recordGenericSubstitution)

include/swift/AST/KnownStdlibTypes.def

@@ -49,6 +49,7 @@ KNOWN_STDLIB_TYPE_DECL(String, NominalTypeDecl, 0)
 KNOWN_STDLIB_TYPE_DECL(StaticString, NominalTypeDecl, 0)
 KNOWN_STDLIB_TYPE_DECL(Substring, NominalTypeDecl, 0)
 KNOWN_STDLIB_TYPE_DECL(Array, NominalTypeDecl, 1)
+KNOWN_STDLIB_TYPE_DECL(_ContiguousArrayStorage, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Set, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Sequence, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Dictionary, NominalTypeDecl, 2)