anchor.diff:  ''');
     }
   
  -  test_notGeneric_noName_constant() async {
  +  test_class_notGeneric_noName_constant() async {
       await assertErrorsInCode(r'''
   abstract class A {
     int get foo;
  
positive.code: ''');
    }
  
    test_notGeneric_hasName_recordField_named() async {
      await assertNoErrorsInCode(r'''
  typedef A = ({int foo});
  
  void f(x) {
    switch (x) {
      case A(foo: var y):
        break;
    }
  }
  ''');
      final node = findNode.switchPatternCase('case').pattern;
      assertResolvedNodeText(node, r'''
  ExtractorPattern
    type: NamedType
      name: SimpleIdentifier
        token: A
        staticElement: self::@typeAlias::A
        staticType: null
      type: ({int foo})
        alias: self::@typeAlias::A
    leftParenthesis: (
    fields
      RecordPatternField
        fieldName: RecordPatternFieldName
          name: foo
          colon: :
        pattern: VariablePattern
          keyword: var
          name: y
          declaredElement: hasImplicitType y@73
            type: int
        fieldElement: <null>
    rightParenthesis: )
  ''');
    }
  
    test_notGeneric_hasName_recordField_positional() async {
      await assertNoErrorsInCode(r'''
  typedef A = (int foo,);
  
  void f(x) {
    switch (x) {
      case A($0: var y):
        break;
    }
  }
  ''');
      final node = findNode.switchPatternCase('case').pattern;
      assertResolvedNodeText(node, r'''
  ExtractorPattern
    type: NamedType
      name: SimpleIdentifier
        token: A
        staticElement: self::@typeAlias::A
        staticType: null
      type: (int)
        alias: self::@typeAlias::A
    leftParenthesis: (
    fields
      RecordPatternField
        fieldName: RecordPatternFieldName
          name: $0
          colon: :
        pattern: VariablePattern
          keyword: var
          name: y
          declaredElement: hasImplicitType y@71
            type: int
        fieldElement: <null>
    rightParenthesis: )
  ''');
    }
  
    test_notGeneric_hasName_variable_untyped() async {
      await assertNoErrorsInCode(r'''
  abstract class A {
    int get foo;
  
negative.code: ''');
    }
  
    test_class_generic_withTypeArguments_hasName_variable_untyped() async {
      await assertNoErrorsInCode(r'''
  abstract class A<T> {
    T get foo;
  