[AST] Add getDecl parameter to Expr::isTypeRerefence

So it could be extended to support not yet fully type-checked
AST when used by constraint system solver.

Author: xedin

include/swift/AST/Expr.h

@@ -466,9 +466,11 @@ class alignas(8) Expr {
   /// This distinguishes static references to types, like Int, from metatype
   /// values, "someTy: Any.Type".
   bool isTypeReference(llvm::function_ref<Type(const Expr *)> getType =
-                           [](const Expr *E) -> Type {
-    return E->getType();
-  }) const;
+                           [](const Expr *E) -> Type { return E->getType(); },
+                       llvm::function_ref<Decl *(const Expr *)> getDecl =
+                           [](const Expr *E) -> Decl * {
+                         return nullptr;
+                       }) const;
 
   /// Determine whether this expression refers to a statically-derived metatype.
   ///

lib/AST/Expr.cpp

@@ -440,7 +440,8 @@ void Expr::forEachChildExpr(llvm::function_ref<Expr *(Expr *)> callback) {
 }
 
 bool Expr::isTypeReference(
-    llvm::function_ref<Type(const Expr *)> getType) const {
+    llvm::function_ref<Type(const Expr *)> getType,
+    llvm::function_ref<Decl *(const Expr *)> getDecl) const {
   // If the result isn't a metatype, there's nothing else to do.
   if (!getType(this)->is<AnyMetatypeType>())
     return false;
@@ -461,6 +462,12 @@ bool Expr::isTypeReference(
     if (auto memberRef = dyn_cast<MemberRefExpr>(expr))
       return isa<TypeDecl>(memberRef->getMember().getDecl());
 
+    // Any other expressions which might be referencing
+    // a declaration e.g. not yet type-checked ones like
+    // `UnresolvedDotExpr`.
+    if (auto *decl = getDecl(expr))
+      return isa<TypeDecl>(decl);
+
     // When the base of a "." expression is ignored, look at the member.
     if (auto ignoredDot = dyn_cast<DotSyntaxBaseIgnoredExpr>(expr)) {
       expr = ignoredDot->getRHS();
@@ -470,7 +477,6 @@ bool Expr::isTypeReference(
     // Anything else is not statically derived.
     return false;
   } while (true);
-
 }
 
 bool Expr::isStaticallyDerivedMetatype(

lib/Sema/CSApply.cpp

@@ -227,51 +227,25 @@ getImplicitMemberReferenceAccessSemantics(Expr *base, VarDecl *member,
   return member->getAccessSemanticsFromContext(DC, isAccessOnSelf);
 }
 
-/// This effectively duplicates logic of `Expr::isTypeReference` with
-/// one significant difference - support for `UnresolvedDotExpr` and
-/// `UnresolvedMemberExpr`. This method could be used on not yet
-/// fully type-checked AST.
+/// This extends functionality of `Expr::isTypeReference` with
+/// support for `UnresolvedDotExpr` and `UnresolvedMemberExpr`.
+/// This method could be used on not yet fully type-checked AST.
 bool ConstraintSystem::isTypeReference(const Expr *E) {
-  // If the result isn't a metatype, there's nothing else to do.
-  if (!getType(E)->is<AnyMetatypeType>())
-    return false;
-
-  Expr *expr = const_cast<Expr *>(E);
-  do {
-    // Skip syntax.
-    expr = expr->getSemanticsProvidingExpr();
-
-    // Direct reference to a type.
-    if (auto declRef = dyn_cast<DeclRefExpr>(expr))
-      if (isa<TypeDecl>(declRef->getDecl()))
-        return true;
-
-    if (isa<TypeExpr>(expr))
-      return true;
-
-    if (auto *UDE = dyn_cast<UnresolvedDotExpr>(expr)) {
-      return isa<TypeDecl>(findResolvedMemberRef(
-          getConstraintLocator(UDE, ConstraintLocator::Member)));
-    }
-
-    if (auto *UME = dyn_cast<UnresolvedMemberExpr>(expr)) {
-      return isa<TypeDecl>(findResolvedMemberRef(
-          getConstraintLocator(UME, ConstraintLocator::UnresolvedMember)));
-    }
-
-    // A "." expression that refers to a member.
-    if (auto memberRef = dyn_cast<MemberRefExpr>(expr))
-      return isa<TypeDecl>(memberRef->getMember().getDecl());
+  return E->isTypeReference(
+      [&](const Expr *E) -> Type { return getType(E); },
+      [&](const Expr *E) -> Decl * {
+        if (auto *UDE = dyn_cast<UnresolvedDotExpr>(E)) {
+          return findResolvedMemberRef(
+              getConstraintLocator(UDE, ConstraintLocator::Member));
+        }
 
-    // When the base of a "." expression is ignored, look at the member.
-    if (auto ignoredDot = dyn_cast<DotSyntaxBaseIgnoredExpr>(expr)) {
-      expr = ignoredDot->getRHS();
-      continue;
-    }
+        if (auto *UME = dyn_cast<UnresolvedMemberExpr>(E)) {
+          return findResolvedMemberRef(
+              getConstraintLocator(UME, ConstraintLocator::UnresolvedMember));
+        }
 
-    // Anything else is not statically derived.
-    return false;
-  } while (true);
+        return nullptr;
+      });
 }
 
 bool ConstraintSystem::isStaticallyDerivedMetatype(const Expr *E) {

lib/Sema/ConstraintSystem.h

@@ -1762,6 +1762,12 @@ class ConstraintSystem {
                                 pathElt.getNewSummaryFlags());
   }
 
+  ConstraintLocator *
+  getConstraintLocator(const Expr *anchor,
+                       ConstraintLocator::PathElement pathElt) {
+    return getConstraintLocator(const_cast<Expr *>(anchor), pathElt);
+  }
+
   /// Extend the given constraint locator with a path element.
   ConstraintLocator *
   getConstraintLocator(ConstraintLocator *locator,