anchor.diff:      // Check if this type has type arguments and at least one is dynamic.
       // If so, we may need to issue a strict-raw-types error.
       if (typeArguments.any((t) => t.isDynamic)) {
  -      // If we have an inference context node, check if the type was inferred
  -      // from it. Some cases will not have a context type, such as the type
  -      // annotation `List` in `List list;`
  -      if (inferenceContextNode != null) {
  -        var contextType = InferenceContext.getContext(inferenceContextNode);
  -        if (contextType != null && UnknownInferredType.isKnown(contextType)) {
  -          // Type was inferred from downwards context: not an error.
  -          return false;
  -        }
  -      }
         if (element != null && element.hasOptionalTypeArgs) {
           return false;
         }
  
positive.code:   ///   contain `_`
    /// - [type] does not have any `dynamic` type arguments.
    /// - the element is marked with `@optionalTypeArgs` from "package:meta".
    bool _isMissingTypeArguments(AstNode node, DartType type, Element? element,
        Expression? inferenceContextNode) {
      List<DartType> typeArguments;
      var alias = type.alias;
      if (alias != null) {
  
negative.code:       return;
      }
      var type = node.typeOrThrow;
      if (_isMissingTypeArguments(node, type, node.name.staticElement)) {
        AstNode unwrappedParent = parentEscapingTypeArguments(node);
        if (unwrappedParent is AsExpression || unwrappedParent is IsExpression) {
          // Do not report a "Strict raw type" error in this case; too noisy.
  