Merge pull request swiftlang#4518 from swiftwasm/katei/merge-5.7-2022-05-06

Merge 5.7 2022-05-06

Author: kateinoigakukun

SwiftCompilerSources/Sources/Parse/Regex.swift

@@ -15,14 +15,14 @@ import AST
 import Basic
 
 #if canImport(_CompilerRegexParser)
-import _CompilerRegexParser
+@_spi(CompilerInterface) import _CompilerRegexParser
 
 public func registerRegexParser() {
   Parser_registerRegexLiteralParsingFn(_RegexLiteralParsingFn)
   Parser_registerRegexLiteralLexingFn(_RegexLiteralLexingFn)
 }
 
-/// Bridging between C++ lexer and _CompilerRegexParser.lexRegex()
+/// Bridging between C++ lexer and swiftCompilerLexRegexLiteral.
 ///
 /// Attempt to lex a regex literal string.
 ///
@@ -50,47 +50,29 @@ private func _RegexLiteralLexingFn(
 ) -> /*CompletelyErroneous*/ CBool {
   let inputPtr = curPtrPtr.pointee
 
-  do {
-    let (_, _, endPtr) = try lexRegex(start: inputPtr, end: bufferEndPtr)
-    curPtrPtr.pointee = endPtr.assumingMemoryBound(to: CChar.self)
+  guard let (resumePtr, error) = swiftCompilerLexRegexLiteral(
+    start: inputPtr, bufferEnd: bufferEndPtr, mustBeRegex: mustBeRegex
+  ) else {
+    // Not a regex literal, fallback without advancing the pointer.
     return false
-  } catch let error as DelimiterLexError {
-    if !mustBeRegex {
-      // This token can be something else. Let the client fallback.
-      return false;
-    }
-    if error.kind == .unknownDelimiter {
-      // An unknown delimiter should be recovered from, as we may want to try
-      // lex something else.
-      return false
-    }
+  }
 
+  // Advance the current pointer.
+  curPtrPtr.pointee = resumePtr.assumingMemoryBound(to: CChar.self)
+
+  if let error = error {
+    // Emit diagnostic if diagnostics are enabled.
     if let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine) {
-      // Emit diagnostic.
       let startLoc = SourceLoc(
-        locationInFile: UnsafeRawPointer(inputPtr).assumingMemoryBound(to: UInt8.self))!
-      diagEngine.diagnose(startLoc, .regex_literal_parsing_error, "\(error)")
-    }
-
-    // Advance the current pointer.
-    curPtrPtr.pointee = error.resumePtr.assumingMemoryBound(to: CChar.self)
-
-    switch error.kind {
-    case .unterminated, .multilineClosingNotOnNewline:
-      // These can be recovered from.
-      return false
-    case .unprintableASCII, .invalidUTF8:
-      // We don't currently have good recovery behavior for these.
-      return true
-    case .unknownDelimiter:
-      fatalError("Already handled")
+        locationInFile: error.location.assumingMemoryBound(to: UInt8.self))!
+      diagEngine.diagnose(startLoc, .regex_literal_parsing_error, error.message)
     }
-  } catch {
-    fatalError("Should be a DelimiterLexError")
+    return error.completelyErroneous
   }
+  return false
 }
 
-/// Bridging between C++ parser and _CompilerRegexParser.parseWithDelimiters()
+/// Bridging between C++ parser and swiftCompilerParseRegexLiteral.
 ///
 /// - Parameters:
 ///   - inputPtr: A null-terminated C string.
