Handle dynamically accessing the static member from type(of:)

Author: Azoy

include/swift/AST/Expr.h

@@ -1450,24 +1450,33 @@ 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(DeclNameLoc loc, GenericTypeParamDecl *paramDecl) :
+  TypeValueExpr(TypeRepr *repr, DeclNameLoc loc, GenericTypeParamDecl *paramDecl) :
       Expr(ExprKind::TypeValue, /*implicit*/ false), paramDecl(paramDecl),
-      loc(loc), paramType(nullptr) {}
+      repr(repr), loc(loc), paramType(nullptr) {}
 
 public:
   /// Create a \c TypeValueExpr for a given \c GenericTypeParamDecl.
   ///
   /// The given location must be valid.
   static TypeValueExpr *createForDecl(DeclNameLoc Loc, GenericTypeParamDecl *D);
 
+  /// 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;
   }
 
+  TypeRepr *getRepr() const {
+    return repr;
+  }
+
   /// Retrieves the corresponding parameter type of the value referenced by this
   /// expression.
   Type getParamType() const {
@@ -1483,7 +1492,7 @@ class TypeValueExpr : public Expr {
   /// Retrieves the underlying value type of the parameter type referenced by
   /// this expression.
   Type getValueType() const {
-    return valueType;
+    return paramDecl->getValueType();
   }
 
   SourceRange getSourceRange() const {

lib/AST/Expr.cpp

@@ -2445,7 +2445,15 @@ TypeValueExpr *TypeValueExpr::createForDecl(DeclNameLoc loc,
                                             GenericTypeParamDecl *paramDecl) {
   auto &ctx = paramDecl->getASTContext();
   ASSERT(loc.isValid());
-  return new (ctx) TypeValueExpr(loc, paramDecl);
+  return new (ctx) TypeValueExpr(/*repr*/ nullptr, loc, paramDecl);
+}
+
+TypeValueExpr *TypeValueExpr::createForMemberDecl(TypeRepr *repr,
+                                                  DeclNameLoc loc,
+                                                  GenericTypeParamDecl *paramDecl) {
+  auto &ctx = paramDecl->getASTContext();
+  ASSERT(loc.isValid());
+  return new (ctx) TypeValueExpr(repr, loc, paramDecl);
 }
 
 ExistentialArchetypeType *OpenExistentialExpr::getOpenedArchetype() const {

lib/Sema/CSApply.cpp

@@ -1631,6 +1631,29 @@ namespace {
       // Build a member reference.
       auto memberRef = resolveConcreteDeclRef(member, memberLocator);
 
+      // If our member reference is a value generic, then the resulting
+      // expression is the type value one to access the underlying parameter's
+      // value.
+      //
+      // 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()) {
+          auto refType = adjustedOpenedType;
+          auto ref = TypeValueExpr::createForDecl(memberLoc, gp);
+          cs.setType(ref, refType);
+
+          auto gpTy = gp->getDeclaredInterfaceType();
+          auto subs = baseTy->getContextSubstitutionMap();
+          ref->setParamType(gpTy.subst(subs));
+
+          auto result = new (ctx) DotSyntaxBaseIgnoredExpr(base, dotLoc, ref,
+                                                           refType);
+          cs.setType(result, refType);
+          return result;
+        }
+      }
+
       // If we're referring to a member type, it's just a type
       // reference.
       if (auto *TD = dyn_cast<TypeDecl>(member)) {

lib/Sema/CSGen.cpp

@@ -1724,6 +1724,22 @@ namespace {
 
     Type visitTypeValueExpr(TypeValueExpr *E) {
       auto ty = E->getParamDecl()->getDeclaredInterfaceType();
+
+      // 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();
+      }
+
       auto paramType = CS.DC->mapTypeIntoContext(ty);
       E->setParamType(paramType);
       return E->getParamDecl()->getValueType();

lib/Sema/PreCheckTarget.cpp

@@ -1843,12 +1843,12 @@ Expr *PreCheckTarget::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
     if (Result.size() == 1) {
       auto resultDecl = Result.front().Member;
 
-      if (isa<GenericTypeParamDecl>(resultDecl) &&
+      if (resultDecl &&
+          isa<GenericTypeParamDecl>(resultDecl) &&
           cast<GenericTypeParamDecl>(resultDecl)->isValue()) {
         auto gtpd = cast<GenericTypeParamDecl>(resultDecl);
         return TypeValueExpr::createForMemberDecl(InnerTypeRepr,
-                                                  UDE->getNameLoc(),
-                                                  gtpd);
+                                                  UDE->getNameLoc(), gtpd);
 
       } else {
         return TypeExpr::createForMemberDecl(InnerTypeRepr, UDE->getNameLoc(),
@@ -1864,7 +1864,7 @@ TypeExpr *PreCheckTarget::simplifyUnresolvedSpecializeExpr(
     UnresolvedSpecializeExpr *us) {
   // If this is a reference type a specialized type, form a TypeExpr.
   // The base should be a TypeExpr that we already resolved.
-  if (auto *te = dyn_cast<TypeExpr>(us->getSubExpr())) {
+  if (auto *te = dyn_cast_or_null<TypeExpr>(us->getSubExpr())) {
     if (auto *declRefTR =
             dyn_cast_or_null<DeclRefTypeRepr>(te->getTypeRepr())) {
       return TypeExpr::createForSpecializedDecl(
@@ -2331,7 +2331,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<TypeExpr>(simplifyTypeExpr(E))) {
+      if (auto ArgsTypeExpr = dyn_cast_or_null<TypeExpr>(simplifyTypeExpr(E))) {
         auto ArgRepr = ArgsTypeExpr->getTypeRepr();
         if (auto *TTyRepr = dyn_cast<TupleTypeRepr>(ArgRepr))
           return TTyRepr;
@@ -2352,7 +2352,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<TypeExpr>(simplifyTypeExpr(E)))
+      if (auto ArgsTypeExpr = dyn_cast_or_null<TypeExpr>(simplifyTypeExpr(E)))
         return ArgsTypeExpr->getTypeRepr();
       return nullptr;
     };
@@ -2391,7 +2391,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<TypeExpr>(
+      if (auto operand = dyn_cast_or_null<TypeExpr>(
             simplifyTypeExpr(unaryExpr->getOperand()))) {
         auto inverseTypeRepr = new (Ctx) InverseTypeRepr(
             unaryExpr->getLoc(), operand->getTypeRepr());
@@ -2412,7 +2412,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<TypeExpr>(simplifyTypeExpr(lhsExpr)))
+      if (auto expr = dyn_cast_or_null<TypeExpr>(simplifyTypeExpr(lhsExpr)))
         if (auto *repr = dyn_cast<CompositionTypeRepr>(expr->getTypeRepr()))
           // add the protocols to our list
           for (auto proto : repr->getTypes())

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -727,6 +727,20 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
       auto found = nominal->lookupDirect(current->getBaseName(), SourceLoc(),
                                          flags);
       otherDefinitions.append(found.begin(), found.end());
+
+      // Look into the generics of the type. Value generic parameters can appear
+      // as static members of the type.
+      if (auto genericDC = static_cast<Decl *>(nominal)->getAsGenericContext()) {
+        auto gpList = genericDC->getGenericParams();
+
+        if (gpList && !current->getBaseName().isSpecial()) {
+          auto gp = gpList->lookUpGenericParam(current->getBaseIdentifier());
+
+          if (gp && gp->isValue()) {
+            otherDefinitions.push_back(gp);
+          }
+        }
+      }
     }
   } else if (currentDC->isLocalContext()) {
     if (!current->isImplicit()) {
@@ -1135,25 +1149,6 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
     }
   }
 
-  // Look to see if this type has a value generic with the same name and that
-  // the current value is a property.
-  if (currentDC->isTypeContext() && currentDC->isGenericContext() &&
-      isa<VarDecl>(current)) {
-    auto gpList = currentDC->getAsDecl()->getAsGenericContext()->getGenericParams();
-
-    if (gpList && !current->getBaseName().isSpecial()) {
-      auto gp = gpList->lookUpGenericParam(current->getBaseIdentifier());
-
-      if (gp && gp->isValue()) {
-        ctx.Diags.diagnoseWithNotes(
-          current->diagnose(diag::invalid_redecl, current), [&]() {
-          gp->diagnose(diag::invalid_redecl_prev, gp);
-        });
-        current->setInvalid();
-      }
-    }
-  }
-
   return std::make_tuple<>();
 }
 

lib/Sema/TypeOfReference.cpp

@@ -1557,6 +1557,18 @@ 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();
+      }
+    }
+
     auto openedType = FunctionType::get({baseObjParam}, memberTy);
     return { openedType, openedType, memberTy, memberTy, Type() };
   }

stdlib/public/core/InlineArray.swift

@@ -272,14 +272,6 @@ extension InlineArray where Element: ~Copyable {
   @available(SwiftStdlib 6.2, *)
   public typealias Index = Int
 
-  // FIXME: Remove when SE-0452 "Integer Generic Parameters" is implemented.
-  @available(SwiftStdlib 6.2, *)
-  @_alwaysEmitIntoClient
-  @_transparent
-  public static var count: Int {
-    count
-  }
-
   /// The number of elements in the array.
   ///
   /// - Complexity: O(1)

test/Sema/value_generics.swift

@@ -121,16 +121,16 @@ func testC4<let T: Int>(with c: C<T, T>) {
 struct D<let N: Int & P> {} // expected-error {{non-protocol, non-class type 'Int' cannot be used within a protocol-constrained type}}
 
 struct E<A, let b: Int> { // expected-note {{'b' previously declared here}}
-                          // expected-note@-1 {{'b' previously declared here}}
   static var b: Int { // expected-error {{invalid redeclaration of 'b'}}
                       // expected-note@-1 {{'b' declared here}}
     123
   }
 
-  let b: String // expected-error {{invalid redeclaration of 'b'}}
+  let b: String // expected-note {{'b' previously declared here}}
                 // expected-note@-1 {{'b' declared here}}
 
-  func b() {} // expected-note {{'b' declared here}}
+  func b() {} // expected-error {{invalid redeclaration of 'b()'}}
+              // expected-note@-1 {{'b' declared here}}
 }
 
 func testE1() -> Int {
@@ -141,15 +141,35 @@ func testE2() -> Int {
   E<Int, 123>.A // expected-error {{type 'E<Int, 123>' has no member 'A'}}
 }
 
-func testE3<let c: Int>(_: E<Int, c>.Type = E<Int, c>.self) -> Int {
+func testE3<let c: Int>(_: E<Int, c>.Type) -> Int {
   E<Int, c>.b // OK
 }
 
 func testShadowing<let a: Int>(_: A<a>) {
-  var a: Int {
-    123
+  var a: String {
+    "123"
   }
 
+  let x: String = a // OK
+  let y: Int = a // expected-error {{cannot convert value of type 'String' to specified type 'Int'}}
+
   print(a) // OK
   print(a.self) // OK
 }
+
+class F<let n: Int> {}
+class G: F<3> {}
+
+func hello() -> Int {
+  G.n // OK
+}
+
+func testTypeOf() -> Int {
+  let x = E<Int, 123>(b: "")
+  return type(of: x).b // OK
+}
+
+func testTypeOf2<let c: Int>(_: E<Int, c>.Type) -> Int {
+  let x = E<Int, c>(b: "")
+  return type(of: x).b // OK
+}