Store TypeRepr in TypeValueExpr

Azoy · Azoy · commit ae355007fc7e · 2025-04-14T15:33:08.000-07:00
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -1449,29 +1449,22 @@ class TypeExpr : public Expr {
 };
 
 class TypeValueExpr : public Expr {
-  GenericTypeParamDecl *paramDecl;
   TypeRepr *repr;
-  DeclNameLoc loc;
   Type paramType;
 
-  /// Create a \c TypeValueExpr from a given generic value param decl.
-  TypeValueExpr(TypeRepr *repr, DeclNameLoc loc, GenericTypeParamDecl *paramDecl) :
-      Expr(ExprKind::TypeValue, /*implicit*/ false), paramDecl(paramDecl),
-      repr(repr), loc(loc), paramType(nullptr) {}
+  /// Create a \c TypeValueExpr from a given type representation.
+  TypeValueExpr(TypeRepr *repr) :
+      Expr(ExprKind::TypeValue, /*implicit*/ false), repr(repr),
+      paramType(nullptr) {}
 
 public:
-  /// Create a \c TypeValueExpr for a given \c GenericTypeParamDecl.
+  /// Create a \c TypeValueExpr for a given \c TypeDecl.
   ///
   /// The given location must be valid.
-  static TypeValueExpr *createForDecl(DeclNameLoc Loc, GenericTypeParamDecl *D);
+  static TypeValueExpr *createForDecl(DeclNameLoc loc, TypeDecl *d,
+                                      DeclContext *dc);
 
-  /// Create a \c TypeValueExpr for a member of the given parent \c TypeRepr.
-  static TypeValueExpr *createForMemberDecl(TypeRepr *repr, DeclNameLoc loc,
-                                            GenericTypeParamDecl *d);
-
-  GenericTypeParamDecl *getParamDecl() const {
-    return paramDecl;
-  }
+  GenericTypeParamDecl *getParamDecl() const;
 
   TypeRepr *getRepr() const {
     return repr;
@@ -1489,15 +1482,7 @@ class TypeValueExpr : public Expr {
     this->paramType = paramType;
   }
 
-  /// Retrieves the underlying value type of the parameter type referenced by
-  /// this expression.
-  Type getValueType() const {
-    return paramDecl->getValueType();
-  }
-
-  SourceRange getSourceRange() const {
-    return loc.getSourceRange();
-  }
+  SourceRange getSourceRange() const;
 
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::TypeValue;
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -2441,19 +2441,22 @@ bool Expr::isSelfExprOf(const AbstractFunctionDecl *AFD, bool sameBase) const {
   return false;
 }
 
-TypeValueExpr *TypeValueExpr::createForDecl(DeclNameLoc loc, 
-                                            GenericTypeParamDecl *paramDecl) {
-  auto &ctx = paramDecl->getASTContext();
+TypeValueExpr *TypeValueExpr::createForDecl(DeclNameLoc loc, TypeDecl *decl,
+                                            DeclContext *dc) {
+  auto &ctx = decl->getASTContext();
   ASSERT(loc.isValid());
-  return new (ctx) TypeValueExpr(/*repr*/ nullptr, loc, paramDecl);
+  auto repr = UnqualifiedIdentTypeRepr::create(ctx, loc, decl->createNameRef());
+  repr->setValue(decl, dc);
+  return new (ctx) TypeValueExpr(repr);
 }
 
-TypeValueExpr *TypeValueExpr::createForMemberDecl(TypeRepr *repr,
-                                                  DeclNameLoc loc,
-                                                  GenericTypeParamDecl *paramDecl) {
-  auto &ctx = paramDecl->getASTContext();
-  ASSERT(loc.isValid());
-  return new (ctx) TypeValueExpr(repr, loc, paramDecl);
+GenericTypeParamDecl *TypeValueExpr::getParamDecl() const {
+  auto declRefRepr = cast<DeclRefTypeRepr>(getRepr());
+  return cast<GenericTypeParamDecl>(declRefRepr->getBoundDecl());
+}
+
+SourceRange TypeValueExpr::getSourceRange() const {
+  return getRepr()->getSourceRange();
 }
 
 ExistentialArchetypeType *OpenExistentialExpr::getOpenedArchetype() const {
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -2742,7 +2742,8 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
     // Qualified name lookup can find generic value parameters.
     auto gpList = current->getGenericParams();
 
-    if (gpList && !member.isSpecial()) {
+    // .. But not in type contexts (yet)
+    if (!(options & NL_OnlyTypes) && gpList && !member.isSpecial()) {
       auto gp = gpList->lookUpGenericParam(member.getBaseIdentifier());
 
       if (gp && gp->isValue()) {
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -1640,7 +1640,7 @@ namespace {
       if (auto gp = dyn_cast<GenericTypeParamDecl>(member)) {
         if (gp->isValue()) {
           auto refType = adjustedOpenedType;
-          auto ref = TypeValueExpr::createForDecl(memberLoc, gp);
+          auto ref = TypeValueExpr::createForDecl(memberLoc, gp, dc);
           cs.setType(ref, refType);
 
           auto gpTy = gp->getDeclaredInterfaceType();
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -1723,25 +1723,15 @@ namespace {
     }
 
     Type visitTypeValueExpr(TypeValueExpr *E) {
-      auto ty = E->getParamDecl()->getDeclaredInterfaceType();
+      auto declRefRepr = cast<DeclRefTypeRepr>(E->getRepr());
+      auto resolvedTy = resolveTypeReferenceInExpression(declRefRepr,
+                                                         TypeResolverContext::InExpression,
+                                                         CS.getConstraintLocator(E));
 
-      // If we have a type representation for this type value, then we're in a
-      // context where we're statically accessing the generic parameter by name
-      // from a qualified name. E.g. 'A<123>.b'. This context may or may not
-      // have a generic environment from which we can map our parameter to.
-      if (auto repr = E->getRepr()) {
-        auto resolvedTy =
-            resolveTypeReferenceInExpression(repr,
-                                             TypeResolverContext::InExpression,
-                                             CS.getConstraintLocator(E));
-
-        auto paramType = ty.subst(resolvedTy->getContextSubstitutionMap());
-        E->setParamType(paramType);
-        return E->getParamDecl()->getValueType();
-      }
+      if (!resolvedTy || resolvedTy->hasError())
+        return Type();
 
-      auto paramType = CS.DC->mapTypeIntoContext(ty);
-      E->setParamType(paramType);
+      E->setParamType(resolvedTy);
       return E->getParamDecl()->getValueType();
     }
 
diff --git a/lib/Sema/PreCheckTarget.cpp b/lib/Sema/PreCheckTarget.cpp
@@ -817,8 +817,7 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
                    : D->getInterfaceType());
     } else {
       if (makeTypeValue) {
-        return TypeValueExpr::createForDecl(UDRE->getNameLoc(),
-                                            cast<GenericTypeParamDecl>(D));
+        return TypeValueExpr::createForDecl(UDRE->getNameLoc(), D, LookupDC);
       } else {
         return TypeExpr::createForDecl(UDRE->getNameLoc(), D, LookupDC);
       }
@@ -1096,10 +1095,10 @@ class PreCheckTarget final : public ASTWalker {
   /// Simplify expressions which are type sugar productions that got parsed
   /// as expressions due to the parser not knowing which identifiers are
   /// type names.
-  Expr *simplifyTypeExpr(Expr *E);
+  TypeExpr *simplifyTypeExpr(Expr *E);
 
   /// Simplify unresolved dot expressions which are nested type productions.
-  Expr *simplifyNestedTypeExpr(UnresolvedDotExpr *UDE);
+  TypeExpr *simplifyNestedTypeExpr(UnresolvedDotExpr *UDE);
 
   TypeExpr *simplifyUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *USE);
 
@@ -1726,7 +1725,7 @@ void PreCheckTarget::diagnoseOutOfPlaceSingleValueStmtExprs(
   }
 }
 
-Expr *PreCheckTarget::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
+TypeExpr *PreCheckTarget::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
   if (!UDE->getName().isSimpleName() ||
       UDE->getName().isSpecial())
     return nullptr;
@@ -1841,19 +1840,8 @@ Expr *PreCheckTarget::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
     // If there is no nested type with this name, we have a lookup of
     // a non-type member, so leave the expression as-is.
     if (Result.size() == 1) {
-      auto resultDecl = Result.front().Member;
-
-      if (resultDecl &&
-          isa<GenericTypeParamDecl>(resultDecl) &&
-          cast<GenericTypeParamDecl>(resultDecl)->isValue()) {
-        auto gtpd = cast<GenericTypeParamDecl>(resultDecl);
-        return TypeValueExpr::createForMemberDecl(InnerTypeRepr,
-                                                  UDE->getNameLoc(), gtpd);
-
-      } else {
-        return TypeExpr::createForMemberDecl(InnerTypeRepr, UDE->getNameLoc(),
-                                             resultDecl);
-      }
+      return TypeExpr::createForMemberDecl(InnerTypeRepr, UDE->getNameLoc(),
+                                           Result.front().Member);
     }
   }
 
@@ -2132,7 +2120,7 @@ static bool isTildeOperator(Expr *expr) {
 /// Simplify expressions which are type sugar productions that got parsed
 /// as expressions due to the parser not knowing which identifiers are
 /// type names.
-Expr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
+TypeExpr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
   // If it's already a type expression, return it.
   if (auto typeExpr = dyn_cast<TypeExpr>(E))
     return typeExpr;
@@ -2331,7 +2319,7 @@ Expr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
 
       // When simplifying a type expr like "(P1 & P2) -> (P3 & P4) -> Int",
       // it may have been folded at the same time; recursively simplify it.
-      if (auto ArgsTypeExpr = dyn_cast_or_null<TypeExpr>(simplifyTypeExpr(E))) {
+      if (auto ArgsTypeExpr = simplifyTypeExpr(E)) {
         auto ArgRepr = ArgsTypeExpr->getTypeRepr();
         if (auto *TTyRepr = dyn_cast<TupleTypeRepr>(ArgRepr))
           return TTyRepr;
@@ -2352,7 +2340,7 @@ Expr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
 
       // When simplifying a type expr like "P1 & P2 -> P3 & P4 -> Int",
       // it may have been folded at the same time; recursively simplify it.
-      if (auto ArgsTypeExpr = dyn_cast_or_null<TypeExpr>(simplifyTypeExpr(E)))
+      if (auto ArgsTypeExpr =  simplifyTypeExpr(E))
         return ArgsTypeExpr->getTypeRepr();
       return nullptr;
     };
@@ -2391,8 +2379,7 @@ Expr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
   // Fold '~P' into a composition type.
   if (auto *unaryExpr = dyn_cast<PrefixUnaryExpr>(E)) {
     if (isTildeOperator(unaryExpr->getFn())) {
-      if (auto operand = dyn_cast_or_null<TypeExpr>(
-            simplifyTypeExpr(unaryExpr->getOperand()))) {
+      if (auto operand = simplifyTypeExpr(unaryExpr->getOperand())) {
         auto inverseTypeRepr = new (Ctx) InverseTypeRepr(
             unaryExpr->getLoc(), operand->getTypeRepr());
         return new (Ctx) TypeExpr(inverseTypeRepr);
@@ -2412,7 +2399,7 @@ Expr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
       // If the lhs is another binary expression, we have a multi element
       // composition: 'A & B & C' is parsed as ((A & B) & C); we get
       // the protocols from the lhs here
-      if (auto expr = dyn_cast_or_null<TypeExpr>(simplifyTypeExpr(lhsExpr)))
+      if (auto expr = simplifyTypeExpr(lhsExpr))
         if (auto *repr = dyn_cast<CompositionTypeRepr>(expr->getTypeRepr()))
           // add the protocols to our list
           for (auto proto : repr->getTypes())
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -6335,6 +6335,18 @@ Type TypeChecker::substMemberTypeWithBase(TypeDecl *member,
     resultType = TypeAliasType::get(aliasDecl, sugaredBaseTy, {}, resultType);
   }
 
+  // However, if overload resolution finds a value generic decl from name
+  // lookup, replace the returned member type to be the underlying value type
+  // of the generic.
+  //
+  // This can occur in code that does something like: 'type(of: x).a' where
+  // 'a' is the static value generic member.
+  if (auto gp = dyn_cast<GenericTypeParamDecl>(member)) {
+    if (gp->isValue()) {
+      resultType = gp->getValueType();
+    }
+  }
+
   return resultType;
 }
 
diff --git a/lib/Sema/TypeOfReference.cpp b/lib/Sema/TypeOfReference.cpp
@@ -1557,16 +1557,11 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     // Wrap it in a metatype.
     memberTy = MetatypeType::get(memberTy);
 
-    // However, if overload resolution finds a value generic decl from name
-    // lookup, replace the returned member type to be the underlying value type
-    // of the generic.
-    //
-    // This can occur in code that does something like: 'type(of: x).a' where
-    // 'a' is the static value generic member.
-    if (auto gp = dyn_cast<GenericTypeParamDecl>(typeDecl)) {
-      if (gp->isValue()) {
-        memberTy = gp->getValueType();
-      }
+    // If this is a value generic, undo the wrapping. 'substMemberTypeWithBase'
+    // returns the underlying value type of the value generic (e.g. 'Int').
+    if (isa<GenericTypeParamDecl>(value) &&
+        cast<GenericTypeParamDecl>(value)->isValue()) {
+      memberTy = memberTy->castTo<MetatypeType>()->getInstanceType();
     }
 
     auto openedType = FunctionType::get({baseObjParam}, memberTy);
diff --git a/test/Sema/value_generics.swift b/test/Sema/value_generics.swift
@@ -181,3 +181,9 @@ func testTypeOf2<let c: Int>(_: E<Int, c>.Type) -> Int {
   let x = E<Int, c>(b: "")
   return type(of: x).b // OK
 }
+
+struct H<let I: Int> { // expected-note {{'I' previously declared here}}
+  struct I {} // expected-error {{invalid redeclaration of 'I'}}
+}
+
+typealias J = E<Int, 123>.b // expected-error {{static property 'b' is not a member type of 'E<Int, 123>'}}