@@ -103,6 +85,8 @@ private func _RegexLiteralLexingFn(
 ///     greater than or equal to `strlen(inputPtr)`.
 ///   - bridgedDiagnosticBaseLoc: Source location of the start of the literal
 ///   - bridgedDiagnosticEngine: Diagnostic engine to emit diagnostics.
+///
+/// - Returns: `true` if there was a parse error, `false` otherwise.
 public func _RegexLiteralParsingFn(
   _ inputPtr: UnsafePointer<CChar>,
   _ versionOut: UnsafeMutablePointer<CUnsignedInt>,
@@ -111,30 +95,27 @@ public func _RegexLiteralParsingFn(
   _ bridgedDiagnosticBaseLoc: BridgedSourceLoc,
   _ bridgedDiagnosticEngine: BridgedDiagnosticEngine
 ) -> Bool {
-  versionOut.pointee = currentRegexLiteralFormatVersion
-
   let str = String(cString: inputPtr)
+  let captureBuffer = UnsafeMutableRawBufferPointer(
+    start: captureStructureOut, count: Int(captureStructureSize))
   do {
-    let ast = try parseWithDelimiters(str)
-    // Serialize the capture structure for later type inference.
-    assert(captureStructureSize >= str.utf8.count)
-    let buffer = UnsafeMutableRawBufferPointer(
-        start: captureStructureOut, count: Int(captureStructureSize))
-    ast.captureStructure.encode(to: buffer)
-    return false;
-  } catch {
+    // FIXME: We need to plumb through the 'regexToEmit' result to the caller.
+    // For now, it is the same as the input.
+    let (_, version) = try swiftCompilerParseRegexLiteral(
+      str, captureBufferOut: captureBuffer)
+    versionOut.pointee = CUnsignedInt(version)
+    return false
+  } catch let error as CompilerParseError {
     var diagLoc = SourceLoc(bridged: bridgedDiagnosticBaseLoc)
     let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine)
-    if let _diagLoc = diagLoc,
-       let locatedError = error as? LocatedErrorProtocol {
-      let offset = str.utf8.distance(from: str.startIndex,
-                                     to: locatedError.location.start)
+    if let _diagLoc = diagLoc, let errorLoc = error.location {
+      let offset = str.utf8.distance(from: str.startIndex, to: errorLoc)
       diagLoc = _diagLoc.advanced(by: offset)
     }
-    diagEngine.diagnose(
-      diagLoc, .regex_literal_parsing_error,
-      "cannot parse regular expression: \(String(describing: error))")
+    diagEngine.diagnose(diagLoc, .regex_literal_parsing_error, error.message)
     return true
+  } catch {
+    fatalError("Expected CompilerParseError")
   }
 }
 

include/swift/ABI/GenericContext.h

@@ -58,7 +58,7 @@ struct TargetGenericContextDescriptorHeader {
   /// Key arguments include generic parameters and conformance
   /// requirements which are part of the identity of the context.
   ///
-  /// The key area of the argument layout considers of a sequence
+  /// The key area of the argument layout consists of a sequence
   /// of type metadata pointers (in the same order as the parameter
   /// descriptors, for those parameters which satisfy hasKeyArgument())
   /// followed by a sequence of witness table pointers (in the same
@@ -191,25 +191,48 @@ using GenericRequirementDescriptor =
 extern const GenericParamDescriptor
 ImplicitGenericParamDescriptors[MaxNumImplicitGenericParamDescriptors];
 
+inline const GenericParamDescriptor *
+externalTargetImplicitGenericParamDescriptors() {
+  static const GenericParamDescriptor
+      buffer[MaxNumImplicitGenericParamDescriptors] = {
+#define D GenericParamDescriptor::implicit()
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D
+#undef D
+      };
+  return buffer;
+}
+
+template <class Runtime>
+const GenericParamDescriptor *targetImplicitGenericParamDescriptors() {
+  return externalTargetImplicitGenericParamDescriptors();
+}
+template <>
+inline const GenericParamDescriptor *targetImplicitGenericParamDescriptors<InProcess>() {
+  return ImplicitGenericParamDescriptors;
+}
+
 /// A runtime description of a generic signature.
+template<typename Runtime>
 class RuntimeGenericSignature {
-  GenericContextDescriptorHeader Header;
+  TargetGenericContextDescriptorHeader<Runtime> Header;
   const GenericParamDescriptor *Params;
-  const GenericRequirementDescriptor *Requirements;
+  const TargetGenericRequirementDescriptor<Runtime> *Requirements;
 public:
   RuntimeGenericSignature()
     : Header{0, 0, 0, 0}, Params(nullptr), Requirements(nullptr) {}
 
-  RuntimeGenericSignature(const GenericContextDescriptorHeader &header,
+  RuntimeGenericSignature(const TargetGenericContextDescriptorHeader<Runtime> &header,
                           const GenericParamDescriptor *params,
-                          const GenericRequirementDescriptor *requirements)
+                          const TargetGenericRequirementDescriptor<Runtime> *requirements)
     : Header(header), Params(params), Requirements(requirements) {}
 
   llvm::ArrayRef<GenericParamDescriptor> getParams() const {
     return llvm::makeArrayRef(Params, Header.NumParams);
   }
 
-  llvm::ArrayRef<GenericRequirementDescriptor> getRequirements() const {
+  llvm::ArrayRef<TargetGenericRequirementDescriptor<Runtime>> getRequirements() const {
     return llvm::makeArrayRef(Requirements, Header.NumRequirements);
   }
 
@@ -375,8 +398,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
              * sizeof(StoredPointer);
   }
 
-  RuntimeGenericSignature getGenericSignature() const {
-    if (!asSelf()->isGeneric()) return RuntimeGenericSignature();
+  RuntimeGenericSignature<Runtime> getGenericSignature() const {
+    if (!asSelf()->isGeneric()) return RuntimeGenericSignature<Runtime>();
     return {getGenericContextHeader(),
             getGenericParams().data(),
             getGenericRequirements().data()};

include/swift/ABI/Metadata.h

@@ -1735,6 +1735,12 @@ struct TargetExistentialTypeMetadata
 using ExistentialTypeMetadata
   = TargetExistentialTypeMetadata<InProcess>;
 
+template<typename Runtime>
+struct TargetExistentialTypeExpression {
+  /// The type expression.
+  TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false> name;
+};
+
 /// A description of the shape of an existential type.
 ///
 /// An existential type has the general form:
@@ -1791,7 +1797,7 @@ struct TargetExtendedExistentialTypeShape
       // Optional generalization signature header
       TargetGenericContextDescriptorHeader<Runtime>,
       // Optional type subexpression
-      TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>,
+      TargetExistentialTypeExpression<Runtime>,
       // Optional suggested value witnesses
       TargetRelativeIndirectablePointer<Runtime, const TargetValueWitnessTable<Runtime>,
                                         /*nullable*/ false>,
@@ -1802,8 +1808,6 @@ struct TargetExtendedExistentialTypeShape
       // for generalization signature
       TargetGenericRequirementDescriptor<Runtime>> {
 private:
-  using RelativeStringPointer =
-    TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>;
   using RelativeValueWitnessTablePointer =
     TargetRelativeIndirectablePointer<Runtime,
                                       const TargetValueWitnessTable<Runtime>,
@@ -1812,7 +1816,7 @@ struct TargetExtendedExistentialTypeShape
     swift::ABI::TrailingObjects<
       TargetExtendedExistentialTypeShape<Runtime>,
       TargetGenericContextDescriptorHeader<Runtime>,
-      RelativeStringPointer,
+      TargetExistentialTypeExpression<Runtime>,
       RelativeValueWitnessTablePointer,
       GenericParamDescriptor,
       TargetGenericRequirementDescriptor<Runtime>>;
@@ -1825,7 +1829,7 @@ struct TargetExtendedExistentialTypeShape
     return Flags.hasGeneralizationSignature();
   }
 
-  size_t numTrailingObjects(OverloadToken<RelativeStringPointer>) const {
+  size_t numTrailingObjects(OverloadToken<TargetExistentialTypeExpression<Runtime>>) const {
     return Flags.hasTypeExpression();
   }
 
@@ -1879,12 +1883,13 @@ struct TargetExtendedExistentialTypeShape
   /// we nonetheless distinguish at compile time.  Storing this also
   /// allows us to far more easily produce a formal type from this
   /// shape reflectively.
-  RelativeStringPointer ExistentialType;
+  TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>
+      ExistentialType;
 
   /// The header describing the requirement signature of the existential.
   TargetGenericContextDescriptorHeader<Runtime> ReqSigHeader;
 
-  RuntimeGenericSignature getRequirementSignature() const {
+  RuntimeGenericSignature<Runtime> getRequirementSignature() const {
     return {ReqSigHeader, getReqSigParams(), getReqSigRequirements()};
   }
 
@@ -1894,8 +1899,8 @@ struct TargetExtendedExistentialTypeShape
 
   const GenericParamDescriptor *getReqSigParams() const {
     return Flags.hasImplicitReqSigParams()
-             ? ImplicitGenericParamDescriptors
-             : this->template getTrailingObjects<GenericParamDescriptor>();
+               ? swift::targetImplicitGenericParamDescriptors<Runtime>()
+               : this->template getTrailingObjects<GenericParamDescriptor>();
   }
 
   unsigned getNumReqSigRequirements() const {
@@ -1911,10 +1916,11 @@ struct TargetExtendedExistentialTypeShape
   /// The type expression of the existential, as a symbolic mangled type
   /// string.  Must be null if the header is just the (single)
   /// requirement type parameter.
-  TargetPointer<Runtime, const char> getTypeExpression() const {
+  const TargetExistentialTypeExpression<Runtime> *getTypeExpression() const {
     return Flags.hasTypeExpression()
-      ? this->template getTrailingObjects<RelativeStringPointer>()->get()
-      : nullptr;
+               ? this->template getTrailingObjects<
+                     TargetExistentialTypeExpression<Runtime>>()
+               : nullptr;
   }
 
   bool isTypeExpressionOpaque() const {
@@ -1961,8 +1967,8 @@ struct TargetExtendedExistentialTypeShape
     return Flags.hasGeneralizationSignature();
   }
 
-  RuntimeGenericSignature getGeneralizationSignature() const {
-    if (!hasGeneralizationSignature()) return RuntimeGenericSignature();
+  RuntimeGenericSignature<Runtime> getGeneralizationSignature() const {
+    if (!hasGeneralizationSignature()) return RuntimeGenericSignature<Runtime>();
     return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements()};
   }
 
@@ -1974,7 +1980,7 @@ struct TargetExtendedExistentialTypeShape
   const GenericParamDescriptor *getGenSigParams() const {
     assert(hasGeneralizationSignature());
     if (Flags.hasImplicitGenSigParams())
-      return ImplicitGenericParamDescriptors;
+      return swift::targetImplicitGenericParamDescriptors<Runtime>();
     auto base = this->template getTrailingObjects<GenericParamDescriptor>();
     if (!Flags.hasImplicitReqSigParams())
       base += getNumReqSigParams();
@@ -2086,6 +2092,8 @@ struct TargetExtendedExistentialTypeMetadata
     swift::ABI::TrailingObjects<
       TargetExtendedExistentialTypeMetadata<Runtime>,
       ConstTargetPointer<Runtime, void>> {
+  using StoredSize = typename Runtime::StoredSize;
+
 private:
   using TrailingObjects =
     swift::ABI::TrailingObjects<
@@ -2097,9 +2105,12 @@ struct TargetExtendedExistentialTypeMetadata
   using OverloadToken = typename TrailingObjects::template OverloadToken<T>;
 
   size_t numTrailingObjects(OverloadToken<ConstTargetPointer<Runtime, void>>) const {
-    return Shape->getGenSigLayoutSizeInWords();
+    return Shape->getGenSigArgumentLayoutSizeInWords();
   }
 
+public:
+  static constexpr StoredSize OffsetToArguments = sizeof(TargetMetadata<Runtime>);
+
 public:
   explicit constexpr
   TargetExtendedExistentialTypeMetadata(const ExtendedExistentialTypeShape *shape)
@@ -2113,6 +2124,11 @@ struct TargetExtendedExistentialTypeMetadata
   ConstTargetPointer<Runtime, void> const *getGeneralizationArguments() const {
     return this->template getTrailingObjects<ConstTargetPointer<Runtime, void>>();
   }
+
+public:
+  static bool classof(const TargetMetadata<Runtime> *metadata) {
+    return metadata->getKind() == MetadataKind::ExtendedExistential;
+  }
 };
 using ExtendedExistentialTypeMetadata
   = TargetExtendedExistentialTypeMetadata<InProcess>;

include/swift/AST/ASTDemangler.h

@@ -59,6 +59,11 @@ class ASTBuilder {
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
   using BuiltProtocolDecl = swift::ProtocolDecl *;
+  using BuiltGenericSignature = swift::GenericSignature;
+  using BuiltGenericTypeParam = swift::GenericTypeParamType *;
+  using BuiltRequirement = swift::Requirement;
+  using BuiltSubstitutionMap = swift::SubstitutionMap;
+
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
 
   ASTContext &getASTContext() { return Ctx; }
@@ -112,6 +117,8 @@ class ASTBuilder {
                                      bool isClassBound,
                                      bool forRequirement = true);
 
+  Type createProtocolTypeFromDecl(ProtocolDecl *protocol);
+
   Type createParameterizedProtocolType(Type base, ArrayRef<Type> args);
 
   Type createExistentialMetatypeType(Type instance,
@@ -134,7 +141,6 @@ class ASTBuilder {
   Type createSILBoxType(Type base);
   using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
   using BuiltSubstitution = std::pair<Type, Type>;
-  using BuiltRequirement = swift::Requirement;
   using BuiltLayoutConstraint = swift::LayoutConstraint;
   Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
                                   ArrayRef<BuiltSubstitution> Substitutions,
@@ -167,6 +173,15 @@ class ASTBuilder {
 
   Type createParenType(Type base);
 
+  BuiltGenericSignature
+  createGenericSignature(ArrayRef<BuiltType> params,
+                         ArrayRef<BuiltRequirement> requirements);
+
+  BuiltSubstitutionMap createSubstitutionMap(BuiltGenericSignature sig,
+                                             ArrayRef<BuiltType> replacements);
+
+  Type subst(Type subject, const BuiltSubstitutionMap &Subs) const;
+
   LayoutConstraint getLayoutConstraint(LayoutConstraintKind kind);
   LayoutConstraint getLayoutConstraintWithSizeAlign(LayoutConstraintKind kind,
                                                     unsigned size,