Allow value generics to show up as static members

Author: Azoy

include/swift/AST/Expr.h

@@ -1480,6 +1480,12 @@ class TypeValueExpr : public Expr {
     this->paramType = paramType;
   }
 
+  /// Retrieves the underlying value type of the parameter type referenced by
+  /// this expression.
+  Type getValueType() const {
+    return valueType;
+  }
+
   SourceRange getSourceRange() const {
     return loc.getSourceRange();
   }

lib/AST/NameLookup.cpp

@@ -2739,6 +2739,17 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
       }
     }
 
+    // Qualified name lookup can find generic value parameters.
+    auto gpList = current->getGenericParams();
+
+    if (gpList && !member.isSpecial()) {
+      if (auto gp = gpList->lookUpGenericParam(member.getBaseIdentifier())) {
+        if (gp->isValue()) {
+          decls.push_back(gp);
+        }
+      }
+    }
+
     // If we're not looking at a protocol and we're not supposed to
     // visit the protocols that this type conforms to, skip the next
     // step.

lib/Sema/CSApply.cpp

@@ -3222,7 +3222,7 @@ namespace {
 
     Expr *visitTypeValueExpr(TypeValueExpr *expr) {
       auto toType = simplifyType(cs.getType(expr));
-      assert(toType->isEqual(expr->getParamDecl()->getValueType()));
+      ASSERT(toType->isEqual(expr->getParamDecl()->getValueType()));
       cs.setType(expr, toType);
       return expr;
     }

lib/Sema/PreCheckTarget.cpp

@@ -1096,10 +1096,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.
-  TypeExpr *simplifyTypeExpr(Expr *E);
+  Expr *simplifyTypeExpr(Expr *E);
 
   /// Simplify unresolved dot expressions which are nested type productions.
-  TypeExpr *simplifyNestedTypeExpr(UnresolvedDotExpr *UDE);
+  Expr *simplifyNestedTypeExpr(UnresolvedDotExpr *UDE);
 
   TypeExpr *simplifyUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *USE);
 
@@ -1726,7 +1726,7 @@ void PreCheckTarget::diagnoseOutOfPlaceSingleValueStmtExprs(
   }
 }
 
-TypeExpr *PreCheckTarget::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
+Expr *PreCheckTarget::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
   if (!UDE->getName().isSimpleName() ||
       UDE->getName().isSpecial())
     return nullptr;
@@ -1841,8 +1841,19 @@ TypeExpr *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) {
-      return TypeExpr::createForMemberDecl(InnerTypeRepr, UDE->getNameLoc(),
-                                           Result.front().Member);
+      auto resultDecl = Result.front().Member;
+
+      if (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);
+      }
     }
   }
 
@@ -2121,7 +2132,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.
-TypeExpr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
+Expr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
   // If it's already a type expression, return it.
   if (auto typeExpr = dyn_cast<TypeExpr>(E))
     return typeExpr;
@@ -2320,7 +2331,7 @@ TypeExpr *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 = simplifyTypeExpr(E)) {
+      if (auto ArgsTypeExpr = dyn_cast<TypeExpr>(simplifyTypeExpr(E))) {
         auto ArgRepr = ArgsTypeExpr->getTypeRepr();
         if (auto *TTyRepr = dyn_cast<TupleTypeRepr>(ArgRepr))
           return TTyRepr;
@@ -2341,7 +2352,7 @@ TypeExpr *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 = simplifyTypeExpr(E))
+      if (auto ArgsTypeExpr = dyn_cast<TypeExpr>(simplifyTypeExpr(E)))
         return ArgsTypeExpr->getTypeRepr();
       return nullptr;
     };
@@ -2380,7 +2391,8 @@ TypeExpr *PreCheckTarget::simplifyTypeExpr(Expr *E) {
   // Fold '~P' into a composition type.
   if (auto *unaryExpr = dyn_cast<PrefixUnaryExpr>(E)) {
     if (isTildeOperator(unaryExpr->getFn())) {
-      if (auto operand = simplifyTypeExpr(unaryExpr->getOperand())) {
+      if (auto operand = dyn_cast<TypeExpr>(
+            simplifyTypeExpr(unaryExpr->getOperand()))) {
         auto inverseTypeRepr = new (Ctx) InverseTypeRepr(
             unaryExpr->getLoc(), operand->getTypeRepr());
         return new (Ctx) TypeExpr(inverseTypeRepr);
@@ -2400,7 +2412,7 @@ TypeExpr *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 = simplifyTypeExpr(lhsExpr))
+      if (auto expr = dyn_cast<TypeExpr>(simplifyTypeExpr(lhsExpr)))
         if (auto *repr = dyn_cast<CompositionTypeRepr>(expr->getTypeRepr()))
           // add the protocols to our list
           for (auto proto : repr->getTypes())

test/Sema/value_generics.swift

@@ -119,3 +119,17 @@ 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> {}
+
+func testE1() -> Int {
+  E<Int, 123>.b // OK
+}
+
+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 {
+  E<Int, c>.b // OK
+}