Add some new diagnostics and tests

Author: Azoy

include/swift/AST/DiagnosticsSema.def

@@ -3002,16 +3002,6 @@ WARNING(associated_type_not_usable_from_inline_warn,none,
         "'@usableFromInline' protocol should be '@usableFromInline' or public",
         (unsigned))
 
-ERROR(invalid_value_variable_generic,none,
-      "%0 requires that %1 must be a valid value for %2",
-      (Type, Type, Type))
-NOTE(invalid_value_variable_generic_requirement,none,
-     "requirement specified as %0 == %1%2",
-     (Type, Type, StringRef))
-ERROR(cannot_pass_type_for_value_generic,none,
-      "cannot pass type %1 as a value for generic value of %2",
-      (Type, Type, Type))
-
 NOTE(bad_associated_type_deduction,none,
      "unable to infer associated type %0 for protocol %1",
      (const AssociatedTypeDecl *, const ProtocolDecl *))
@@ -4751,9 +4741,6 @@ NOTE(add_parens_to_type,none,
 NOTE(add_self_to_type,none,
      "use '.self' to reference the type object", ())
 
-ERROR(cannot_self_value_generic,none,
-      "cannot reference '.self' on value generic parameter %0", (Type))
-
 WARNING(warn_unqualified_access,none,
         "use of %0 treated as a reference to %1 in %kind2",
         (Identifier, DescriptiveDeclKind, const ValueDecl *))
@@ -8011,5 +7998,27 @@ WARNING(reference_to_unsafe_typed_decl,none,
 NOTE(unsafe_decl_here,none,
      "unsafe %kindbase0 declared here", (const ValueDecl *))
 
+//===----------------------------------------------------------------------===//
+// MARK: Value Generics
+//===----------------------------------------------------------------------===//
+
+ERROR(invalid_value_value_generic,none,
+      "%0 requires that %1 must be a valid value for %2",
+      (Type, Type, Type))
+NOTE(invalid_value_value_generic_requirement,none,
+     "requirement specified as %0 == %1%2",
+     (Type, Type, StringRef))
+ERROR(cannot_pass_type_for_value_generic,none,
+      "cannot pass type %1 as a value for generic value of %2",
+      (Type, Type, Type))
+ERROR(value_type_used_in_type_parameter,none,
+      "cannot use value type %0 for generic argument %1", (Type, Type))
+ERROR(cannot_self_value_generic,none,
+      "cannot reference '.self' on value generic parameter %0", (Type))
+ERROR(invalid_value_type_value_generic,none,
+      "%0 is not a supported value type for %1", (Type, Type))
+ERROR(invalid_value_generic_conformance,none,
+      "value generic type %0 cannot conform to protocol %1", (Type, Type))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/AST/ASTPrinter.cpp

@@ -5693,11 +5693,15 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     } else if (auto param = dyn_cast<GenericTypeParamType>(T.getPointer())) {
       if (param->isParameterPack())
         return false;
+      if (param->isValue())
+        return false;
     } else if (auto archetype = dyn_cast<ArchetypeType>(T.getPointer())) {
       if (isa<PackArchetypeType>(archetype))
         return false;
       if (Options.PrintForSIL && isa<LocalArchetypeType>(archetype))
         return false;
+      if (archetype->getValueType())
+        return false;
     }
     return T->hasSimpleTypeRepr();
   }

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -225,6 +225,30 @@ bool swift::rewriting::diagnoseRequirementErrors(
       diagnosedError = true;
       break;
     }
+
+    case RequirementError::Kind::InvalidValueGenericType: {
+      auto req = error.getRequirement();
+
+      if (req.hasError())
+        break;
+
+      ctx.Diags.diagnose(loc, diag::invalid_value_type_value_generic,
+                         req.getSecondType(), req.getFirstType());
+      diagnosedError = true;
+      break;
+    }
+
+    case RequirementError::Kind::InvalidValueGenericConformance: {
+      auto req = error.getRequirement();
+
+      if (req.hasError())
+        break;
+
+      ctx.Diags.diagnose(loc, diag::invalid_value_generic_conformance,
+                         req.getFirstType(), req.getSecondType());
+      diagnosedError = true;
+      break;
+    }
     }
   }
 

lib/AST/RequirementMachine/Diagnostics.h

@@ -53,6 +53,12 @@ struct RequirementError {
     RecursiveRequirement,
     /// A not-yet-supported same-element requirement, e.g. each T == Int.
     UnsupportedSameElement,
+    /// An unexpected value type used in a value generic,
+    /// e.g. 'let N: String'.
+    InvalidValueGenericType,
+    /// A value generic type was used to conform to a protocol,
+    /// e.g. 'where N: P' where N == 'let N: Int' and P is some protocol.
+    InvalidValueGenericConformance,
   } kind;
 
 private:
@@ -149,6 +155,16 @@ struct RequirementError {
   static RequirementError forSameElement(Requirement req, SourceLoc loc) {
     return {Kind::UnsupportedSameElement, req, loc};
   }
+
+  static RequirementError forInvalidValueGenericType(Requirement req,
+                                                     SourceLoc loc) {
+    return {Kind::InvalidValueGenericType, req, loc};
+  }
+
+  static RequirementError forInvalidValueGenericConformance(Requirement req,
+                                                            SourceLoc loc) {
+    return {Kind::InvalidValueGenericConformance, req, loc};
+  }
 };
 
 /// Policy for the fixit that transforms 'T : S' where 'S' is not a protocol

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -337,6 +337,12 @@ static void desugarConformanceRequirement(
   // Fast path.
   if (constraintType->is<ProtocolType>()) {
     if (req.getFirstType()->isTypeParameter()) {
+      // Value generic types cannot conform to protocols.
+      if (req.getFirstType()->getAs<GenericTypeParamType>()->isValue()) {
+        errors.push_back(RequirementError::forInvalidValueGenericConformance(req, loc));
+        return;
+      }
+
       result.push_back(req);
       return;
     }
@@ -419,6 +425,12 @@ static void desugarValueRequirement(Requirement req, SourceLoc loc,
                                     SmallVectorImpl<Requirement> &result,
                                     SmallVectorImpl<InverseRequirement> &inverses,
                                     SmallVectorImpl<RequirementError> &errors) {
+
+  if (!req.getSecondType()->isLegalValueGenericType()) {
+    errors.push_back(RequirementError::forInvalidValueGenericType(req, loc));
+    return;
+  }
+
   if (req.getFirstType()->isTypeParameter()) {
     result.push_back(req);
     return;
@@ -531,9 +543,7 @@ static void realizeTypeRequirement(TypeDecl *decl, DeclContext *dc,
     result.push_back({Requirement(RequirementKind::Superclass,
                                   subjectType, constraintType),
                       loc});
-  } else if (gpDecl &&
-             gpDecl->isValue() &&
-             constraintType->isLegalValueGenericType()) {
+  } else if (gpDecl && gpDecl->isValue()) {
     result.push_back({Requirement(RequirementKind::Value,
                                 subjectType, constraintType),
                       loc});
@@ -689,6 +699,10 @@ struct InferRequirementsWalker : public TypeWalker {
       if (skipRequirement(rawReq, decl))
         continue;
 
+      if (rawReq.getKind() == RequirementKind::Value) {
+        continue;
+      }
+
       reqs.push_back({rawReq.subst(subMap), SourceLoc()});
     }
 

lib/Sema/TypeCheckGeneric.cpp

@@ -964,11 +964,11 @@ void TypeChecker::diagnoseRequirementFailure(
 
   case RequirementKind::Value:
     if (substReq.getFirstType()->is<IntegerType>()) {
-      diagnostic = diag::invalid_value_variable_generic;
-      diagnosticNote = diag::invalid_value_variable_generic_requirement;
+      diagnostic = diag::invalid_value_value_generic;
+      diagnosticNote = diag::invalid_value_value_generic_requirement;
     } else {
       diagnostic = diag::cannot_pass_type_for_value_generic;
-      diagnosticNote = diag::invalid_value_variable_generic_requirement;
+      diagnosticNote = diag::invalid_value_value_generic_requirement;
     }
 
     break;

lib/Sema/TypeCheckType.cpp

@@ -4762,6 +4762,37 @@ TypeResolver::resolveDeclRefTypeRepr(DeclRefTypeRepr *repr,
     return ErrorType::get(result->getASTContext());
   }
 
+  // Diagnose an error if an IntegerType or GenericTypeParamType who is a value
+  // is being used as a type parameter instead of a value parameter.
+  //
+  // FIXME: This runs through every bound generic type, is there a better way
+  // of doing this or perhaps add a quicker check so that we aren't doing this
+  // for all types..?
+  if (auto generic = result->getAs<BoundGenericType>()) {
+    auto subs = generic->getContextSubstitutionMap();
+    auto replacements = subs.getReplacementTypes();
+    auto params = subs.getGenericSignature().getGenericParams();
+
+    for (auto p : llvm::zip(params, replacements)) {
+      auto param = std::get<0>(p);
+      auto replacement = std::get<1>(p);
+
+      if (replacement->is<IntegerType>() && !param->isValue()) {
+        result->getASTContext().Diags.diagnose(repr->getLoc(),
+          diag::value_type_used_in_type_parameter, replacement, param);
+        return ErrorType::get(result->getASTContext());
+      }
+
+      if (replacement->is<GenericTypeParamType>() &&
+          replacement->getAs<GenericTypeParamType>()->isValue() &&
+          !param->isValue()) {
+        result->getASTContext().Diags.diagnose(repr->getLoc(),
+          diag::value_type_used_in_type_parameter, replacement, param);
+        return ErrorType::get(result->getASTContext());
+      }
+    }
+  }
+
   if (auto moduleTy = result->getAs<ModuleType>()) {
     // Allow module types only if flag is specified.
     if (options.contains(TypeResolutionFlags::AllowModule))

test/Sema/value_generics.swift

@@ -0,0 +1,73 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature NonescapableTypes
+
+protocol P {}
+
+struct A<let N: Int> { // expected-note {{requirement specified as 'let N' == 'Int' [with N = T]}}
+                       // expected-note@-1 {{requirement specified as 'let N' == 'Int' [with N = Int]}}
+  var int: Int {
+    N // OK
+  }
+
+  var uint: UInt {
+    N // expected-error {{cannot convert return expression of type '(let N).Type' to return type 'UInt'}}
+  }
+}
+
+extension A where N: P {} // expected-error {{value generic type 'let N' cannot conform to protocol 'P'}}
+
+func b(with a: A<123>) {} // OK
+func c<let M: Int>(with a: A<M>) {} // OK
+func d<T>(with a: A<T>) {} // expected-error {{cannot pass type 'T' as a value for generic value of 'Int'}}
+func e(with a: A<Int>) {} // expected-error {{cannot pass type 'Int' as a value for generic value of 'Int'}}
+
+struct Generic<T: ~Copyable & ~Escapable> {}
+
+func f(with generic: Generic<123>) {} // expected-error {{cannot use value type '123' for generic argument 'T'}}
+func g<let N: Int>(with generic: Generic<N>) {} // expected-error {{cannot use value type 'let N' for generic argument 'T'}}
+
+struct B<let N: UInt8> {} // expected-error {{'UInt8' is not a supported value type for 'let N'}}
+
+struct C<let N: Int, let M: Int> {}
+
+extension C where N == 123 { // expected-note {{where 'let N' = '0'}}
+                             // expected-note@-1 {{where 'let N' = '0'}}
+                             // expected-note@-2 {{where 'let N' = 'let T'}}
+  func nIs123() {}
+}
+
+extension C where M == 321 { // expected-note {{where 'let M' = '0'}}
+                             // expected-note@-1 {{where 'let M' = '0'}}
+                             // expected-note@-2 {{where 'let M' = 'let T'}}
+  func mIs123() {}
+}
+
+extension C where N == M { // expected-note {{where 'let N' = '123', 'let M' = '0'}}
+                           // expected-note@-1 {{where 'let N' = '0', 'let M' = '321'}}
+  func nAndMAreBothEqual() {}
+}
+
+func testC1(with c: C<0, 0>) {
+  c.nIs123() // expected-error {{referencing instance method 'nIs123()' on 'C' requires the types '0' and '123' be equivalent}}
+  c.mIs123() // expected-error {{referencing instance method 'mIs123()' on 'C' requires the types '0' and '321' be equivalent}}
+  c.nAndMAreBothEqual() // OK
+}
+
+func testC2(with c: C<123, 0>) {
+  c.nIs123() // OK
+  c.mIs123() // expected-error {{referencing instance method 'mIs123()' on 'C' requires the types '0' and '321' be equivalent}}
+  c.nAndMAreBothEqual() // expected-error {{referencing instance method 'nAndMAreBothEqual()' on 'C' requires the types '123' and '0' be equivalent}}
+}
+
+func testC3(with c: C<0, 321>) {
+  c.nIs123() // expected-error {{referencing instance method 'nIs123()' on 'C' requires the types '0' and '123' be equivalent}}
+  c.mIs123() // OK
+  c.nAndMAreBothEqual() // expected-error {{referencing instance method 'nAndMAreBothEqual()' on 'C' requires the types '0' and '321' be equivalent}}
+}
+
+func testC4<let T: Int>(with c: C<T, T>) {
+  c.nIs123() // expected-error {{referencing instance method 'nIs123()' on 'C' requires the types 'let T' and '123' be equivalent}}
+  c.mIs123() // expected-error {{referencing instance method 'mIs123()' on 'C' requires the types 'let T' and '321' be equivalent}}
+  c.nAndMAreBothEqual() // OK
+}
+
+struct D<let N: Int & P> {} // expected-error {{non-protocol, non-class type 'Int' cannot be used within a protocol-constrained type}}