Merge pull request #6570 from rudkx/type-accessors-for-exprs

Author: swift-ci

include/swift/AST/Expr.h

@@ -538,13 +538,20 @@ class alignas(8) Expr {
   ///
   /// This distinguishes static references to types, like Int, from metatype
   /// values, "someTy: Any.Type".
-  bool isTypeReference() const;
+  bool isTypeReference(llvm::function_ref<Type(const Expr &)> getType
+                       = [](const Expr &E) -> Type {
+                         return E.getType();
+                       }) const;
 
   /// Determine whether this expression refers to a statically-derived metatype.
   ///
   /// This implies `isTypeReference`, but also requires that the referenced type
   /// is not an archetype or dependent type.
-  bool isStaticallyDerivedMetatype() const;
+  bool isStaticallyDerivedMetatype(
+      llvm::function_ref<Type(const Expr &)> getType
+      = [](const Expr &E) -> Type {
+        return E.getType();
+      }) const;
 
   /// isImplicit - Determines whether this expression was implicitly-generated,
   /// rather than explicitly written in the AST.
@@ -1324,7 +1331,14 @@ class TypeExpr : public Expr {
 
   // The type of a TypeExpr is always a metatype type.  Return the instance
   // type, ErrorType if an error, or null if not set yet.
-  Type getInstanceType() const;
+  Type getInstanceType(llvm::function_ref<bool(const Expr &)> hasType
+                       = [](const Expr &E) -> bool {
+                         return !!E.getType();
+                       },
+                       llvm::function_ref<Type(const Expr &)> getType
+                       = [](const Expr &E) -> Type {
+                         return E.getType();
+                       }) const;
 
   // Create an implicit TypeExpr, which has no location information.
   static TypeExpr *createImplicit(Type Ty, ASTContext &C) {

lib/AST/Expr.cpp

@@ -567,9 +567,10 @@ void Expr::forEachChildExpr(const std::function<Expr*(Expr*)> &callback) {
   this->walk(ChildWalker(callback));
 }
 
-bool Expr::isTypeReference() const {
+bool Expr::
+isTypeReference(llvm::function_ref<Type(const Expr &)> getType) const {
   // If the result isn't a metatype, there's nothing else to do.
-  if (!getType()->is<AnyMetatypeType>())
+  if (!getType(*this)->is<AnyMetatypeType>())
     return false;
 
   const Expr *expr = this;
@@ -600,13 +601,14 @@ bool Expr::isTypeReference() const {
 
 }
 
-bool Expr::isStaticallyDerivedMetatype() const {
+bool Expr::isStaticallyDerivedMetatype(
+    llvm::function_ref<Type(const Expr &)> getType) const {
   // The type must first be a type reference.
-  if (!isTypeReference())
+  if (!isTypeReference(getType))
     return false;
 
   // Archetypes are never statically derived.
-  return !getType()->getAs<AnyMetatypeType>()->getInstanceType()
+  return !getType(*this)->getAs<AnyMetatypeType>()->getInstanceType()
     ->is<ArchetypeType>();
 }
 
@@ -1890,14 +1892,16 @@ TypeExpr::TypeExpr(Type Ty)
 
 // The type of a TypeExpr is always a metatype type.  Return the instance
 // type or null if not set yet.
-Type TypeExpr::getInstanceType() const {
-  if (!getType())
+Type TypeExpr::getInstanceType(
+    llvm::function_ref<bool(const Expr &)> hasType,
+    llvm::function_ref<Type(const Expr &)> getType) const {
+  if (!hasType(*this))
     return Type();
 
-  if (auto metaType = getType()->getAs<MetatypeType>())
+  if (auto metaType = getType(*this)->getAs<MetatypeType>())
     return metaType->getInstanceType();
 
-  return ErrorType::get(getType()->getASTContext());
+  return ErrorType::get(getType(*this)->getASTContext());
 }
 
 

lib/Sema/CSApply.cpp

@@ -272,6 +272,20 @@ void ConstraintSystem::propagateLValueAccessKind(Expr *E,
                                allowOverwrite);
 }
 
+bool ConstraintSystem::isTypeReference(Expr *E) {
+  return E->isTypeReference([&](const Expr &E) -> Type { return getType(&E); });
+}
+
+bool ConstraintSystem::isStaticallyDerivedMetatype(Expr *E) {
+  return E->isStaticallyDerivedMetatype(
+      [&](const Expr &E) -> Type { return getType(&E); });
+}
+
+Type ConstraintSystem::getInstanceType(TypeExpr *E) {
+  return E->getInstanceType([&](const Expr &E) -> bool { return hasType(&E); },
+                            [&](const Expr &E) -> Type { return getType(&E); });
+}
+
 namespace {
 
   /// \brief Rewrites an expression by applying the solution of a constraint
@@ -6478,7 +6492,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
 
   // If the metatype value isn't a type expression, the user should reference
   // '.init' explicitly, for clarity.
-  if (!fn->isTypeReference()) {
+  if (!cs.isTypeReference(fn)) {
     cs.TC.diagnose(apply->getArg()->getStartLoc(),
                    diag::missing_init_on_metatype_initialization)
       .fixItInsert(apply->getArg()->getStartLoc(), ".init");

lib/Sema/ConstraintSystem.h

@@ -1774,12 +1774,28 @@ class ConstraintSystem {
   bool isAnyHashableType(Type t);
 
   /// Call Expr::propagateLValueAccessKind on the given expression,
-  /// using a custom accessor for the type on the expression which
+  /// using a custom accessor for the type on the expression that
   /// reads the type from the ConstraintSystem expression type map.
   void propagateLValueAccessKind(Expr *E,
                                  AccessKind accessKind,
                                  bool allowOverwrite = false);
 
+  /// Call Expr::isTypeReference on the given expression, using a
+  /// custom accessor for the type on the expression that reads the
+  /// type from the ConstraintSystem expression type map.
+  bool isTypeReference(Expr *E);
+
+  /// Call Expr::isIsStaticallyDerivedMetatype on the given
+  /// expression, using a custom accessor for the type on the
+  /// expression that reads the type from the ConstraintSystem
+  /// expression type map.
+  bool isStaticallyDerivedMetatype(Expr *E);
+
+  /// Call Expr::getInstanceType on the given expression, using a
+  /// custom accessor for the type on the expression that reads the
+  /// type from the ConstraintSystem expression type map.
+  Type getInstanceType(TypeExpr *E);
+
 private:
   /// Introduce the constraints associated with the given type variable
   /// into the worklist.