Disallow referencing a value generic outside of certain contexts

Author: Azoy

include/swift/AST/DiagnosticsSema.def

@@ -8012,8 +8012,6 @@ ERROR(cannot_pass_type_for_value_generic,none,
       "cannot pass type %0 as a value for generic value %1", (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,
@@ -8022,6 +8020,8 @@ ERROR(invalid_value_generic_same_type,none,
       "cannot constrain value parameter %0 to be type %1", (Type, Type))
 ERROR(integer_type_not_accepted,none,
       "integer unexpectedly used in a type position", ())
+ERROR(value_generic_unexpected,none,
+      "using value generic %0 here is not allowed", (Type))
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/AST/LifetimeDependence.cpp

@@ -441,6 +441,10 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
     return std::nullopt;
   }
 
+  if (getResultOrYield(afd)->hasError()) {
+    return std::nullopt;
+  }
+
   // Setters infer 'self' dependence on 'newValue'.
   if (auto accessor = dyn_cast<AccessorDecl>(afd)) {
     if (accessor->getAccessorKind() == AccessorKind::Set) {

lib/Sema/TypeCheckType.cpp

@@ -721,13 +721,9 @@ void swift::diagnoseInvalidGenericArguments(SourceLoc loc,
 }
 
 namespace {
-  /// Visits a requirement type to match it to a potential witness for
-  /// the purpose of deducing associated types.
-  ///
-  /// The visitor argument is the witness type. If there are any
-  /// obvious conflicts between the structure of the two types,
-  /// returns true. The conflict checking is fairly conservative, only
-  /// considering rough structure.
+  /// Visits a generic parameter and the type attempting to substitute for it
+  /// to see if it's a valid parameter for integer arguments or other value
+  /// generic parameters.
   class ValueMatchVisitor : public TypeMatcher<ValueMatchVisitor> {
   public:
     ValueMatchVisitor() {}
@@ -4945,6 +4941,19 @@ TypeResolver::resolveDeclRefTypeRepr(DeclRefTypeRepr *repr,
   if (result->is<FunctionType>())
     result = applyNonEscapingIfNecessary(result, options);
 
+  // Referencing a value generic by name, e.g. 'let N' and referencing 'N', is
+  // only valid as a generic argument, in generic requirements, and when being
+  // used as an expression.
+  if (result->isValueParameter() &&
+      !(options.isGenericArgument() ||
+        options.isGenericRequirement() ||
+        options.isAnyExpr())) {
+    if (!options.contains(TypeResolutionFlags::SilenceErrors)) {
+      diagnose(repr->getNameLoc(), diag::value_generic_unexpected, result);
+    }
+    return ErrorType::get(getASTContext());
+  }
+
   return result;
 }
 

lib/Sema/TypeCheckType.h

@@ -106,6 +106,9 @@ enum class TypeResolverContext : uint8_t {
   /// arguments.
   VariadicGenericArgument,
 
+  /// Whether we are checking generic arguments of a bound generic type with
+  /// value parameters. We use the ValueMatchVisitor to ensure that all value
+  /// parameters line up with integer types or other value parameters.
   ValueGenericArgument,
 
   /// Whether we are checking a tuple element type.
@@ -272,7 +275,6 @@ class TypeResolutionOptions {
     case Context::InExpression:
     case Context::ExplicitCastExpr:
     case Context::ForEachStmt:
-    case Context::PatternBindingDecl:
     case Context::EditorPlaceholderExpr:
     case Context::ClosureExpr:
       return true;
@@ -305,6 +307,7 @@ class TypeResolutionOptions {
     case Context::CustomAttr:
     case Context::Inverted:
     case Context::ValueGenericArgument:
+    case Context::PatternBindingDecl:
       return false;
     }
     llvm_unreachable("unhandled kind");
@@ -397,6 +400,50 @@ class TypeResolutionOptions {
     }
   }
 
+  /// Whether we are resolving a type in a generic argument list.
+  bool isGenericArgument() const {
+    switch (context) {
+    case Context::ScalarGenericArgument:
+    case Context::VariadicGenericArgument:
+    case Context::ValueGenericArgument:
+      return true;
+
+    case Context::None:
+    case Context::Inherited:
+    case Context::FunctionInput:
+    case Context::PackElement:
+    case Context::TupleElement:
+    case Context::GenericRequirement:
+    case Context::SameTypeRequirement:
+    case Context::ExtensionBinding:
+    case Context::TypeAliasDecl:
+    case Context::GenericTypeAliasDecl:
+    case Context::ExistentialConstraint:
+    case Context::MetatypeBase:
+    case Context::InExpression:
+    case Context::ExplicitCastExpr:
+    case Context::ForEachStmt:
+    case Context::PatternBindingDecl:
+    case Context::EditorPlaceholderExpr:
+    case Context::ClosureExpr:
+    case Context::VariadicFunctionInput:
+    case Context::InoutFunctionInput:
+    case Context::FunctionResult:
+    case Context::SubscriptDecl:
+    case Context::EnumElementDecl:
+    case Context::MacroDecl:
+    case Context::EnumPatternPayload:
+    case Context::ProtocolMetatypeBase:
+    case Context::ImmediateOptionalTypeArgument:
+    case Context::AbstractFunctionDecl:
+    case Context::CustomAttr:
+    case Context::Inverted:
+    case Context::GenericParameterInherited:
+    case Context::AssociatedTypeInherited:
+      return false;
+    }
+  }
+
   /// Whether we are resolving a type in a `where` clause, generic parameter
   /// declaration inheritance clause, or associated type inheritance clause.
   bool isGenericRequirement() const {

test/Sema/value_generics.swift

@@ -18,6 +18,18 @@ struct A<let N: Int> {
   var intSelf: Int {
     N.self // OK
   }
+
+  var n: N { // expected-error {{using value generic 'let N' here is not allowed}}
+    fatalError()
+  }
+
+  var nType: N.Type { // expected-error {{using value generic 'let N' here is not allowed}}
+    fatalError()
+  }
+
+  var a: A<N> { // OK
+    fatalError()
+  }
 }
 
 extension A where N: P {} // expected-error {{value generic type 'let N' cannot conform to protocol 'P'}}