Make it an error to redeclare properties with the same name as a value generic

Update value_generics.swift

Author: Azoy

include/swift/AST/TypeCheckRequests.h

@@ -3548,7 +3548,7 @@ class LookupAllConformancesInContextRequest
 class CheckRedeclarationRequest
     : public SimpleRequest<
           CheckRedeclarationRequest,
-          evaluator::SideEffect(ValueDecl *, NominalTypeDecl *),
+          evaluator::SideEffect(ValueDecl *),
           RequestFlags::SeparatelyCached | RequestFlags::DependencySource |
               RequestFlags::DependencySink> {
 public:
@@ -3561,8 +3561,7 @@ class CheckRedeclarationRequest
   /// \p SelfNominalType is \c VD->getDeclContext()->getSelfNominalType().
   /// Passed as a parameter in here so this request doesn't tigger self nominal
   /// type computation.
-  evaluator::SideEffect evaluate(Evaluator &evaluator, ValueDecl *VD,
-                                 NominalTypeDecl *SelfNominalType) const;
+  evaluator::SideEffect evaluate(Evaluator &evaluator, ValueDecl *VD) const;
 
 public:
   // Separate caching.

lib/AST/NameLookup.cpp

@@ -2652,10 +2652,10 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
     auto gpList = current->getGenericParams();
 
     if (gpList && !member.isSpecial()) {
-      if (auto gp = gpList->lookUpGenericParam(member.getBaseIdentifier())) {
-        if (gp->isValue()) {
-          decls.push_back(gp);
-        }
+      auto gp = gpList->lookUpGenericParam(member.getBaseIdentifier());
+
+      if (gp && gp->isValue()) {
+        decls.push_back(gp);
       }
     }
 

lib/AST/TypeCheckRequests.cpp

@@ -1547,7 +1547,7 @@ void CheckRedeclarationRequest::writeDependencySink(
     return;
 
   if (currentDC->isTypeContext()) {
-    if (auto nominal = std::get<1>(getStorage())) {
+    if (auto nominal = currentDC->getSelfNominalTypeDecl()) {
       tracker.addUsedMember(nominal, current->getBaseName());
     }
   } else {

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -669,8 +669,7 @@ static void checkRedeclaration(PrecedenceGroupDecl *group) {
 
 /// Check whether \c current is a redeclaration.
 evaluator::SideEffect
-CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current,
-                                    NominalTypeDecl *SelfNominalType) const {
+CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
   // Ignore invalid and anonymous declarations.
   if (current->isInvalid() || !current->hasName())
     return std::make_tuple<>();
@@ -1088,6 +1087,26 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current,
       break;
     }
   }
+
+  // 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<>();
 }
 
@@ -2301,11 +2320,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       // Force some requests, which can produce diagnostics.
 
       // Check redeclaration.
-      (void)evaluateOrDefault(
-          Ctx.evaluator,
-          CheckRedeclarationRequest{
-              VD, VD->getDeclContext()->getSelfNominalTypeDecl()},
-          {});
+      (void)evaluateOrDefault(Ctx.evaluator, CheckRedeclarationRequest{VD}, {});
 
       // Compute access level.
       (void) VD->getFormalAccess();

test/Sema/value_generics.swift

@@ -114,7 +114,18 @@ 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> {}
+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'}}
+                // expected-note@-1 {{'b' declared here}}
+
+  func b() {} // expected-note {{'b' declared here}}
+}
 
 func testE1() -> Int {
   E<Int, 123>.b // OK
@@ -127,3 +138,12 @@ func testE2() -> Int {
 func testE3<let c: Int>(_: E<Int, c>.Type = E<Int, c>.self) -> Int {
   E<Int, c>.b // OK
 }
+
+func testShadowing<let a: Int>(_: A<a>) {
+  var a: Int {
+    123
+  }
+
+  print(a) // OK
+  print(a.self) // OK
+}