anchor.diff:  ''');
     }
   
  -  test_integerLiteral_contextType_double() async {
  +  test_expression_integerLiteral_contextType_double() async {
       await assertNoErrorsInCode(r'''
   void f(double x) {
     switch (x) {
  
positive.code: ''');
    }
  
    test_simpleIdentifier_ifCase() async {
      await assertNoErrorsInCode(r'''
  void f(x, int y) {
    if (x case y) {}
  }
  ''');
      final node = findNode.caseClause('case').pattern;
      assertResolvedNodeText(node, r'''
  ConstantPattern
    expression: SimpleIdentifier
      token: y
      staticElement: self::@function::f::@parameter::y
      staticType: int
  ''');
    }
  
    test_switchCase() async {
      await assertNoErrorsInCode(r'''
  void f(x) {
    switch (x) {
  
negative.code: 
  @reflectiveTest
  class ConstantPatternResolutionTest extends PatternsResolutionTest {
    test_expression_class_field() async {
      await assertNoErrorsInCode(r'''
  class A {
    static const foo = 0;
  }
  
  void f(x) {
    if (x case A.foo) {}
  }
  ''');
  
      final node = findNode.caseClause('case').pattern;
      assertResolvedNodeText(node, r'''
  ConstantPattern
    expression: PrefixedIdentifier
      prefix: SimpleIdentifier
        token: A
        staticElement: self::@class::A
        staticType: null
      period: .
      identifier: SimpleIdentifier
        token: foo
        staticElement: self::@class::A::@getter::foo
        staticType: int
      staticElement: self::@class::A::@getter::foo
      staticType: int
  ''');
    }
  
    test_expression_instanceCreation() async {
      await assertNoErrorsInCode(r'''
  class A {
    const A();
  }
  
  void f(x) {
    if (x case const A()) {}
  }
  ''');
  
      final node = findNode.caseClause('case').pattern;
      assertResolvedNodeText(node, r'''
  ConstantPattern
    const: const
    expression: InstanceCreationExpression
      constructorName: ConstructorName
        type: NamedType
          name: SimpleIdentifier
            token: A
            staticElement: self::@class::A
            staticType: null
          type: A
        staticElement: self::@class::A::@constructor::new
      argumentList: ArgumentList
        leftParenthesis: (
        rightParenthesis: )
      staticType: A
  ''');
    }
  
    test_expression_integerLiteral() async {
      await assertNoErrorsInCode(r'''
  void f(x) {
    if (x case 0) {}
  