Merge pull request #4214 from swiftwasm/main

Author: MaxDesiatov

include/swift/AST/Decl.h

@@ -861,6 +861,8 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   void print(raw_ostream &OS) const;
   void print(raw_ostream &OS, const PrintOptions &Opts) const;
 
+  void printInherited(ASTPrinter &Printer, const PrintOptions &Options) const;
+
   /// Pretty-print the given declaration.
   ///
   /// \param Printer ASTPrinter object.

include/swift/AST/DiagnosticsSema.def

@@ -2780,8 +2780,8 @@ ERROR(inheritance_from_non_protocol_or_class,none,
   "inheritance from non-protocol, non-class type %0", (Type))
 ERROR(inheritance_from_non_protocol,none,
   "inheritance from non-protocol type %0", (Type))
-ERROR(inheritance_from_parametrized_protocol,none,
-  "cannot inherit from parametrized protocol type %0", (Type))
+ERROR(inheritance_from_parameterized_protocol,none,
+  "cannot inherit from protocol type with generic argument %0", (Type))
 ERROR(superclass_not_first,none,
   "superclass %0 must appear first in the inheritance clause", (Type))
 ERROR(superclass_not_open,none,
@@ -3723,7 +3723,7 @@ ERROR(not_a_generic_definition,none,
       "cannot specialize a non-generic definition", ())
 ERROR(not_a_generic_type,none,
       "cannot specialize non-generic type %0", (Type))
-ERROR(parametrized_protocol_not_supported,none,
+ERROR(parameterized_protocol_not_supported,none,
       "protocol type with generic argument can only be used as a generic constraint", ())
 ERROR(protocol_does_not_have_primary_assoc_type,none,
       "cannot specialize protocol type %0", (Type))

include/swift/AST/ExistentialLayout.h

@@ -42,7 +42,7 @@ struct ExistentialLayout {
 
   ExistentialLayout(ProtocolType *type);
   ExistentialLayout(ProtocolCompositionType *type);
-  ExistentialLayout(ParametrizedProtocolType *type);
+  ExistentialLayout(ParameterizedProtocolType *type);
 
   /// The explicit superclass constraint, if any.
   Type explicitSuperclass;
@@ -116,7 +116,7 @@ struct ExistentialLayout {
   ArrayRef<Type> protocols;
 
   /// Zero or more primary associated type requirements from a
-  /// ParametrizedProtocolType
+  /// ParameterizedProtocolType
   ArrayRef<PrimaryAssociatedTypeRequirement> sameTypeRequirements;
 };
 

include/swift/AST/PrintOptions.h

@@ -486,6 +486,10 @@ struct PrintOptions {
   /// Whether to print inheritance lists for types.
   bool PrintInherited = true;
 
+  /// Whether to print a space before the `:` of an inheritance list in a type
+  /// decl.
+  bool PrintSpaceBeforeInheritance = true;
+
   /// Whether to print feature checks for compatibility with older Swift
   /// compilers that might parse the result.
   bool PrintCompatibilityFeatureChecks = false;

include/swift/AST/TypeDifferenceVisitor.h

@@ -339,8 +339,8 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
                                type1->getMembers(), type2->getMembers());
   }
 
-  bool visitParametrizedProtocolType(CanParametrizedProtocolType type1,
-                                     CanParametrizedProtocolType type2) {
+  bool visitParameterizedProtocolType(CanParameterizedProtocolType type1,
+                                      CanParameterizedProtocolType type2) {
     if (asImpl().visit(type1.getBaseType(), type2.getBaseType()))
       return true;
 

include/swift/AST/TypeMatcher.h

@@ -305,20 +305,20 @@ class TypeMatcher {
     TRIVIAL_CASE(SILBoxType)
     TRIVIAL_CASE(ProtocolCompositionType)
 
-    bool visitParametrizedProtocolType(CanParametrizedProtocolType firstParametrizedProto,
-                                       Type secondType,
-                                       Type sugaredFirstType) {
-      if (auto secondParametrizedProto = secondType->getAs<ParametrizedProtocolType>()) {
+    bool visitParameterizedProtocolType(CanParameterizedProtocolType firstParametrizedProto,
+                                        Type secondType,
+                                        Type sugaredFirstType) {
+      if (auto secondParametrizedProto = secondType->getAs<ParameterizedProtocolType>()) {
         if (!this->visit(firstParametrizedProto.getBaseType(),
                          secondParametrizedProto->getBaseType(),
-                         sugaredFirstType->castTo<ParametrizedProtocolType>()
+                         sugaredFirstType->castTo<ParameterizedProtocolType>()
                              ->getBaseType())) {
           return false;
         }
 
         return this->visit(firstParametrizedProto.getArgumentType(),
                            secondParametrizedProto->getArgumentType(),
-                           sugaredFirstType->castTo<ParametrizedProtocolType>()
+                           sugaredFirstType->castTo<ParameterizedProtocolType>()
                                ->getArgumentType());
       }
 

include/swift/AST/TypeNodes.def

@@ -161,7 +161,7 @@ ARTIFICIAL_TYPE(SILBlockStorage, Type)
 ARTIFICIAL_TYPE(SILBox, Type)
 ARTIFICIAL_TYPE(SILToken, Type)
 TYPE(ProtocolComposition, Type)
-TYPE(ParametrizedProtocol, Type)
+TYPE(ParameterizedProtocol, Type)
 TYPE(Existential, Type)
 TYPE(LValue, Type)
 TYPE(InOut, Type)

include/swift/AST/Types.h

@@ -5243,7 +5243,7 @@ class ProtocolCompositionType final : public TypeBase,
 BEGIN_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
 END_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
 
-/// ParametrizedProtocolType - A type that constrains the primary associated
+/// ParameterizedProtocolType - A type that constrains the primary associated
 /// type of a protocol to an argument type.
 ///
 /// Written like a bound generic type, eg Sequence<Int>.
@@ -5259,7 +5259,7 @@ END_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
 /// \code
 /// T : Sequence where T.Element == Int.
 /// \endcode
-class ParametrizedProtocolType final : public TypeBase,
+class ParameterizedProtocolType final : public TypeBase,
     public llvm::FoldingSetNode {
   friend struct ExistentialLayout;
 
@@ -5294,18 +5294,18 @@ class ParametrizedProtocolType final : public TypeBase,
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
-    return T->getKind() == TypeKind::ParametrizedProtocol;
+    return T->getKind() == TypeKind::ParameterizedProtocol;
   }
 
 private:
-  ParametrizedProtocolType(const ASTContext *ctx,
-                           ProtocolType *base, Type arg,
-                           RecursiveTypeProperties properties);
+  ParameterizedProtocolType(const ASTContext *ctx,
+                            ProtocolType *base, Type arg,
+                            RecursiveTypeProperties properties);
 };
-BEGIN_CAN_TYPE_WRAPPER(ParametrizedProtocolType, Type)
+BEGIN_CAN_TYPE_WRAPPER(ParameterizedProtocolType, Type)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getBaseType)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getArgumentType)
-END_CAN_TYPE_WRAPPER(ParametrizedProtocolType, Type)
+END_CAN_TYPE_WRAPPER(ParameterizedProtocolType, Type)
 
 /// An existential type, spelled with \c any .
 ///
@@ -6365,7 +6365,8 @@ inline bool TypeBase::isConstraintType() const {
 
 inline bool CanType::isConstraintTypeImpl(CanType type) {
   return (isa<ProtocolType>(type) ||
-          isa<ProtocolCompositionType>(type));
+          isa<ProtocolCompositionType>(type) ||
+          isa<ParameterizedProtocolType>(type));
 }
 
 inline bool TypeBase::isExistentialType() {

include/swift/Basic/LangOptions.h

@@ -321,9 +321,9 @@ namespace swift {
     /// keyword.
     bool EnableExplicitExistentialTypes = true;
 
-    /// Enable support for protocol types parametrized by primary
+    /// Enable support for protocol types parameterized by primary
     /// associated type.
-    bool EnableParametrizedProtocolTypes = false;
+    bool EnableParameterizedProtocolTypes = false;
 
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;

include/swift/IDE/RefactoringKinds.def

@@ -54,6 +54,8 @@ CURSOR_REFACTORING(MemberwiseInitLocalRefactoring, "Generate Memberwise Initiali
 
 CURSOR_REFACTORING(AddEquatableConformance, "Add Equatable Conformance", add.equatable.conformance)
 
+CURSOR_REFACTORING(AddExplicitCodableImplementation, "Add Explicit Codable Implementation", add.explicit-codable-implementation)
+
 CURSOR_REFACTORING(ConvertCallToAsyncAlternative, "Convert Call to Async Alternative", convert.call-to-async)
 
 CURSOR_REFACTORING(ConvertToAsync, "Convert Function to Async", convert.func-to-async)