Rewrite expressions in ConstantPattern(s) into TypeLiteral when appropriate.

Bug: https://github.com/dart-lang/linter/issues/4195
Change-Id: I5cf06da31aed9347002684580c106747a057e1f1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/290701
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/constant/evaluation.dart

@@ -936,6 +936,8 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
 
     if (!_isNonNullableByDefault && hasTypeParameterReference(type)) {
       return super.visitNamedType(node);
+    } else {
+      node.name.accept(this);
     }
 
     if (_substitution != null) {

pkg/analyzer/lib/src/dart/resolver/ast_rewrite.dart

@@ -251,15 +251,21 @@ class AstRewriter {
       return node;
     }
     var prefix = node.prefix;
-    var element = nameScope.lookup(prefix.name).getter;
-    if (element is InterfaceElement) {
+    var prefixElement = nameScope.lookup(prefix.name).getter;
+    if (parent is ConstantPattern && prefixElement is PrefixElement) {
+      final element = prefixElement.scope.lookup(node.identifier.name).getter;
+      if (element is TypeDefiningElement) {
+        return _toPatternTypeLiteral(parent, node);
+      }
+    }
+    if (prefixElement is InterfaceElement) {
       // Example:
       //     class C { C.named(); }
       //     C.named
       return _toConstructorReference_prefixed(
-          node: node, classElement: element);
-    } else if (element is TypeAliasElement) {
-      var aliasedType = element.aliasedType;
+          node: node, classElement: prefixElement);
+    } else if (prefixElement is TypeAliasElement) {
+      var aliasedType = prefixElement.aliasedType;
       if (aliasedType is InterfaceType) {
         // Example:
         //     class C { C.named(); }
@@ -376,6 +382,18 @@ class AstRewriter {
     return node;
   }
 
+  AstNode simpleIdentifier(Scope nameScope, SimpleIdentifierImpl node) {
+    final parent = node.parent;
+    if (parent is ConstantPattern) {
+      final element = nameScope.lookup(node.name).getter;
+      if (element is TypeDefiningElement) {
+        return _toPatternTypeLiteral(parent, node);
+      }
+    }
+
+    return node;
+  }
+
   AstNode _instanceCreation_prefix_type_name({
     required MethodInvocationImpl node,
     required PrefixedIdentifierImpl typeNameIdentifier,
@@ -627,4 +645,20 @@ class AstRewriter {
     NodeReplacer.replace(node, methodInvocation);
     return methodInvocation;
   }
+
+  TypeLiteralImpl _toPatternTypeLiteral(
+    ConstantPattern parent,
+    IdentifierImpl node,
+  ) {
+    final result = TypeLiteralImpl(
+      typeName: NamedTypeImpl(
+        name: node,
+        typeArguments: null,
+        question: null,
+      ),
+    );
+    result.staticType = _typeProvider.typeType;
+    NodeReplacer.replace(node, result, parent: parent);
+    return result;
+  }
 }

pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart

@@ -1156,6 +1156,16 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
     _setOrCreateMetadataElements(element, node.metadata);
   }
 
+  @override
+  void visitSimpleIdentifier(covariant SimpleIdentifierImpl node) {
+    final newNode = _astRewriter.simpleIdentifier(_nameScope, node);
+    if (newNode != node) {
+      return newNode.accept(this);
+    }
+
+    super.visitSimpleIdentifier(node);
+  }
+
   @override
   void visitSuperFormalParameter(covariant SuperFormalParameterImpl node) {
     SuperFormalParameterElementImpl element;

pkg/analyzer/test/src/dart/constant/evaluation_test.dart

@@ -1017,7 +1017,9 @@ class C<U> {
   }
 }
 ''');
-    var result = _evaluateConstantLocal('g')!;
+    var result = _evaluateConstantLocal('g', errorCodes: [
+      CompileTimeErrorCode.INVALID_CONSTANT,
+    ])!;
     assertType(result.type, 'void Function(U)');
     assertElement(result.toFunctionValue(), findElement.topFunction('f'));
     _assertTypeArguments(result, ['U']);

pkg/analyzer/test/src/dart/resolution/constant_pattern_test.dart

@@ -279,6 +279,151 @@ ConstantPattern
 ''');
   }
 
+  test_expression_typeLiteral_notPrefixed() async {
+    await assertNoErrorsInCode(r'''
+void f(Object? x) {
+  if (x case int) {}
+}
+''');
+    final node = findNode.singleGuardedPattern.pattern;
+    assertResolvedNodeText(node, r'''
+ConstantPattern
+  expression: TypeLiteral
+    type: NamedType
+      name: SimpleIdentifier
+        token: int
+        staticElement: dart:core::@class::int
+        staticType: null
+      type: int
+    staticType: Type
+  matchedValueType: Object?
+''');
+  }
+
+  test_expression_typeLiteral_notPrefixed_nested() async {
+    await assertNoErrorsInCode(r'''
+void f(Object? x) {
+  if (x case [0, int]) {}
+}
+''');
+    final node = findNode.singleGuardedPattern.pattern;
+    assertResolvedNodeText(node, r'''
+ListPattern
+  leftBracket: [
+  elements
+    ConstantPattern
+      expression: IntegerLiteral
+        literal: 0
+        staticType: int
+      matchedValueType: Object?
+    ConstantPattern
+      expression: TypeLiteral
+        type: NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int
+        staticType: Type
+      matchedValueType: Object?
+  rightBracket: ]
+  matchedValueType: Object?
+  requiredType: List<Object?>
+''');
+  }
+
+  test_expression_typeLiteral_notPrefixed_typeAlias() async {
+    await assertNoErrorsInCode(r'''
+typedef A = int;
+
+void f(Object? x) {
+  if (x case A) {}
+}
+''');
+    final node = findNode.singleGuardedPattern.pattern;
+    assertResolvedNodeText(node, r'''
+ConstantPattern
+  expression: TypeLiteral
+    type: NamedType
+      name: SimpleIdentifier
+        token: A
+        staticElement: self::@typeAlias::A
+        staticType: null
+      type: int
+        alias: self::@typeAlias::A
+    staticType: Type
+  matchedValueType: Object?
+''');
+  }
+
+  test_expression_typeLiteral_prefixed() async {
+    await assertNoErrorsInCode(r'''
+import 'dart:math' as math;
+
+void f(Object? x) {
+  if (x case math.Random) {}
+}
+''');
+    final node = findNode.singleGuardedPattern.pattern;
+    assertResolvedNodeText(node, r'''
+ConstantPattern
+  expression: TypeLiteral
+    type: NamedType
+      name: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: math
+          staticElement: self::@prefix::math
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: Random
+          staticElement: dart:math::@class::Random
+          staticType: null
+        staticElement: dart:math::@class::Random
+        staticType: null
+      type: Random
+    staticType: Type
+  matchedValueType: Object?
+''');
+  }
+
+  test_expression_typeLiteral_prefixed_typeAlias() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+typedef A = int;
+''');
+
+    await assertNoErrorsInCode(r'''
+import 'a.dart' as prefix;
+
+void f(Object? x) {
+  if (x case prefix.A) {}
+}
+''');
+
+    final node = findNode.singleGuardedPattern.pattern;
+    assertResolvedNodeText(node, r'''
+ConstantPattern
+  expression: TypeLiteral
+    type: NamedType
+      name: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: prefix
+          staticElement: self::@prefix::prefix
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: A
+          staticElement: package:test/a.dart::@typeAlias::A
+          staticType: null
+        staticElement: package:test/a.dart::@typeAlias::A
+        staticType: null
+      type: int
+        alias: package:test/a.dart::@typeAlias::A
+    staticType: Type
+  matchedValueType: Object?
+''');
+  }
+
   test_location_ifCase() async {
     await assertNoErrorsInCode(r'''
 void f(x) {

pkg/analyzer/test/src/diagnostics/const_with_type_parameters_test.dart

@@ -144,6 +144,7 @@ class A<U> {
 ''', [
       error(CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS_FUNCTION_TEAROFF,
           65, 1),
+      error(CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE, 65, 1),
     ]);
   }
 
@@ -159,6 +160,8 @@ class A<U> {
       error(HintCode.UNUSED_LOCAL_VARIABLE, 54, 1),
       error(CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS_FUNCTION_TEAROFF,
           60, 1),
+      error(CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE, 60,
+          1),
     ]);
   }
 

pkg/analyzer/test/src/diagnostics/constant_pattern_with_non_constant_expression_test.dart

@@ -558,4 +558,15 @@ GuardedPattern
     matchedValueType: dynamic
 ''');
   }
+
+  test_typeLiteral_typeParameter() async {
+    await assertErrorsInCode(r'''
+void f<T>(x) {
+  if (x case T) {}
+}
+''', [
+      error(CompileTimeErrorCode.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION,
+          28, 1),
+    ]);
+  }
 }

pkg/analyzer/test/src/diagnostics/non_constant_case_expression_from_deferred_library_test.dart

@@ -110,6 +110,37 @@ void f(int e) {
       error(expectedErrorCode, 74, 1),
     ]);
   }
+
+  test_simple_typeLiteral() async {
+    newFile('$testPackageLibPath/a.dart', '''
+class A {}
+''');
+
+    final ErrorCode expectedErrorCode;
+    switch (_variant) {
+      case _Variant.nullSafe:
+        expectedErrorCode = CompileTimeErrorCode
+            .NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY;
+        break;
+      case _Variant.patterns:
+        expectedErrorCode =
+            CompileTimeErrorCode.PATTERN_CONSTANT_FROM_DEFERRED_LIBRARY;
+        break;
+    }
+
+    await assertErrorsInCode('''
+import 'a.dart' deferred as a;
+
+void f(Object? x) {
+  switch (x) {
+    case a.A:
+      break;
+  }
+}
+''', [
+      error(expectedErrorCode, 78, 1),
+    ]);
+  }
 }
 
 enum _Variant { nullSafe, patterns }