Merge pull request #63324 from rjmccall/element-archetype-printing

Fix printing and implement parsing of opened element archetypes in SIL

Author: rjmccall

include/swift/AST/Attr.def.gyb

@@ -84,6 +84,7 @@ TYPE_ATTR(callee_owned)
 TYPE_ATTR(callee_guaranteed)
 TYPE_ATTR(objc_metatype)
 TYPE_ATTR(opened)
+TYPE_ATTR(pack_element)
 TYPE_ATTR(pseudogeneric)
 TYPE_ATTR(yields)
 TYPE_ATTR(yield_once)

include/swift/AST/DiagnosticsParse.def

@@ -677,6 +677,7 @@ ERROR(expected_generic_signature,none,
       "expected a generic signature", ())
 ERROR(sil_expected_uuid,none,
       "expected a UUID string literal", ())
+NOTE(sil_previous_instruction,none, "previous instruction", ())
 
 // SIL Basic Blocks
 ERROR(expected_sil_block_name,none,
@@ -1656,6 +1657,14 @@ ERROR(opened_attribute_id_value,none,
 ERROR(opened_attribute_expected_rparen,none,
       "expected ')' after id value for 'opened' attribute", ())
 
+// pack_element
+ERROR(pack_element_attribute_expected_lparen,none,
+      "expected '(' after 'pack_element' attribute", ())
+ERROR(pack_element_attribute_expected_rparen,none,
+      "expected ')' after id value for 'pack_element' attribute", ())
+ERROR(multiple_open_pack_element,none,
+      "multiple 'open_pack_element' instructions with same UUID", ())
+
 // unowned
 ERROR(attr_unowned_invalid_specifier,none,
       "expected 'safe' or 'unsafe'", ())

include/swift/AST/DiagnosticsSema.def

@@ -5302,6 +5302,8 @@ NOTE(overridden_required_initializer_here,none,
 // Functions
 ERROR(attribute_requires_function_type,none,
       "@%0 attribute only applies to function types", (StringRef))
+ERROR(generic_function_type,none,
+      "function values cannot be generic", ())
 ERROR(unsupported_convention,none,
       "convention '%0' not supported", (StringRef))
 ERROR(unreferenced_generic_parameter,NoUsage,
@@ -5383,6 +5385,9 @@ ERROR(illegal_sil_type,none,
       "type %0 is not a legal SIL value type", (Type))
 ERROR(sil_box_arg_mismatch,none,
       "SIL box type has wrong number of generic arguments for layout", ())
+ERROR(sil_pack_element_uuid_not_found,none,
+      "open_pack_element instruction not found for @pack_element type UUID; "
+      "possible forward reference?", ())
 // SIL Metatypes
 ERROR(sil_metatype_without_repr,none,
       "metatypes in SIL must have @thin, @thick, or @objc_metatype attribute",

include/swift/AST/GenericEnvironment.h

@@ -35,7 +35,9 @@ class ArchetypeType;
 class ASTContext;
 class GenericTypeParamType;
 class OpaqueTypeDecl;
+class ElementArchetypeType;
 class OpenedArchetypeType;
+class PackArchetypeType;
 class SILModule;
 class SILType;
 

include/swift/AST/TypeCheckRequests.h

@@ -3292,8 +3292,7 @@ class ModuleLibraryLevelRequest
 
 class ResolveTypeRequest
     : public SimpleRequest<ResolveTypeRequest,
-                           Type(const TypeResolution *, TypeRepr *,
-                                GenericParamList *),
+                           Type(const TypeResolution *, TypeRepr *),
                            RequestFlags::Uncached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -3302,12 +3301,15 @@ class ResolveTypeRequest
   // Cycle handling.
   void noteCycleStep(DiagnosticEngine &diags) const;
 
+  static Type evaluate(const TypeResolution &resolution,
+                       TypeRepr *repr);
+
 private:
   friend SimpleRequest;
 
   // Evaluation.
   Type evaluate(Evaluator &evaluator, const TypeResolution *resolution,
-                TypeRepr *repr, GenericParamList *silParams) const;
+                TypeRepr *repr) const;
 };
 
 void simple_display(llvm::raw_ostream &out, const TypeResolution *resolution);

include/swift/Sema/SILTypeResolutionContext.h

@@ -0,0 +1,51 @@
+//===--- SILTypeResolutionContext.h -----------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SEMA_SILTYPERESOLUTIONCONTEXT_H
+#define SWIFT_SEMA_SILTYPERESOLUTIONCONTEXT_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "swift/Basic/UUID.h"
+
+namespace swift {
+class GenericParamList;
+class GenericEnvironment;
+
+class SILTypeResolutionContext {
+public:
+  struct OpenedPackElement {
+    SourceLoc DefinitionPoint;
+    GenericParamList *Params;
+    GenericEnvironment *Environment;
+  };
+  using OpenedPackElementsMap = llvm::DenseMap<UUID, OpenedPackElement>;
+
+  /// Are we requesting a SIL type?
+  bool IsSILType;
+
+  /// Look up types in the given parameter list.
+  GenericParamList *GenericParams;
+
+  /// Look up @pack_element environments in this map.
+  OpenedPackElementsMap *OpenedPackElements;
+
+  SILTypeResolutionContext(bool isSILType,
+                           GenericParamList *genericParams,
+                           OpenedPackElementsMap *openedPackElements)
+    : IsSILType(isSILType),
+      GenericParams(genericParams),
+      OpenedPackElements(openedPackElements) {}
+};
+
+}
+
+#endif

include/swift/Subsystems.h

@@ -64,6 +64,7 @@ namespace swift {
   class SerializationOptions;
   class SILOptions;
   class SILModule;
+  class SILTypeResolutionContext;
   class SourceFile;
   enum class SourceFileKind;
   class SourceManager;
@@ -163,10 +164,9 @@ namespace swift {
   /// code completion).
   ///
   /// \returns A well-formed type on success, or an \c ErrorType.
-  Type performTypeResolution(TypeRepr *TyR, ASTContext &Ctx, bool isSILMode,
-                             bool isSILType,
+  Type performTypeResolution(TypeRepr *TyR, ASTContext &Ctx,
                              GenericSignature GenericSig,
-                             GenericParamList *GenericParams,
+                             SILTypeResolutionContext *SILContext,
                              DeclContext *DC, bool ProduceDiagnostics = true);
 
   /// Expose TypeChecker's handling of GenericParamList to SIL parsing.

lib/AST/ASTPrinter.cpp

@@ -5460,6 +5460,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     } else if (auto archetype = dyn_cast<ArchetypeType>(T.getPointer())) {
       if (archetype->isParameterPack() && Options.PrintExplicitEach)
         return false;
+      if (Options.PrintForSIL && isa<LocalArchetypeType>(archetype))
+        return false;
     }
     return T->hasSimpleTypeRepr();
   }
@@ -6621,12 +6623,58 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  static Type findPackForElementArchetype(ElementArchetypeType *T) {
+    // The type in @pack_element is looked up in the generic params
+    // of the identified open_pack_element instruction.  The param list
+    // is long gone, but the sugar survives in the type parameters of
+    // the generic signature of the contextual substitution map in the
+    // opened element environment.
+    auto env = T->getGenericEnvironment();
+    auto subs = env->getPackElementContextSubstitutions();
+    auto sig = subs.getGenericSignature();
+    auto params = sig.getGenericParams();
+
+    auto elementShapeClass =
+      env->getOpenedElementShapeClass()->mapTypeOutOfContext();
+
+    // The element archetypes are at a depth one past the max depth
+    // of the base signature.
+    unsigned elementDepth = params.back()->getDepth() + 1;
+
+    // Transform the archetype's interface type to be based on the
+    // corresponding non-canonical type parameter.
+    auto interfaceType = T->getInterfaceType();
+    return interfaceType.subst([&](SubstitutableType *type) -> Type {
+      // Don't transform types that aren't element type parameters.
+      auto *elementParam = type->getAs<GenericTypeParamType>();
+      if (!elementParam || elementParam->getDepth() != elementDepth)
+        return Type();
+
+      // Loop through the type parameters looking for the type parameter
+      // pack at the appropriate index.  We only expect to actually do
+      // this once for each type, so it's fine to do it in the callback.
+      unsigned nextIndex = 0;
+      for (auto *genericParam : params) {
+        if (!genericParam->isParameterPack())
+          continue;
+
+        if (!sig->haveSameShape(genericParam, elementShapeClass))
+          continue;
+
+        if (nextIndex == elementParam->getIndex())
+          return genericParam;
+        nextIndex++;
+      }
+      llvm_unreachable("ran out of type parameters");
+      return Type();
+    }, LookUpConformanceInSignature(sig.getPointer()));
+  }
+
   void visitElementArchetypeType(ElementArchetypeType *T) {
     if (Options.PrintForSIL) {
-      Printer << "@element(\"" << T->getOpenedElementID() << ") ";
-
-      auto interfaceTy = T->getInterfaceType();
-      visit(interfaceTy);
+      Printer << "@pack_element(\"" << T->getOpenedElementID() << "\") ";
+      auto packTy = findPackForElementArchetype(T);
+      visit(packTy);
     } else {
       visit(T->getInterfaceType());
     }

lib/AST/GenericEnvironment.cpp

@@ -547,7 +547,7 @@ Type QueryInterfaceTypeSubstitutions::operator()(SubstitutableType *type) const{
 Type GenericEnvironment::mapTypeIntoContext(
                                 Type type,
                                 LookupConformanceFn lookupConformance) const {
-  assert((!type->hasArchetype() || type->hasOpenedExistential()) &&
+  assert((!type->hasArchetype() || type->hasLocalArchetype()) &&
          "already have a contextual type");
 
   type = maybeApplyOuterContextSubstitutions(type);

lib/AST/Type.cpp

@@ -4710,7 +4710,7 @@ static Type substType(Type derivedType,
     if (origArchetype->isRoot()) {
       // Root opened archetypes are not required to be substituted. Other root
       // archetypes must already have been substituted above.
-      if (isa<OpenedArchetypeType>(origArchetype)) {
+      if (isa<LocalArchetypeType>(origArchetype)) {
         return Type(type);
       } else {
         return ErrorType::get(type);