Merge pull request #32310 from CodaFi/relocation-allowance

Strip Attributes of their TypeLocs

Author: CodaFi

include/swift/AST/Attr.h

@@ -36,7 +36,6 @@
 #include "swift/AST/PlatformKind.h"
 #include "swift/AST/Requirement.h"
 #include "swift/AST/TrailingCallArguments.h"
-#include "swift/AST/TypeLoc.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -56,6 +55,7 @@ class LazyConformanceLoader;
 class LazyMemberLoader;
 class PatternBindingInitializer;
 class TrailingWhereClause;
+class TypeExpr;
 
 /// TypeAttributes - These are attributes that may be applied to types.
 class TypeAttributes {
@@ -1110,47 +1110,41 @@ class DynamicReplacementAttr final
 
 /// The \c @_typeEraser(TypeEraserType) attribute.
 class TypeEraserAttr final : public DeclAttribute {
-  TypeLoc TypeEraserLoc;
+  TypeExpr *TypeEraserExpr;
   LazyMemberLoader *Resolver;
   uint64_t ResolverContextData;
 
   friend class ResolveTypeEraserTypeRequest;
 
-  TypeEraserAttr(SourceLoc atLoc, SourceRange range, TypeLoc typeEraserLoc,
+  TypeEraserAttr(SourceLoc atLoc, SourceRange range, TypeExpr *typeEraserExpr,
                  LazyMemberLoader *Resolver, uint64_t Data)
       : DeclAttribute(DAK_TypeEraser, atLoc, range, /*Implicit=*/false),
-        TypeEraserLoc(typeEraserLoc),
+        TypeEraserExpr(typeEraserExpr),
         Resolver(Resolver), ResolverContextData(Data) {}
 
 public:
   static TypeEraserAttr *create(ASTContext &ctx,
                                 SourceLoc atLoc, SourceRange range,
-                                TypeLoc typeEraserLoc);
+                                TypeExpr *typeEraserRepr);
 
   static TypeEraserAttr *create(ASTContext &ctx,
                                 LazyMemberLoader *Resolver,
                                 uint64_t Data);
 
   /// Retrieve the parsed type repr for this attribute, if it
   /// was parsed. Else returns \c nullptr.
-  TypeRepr *getParsedTypeEraserTypeRepr() const {
-    return TypeEraserLoc.getTypeRepr();
-  }
+  TypeRepr *getParsedTypeEraserTypeRepr() const;
 
   /// Retrieve the parsed location for this attribute, if it was parsed.
-  SourceLoc getLoc() const {
-    return TypeEraserLoc.getLoc();
-  }
+  SourceLoc getLoc() const;
 
   /// Retrieve the resolved type of this attribute if it has been resolved by a
   /// successful call to \c getResolvedType(). Otherwise,
   /// returns \c Type()
   ///
   /// This entrypoint is only suitable for syntactic clients like the
   /// AST printer. Semantic clients should use \c getResolvedType() instead.
-  Type getTypeWithoutResolving() const {
-    return TypeEraserLoc.getType();
-  }
+  Type getTypeWithoutResolving() const;
 
   /// Returns \c true if the type eraser type has a valid implementation of the
   /// erasing initializer for the given protocol.
@@ -1464,25 +1458,26 @@ class SpecializeAttr : public DeclAttribute {
 /// The @_implements attribute, which treats a decl as the implementation for
 /// some named protocol requirement (but otherwise not-visible by that name).
 class ImplementsAttr : public DeclAttribute {
-
-  TypeLoc ProtocolType;
+  TypeExpr *ProtocolType;
   DeclName MemberName;
   DeclNameLoc MemberNameLoc;
 
 public:
   ImplementsAttr(SourceLoc atLoc, SourceRange Range,
-                 TypeLoc ProtocolType,
+                 TypeExpr *ProtocolType,
                  DeclName MemberName,
                  DeclNameLoc MemberNameLoc);
 
   static ImplementsAttr *create(ASTContext &Ctx, SourceLoc atLoc,
                                 SourceRange Range,
-                                TypeLoc ProtocolType,
+                                TypeExpr *ProtocolType,
                                 DeclName MemberName,
                                 DeclNameLoc MemberNameLoc);
 
-  TypeLoc getProtocolType() const;
-  TypeLoc &getProtocolType();
+  void setProtocolType(Type ty);
+  Type getProtocolType() const;
+  TypeRepr *getProtocolTypeRepr() const;
+
   DeclName getMemberName() const { return MemberName; }
   DeclNameLoc getMemberNameLoc() const { return MemberNameLoc; }
 
@@ -1595,27 +1590,27 @@ class ClangImporterSynthesizedTypeAttr : public DeclAttribute {
 /// Defines a custom attribute.
 class CustomAttr final : public DeclAttribute,
                          public TrailingCallArguments<CustomAttr> {
-  TypeLoc type;
+  TypeExpr *typeExpr;
   Expr *arg;
   PatternBindingInitializer *initContext;
   Expr *semanticInit = nullptr;
 
   unsigned hasArgLabelLocs : 1;
   unsigned numArgLabels : 16;
 
-  CustomAttr(SourceLoc atLoc, SourceRange range, TypeLoc type,
+  CustomAttr(SourceLoc atLoc, SourceRange range, TypeExpr *type,
              PatternBindingInitializer *initContext, Expr *arg,
              ArrayRef<Identifier> argLabels, ArrayRef<SourceLoc> argLabelLocs,
              bool implicit);
 
 public:
-  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeLoc type,
+  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeExpr *type,
                             bool implicit = false) {
     return create(ctx, atLoc, type, false, nullptr, SourceLoc(), { }, { }, { },
                   SourceLoc(), implicit);
   }
 
-  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeLoc type,
+  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeExpr *type,
                             bool hasInitializer,
                             PatternBindingInitializer *initContext,
                             SourceLoc lParenLoc,
@@ -1628,8 +1623,8 @@ class CustomAttr final : public DeclAttribute,
   unsigned getNumArguments() const { return numArgLabels; }
   bool hasArgumentLabelLocs() const { return hasArgLabelLocs; }
 
-  TypeLoc &getTypeLoc() { return type; }
-  const TypeLoc &getTypeLoc() const { return type; }
+  TypeRepr *getTypeRepr() const;
+  Type getType() const;
 
   Expr *getArg() const { return arg; }
   void setArg(Expr *newArg) { arg = newArg; }
@@ -1642,6 +1637,14 @@ class CustomAttr final : public DeclAttribute,
   static bool classof(const DeclAttribute *DA) {
     return DA->getKind() == DAK_Custom;
   }
+
+private:
+  friend class CustomAttrNominalRequest;
+  void resetTypeInformation(TypeExpr *repr);
+
+private:
+  friend class CustomAttrTypeRequest;
+  void setType(Type ty);
 };
 
 /// Relates a property to its projection value property, as described by a property wrapper. For

include/swift/AST/LazyResolver.h

@@ -18,7 +18,6 @@
 #define SWIFT_AST_LAZYRESOLVER_H
 
 #include "swift/AST/ProtocolConformanceRef.h"
-#include "swift/AST/TypeLoc.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 
 namespace swift {

include/swift/AST/TypeCheckRequests.h

@@ -2513,6 +2513,41 @@ class CodeCompletionFileRequest
   bool isCached() const { return true; }
 };
 
+/// Kinds of types for CustomAttr.
+enum class CustomAttrTypeKind {
+  /// The type is required to not be expressed in terms of
+  /// any contextual type parameters.
+  NonGeneric,
+
+  /// Property delegates have some funky rules, like allowing
+  /// unbound generic types.
+  PropertyDelegate,
+};
+
+void simple_display(llvm::raw_ostream &out, CustomAttrTypeKind value);
+
+class CustomAttrTypeRequest
+    : public SimpleRequest<CustomAttrTypeRequest,
+                           Type(CustomAttr *, DeclContext *,
+                                CustomAttrTypeKind),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  Type evaluate(Evaluator &evaluator, CustomAttr *, DeclContext *,
+                CustomAttrTypeKind) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<Type> getCachedResult() const;
+  void cacheResult(Type value) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -41,6 +41,9 @@ SWIFT_REQUEST(TypeChecker, CodeCompletionFileRequest,
 SWIFT_REQUEST(TypeChecker, CompareDeclSpecializationRequest,
               bool (DeclContext *, ValueDecl *, ValueDecl *, bool), Cached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CustomAttrTypeRequest,
+              Type(CustomAttr *, DeclContext *, CustomAttrTypeKind),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultArgumentExprRequest,
               Expr *(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultArgumentInitContextRequest,

include/swift/Basic/Statistics.def

@@ -247,9 +247,6 @@ FRONTEND_STATISTIC(Sema, NamedLazyMemberLoadSuccessCount)
 /// Number of types deserialized.
 FRONTEND_STATISTIC(Sema, NumTypesDeserialized)
 
-/// Number of types validated.
-FRONTEND_STATISTIC(Sema, NumTypesValidated)
-
 /// Number of lazy iterable declaration contexts left unloaded.
 FRONTEND_STATISTIC(Sema, NumUnloadedLazyIterableDeclContexts)
 

lib/AST/ASTScope.cpp

@@ -99,9 +99,9 @@ AttachedPropertyWrapperScope::getSourceRangeOfVarDecl(const VarDecl *const vd) {
   SourceRange sr;
   for (auto *attr : vd->getAttrs().getAttributes<CustomAttr>()) {
     if (sr.isInvalid())
-      sr = attr->getTypeLoc().getSourceRange();
+      sr = attr->getTypeRepr()->getSourceRange();
     else
-      sr.widen(attr->getTypeLoc().getSourceRange());
+      sr.widen(attr->getTypeRepr()->getSourceRange());
   }
   return sr;
 }