[analysis_server] Dot shorthands: Extract expression tests.

Adding logic to add a type when extracting locals or methods, otherwise we're refactoring shorthands into a statement with no context.

Tests for mixins, extension types, enums and classes.

Bug: #59836
Change-Id: I8ee1407ba82118831e3bbb092e11a44b6ea5384c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/431950
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Paul Berry <[email protected]>

Author: kallentu

pkg/analysis_server/lib/src/services/refactoring/legacy/extract_local.dart

@@ -24,6 +24,7 @@ import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/source/source_range.dart';
 import 'package:analyzer/src/generated/java_core.dart';
+import 'package:analyzer/src/utilities/dot_shorthands.dart';
 import 'package:analyzer_plugin/utilities/range_factory.dart';
 
 const String _TOKEN_SEPARATOR = '\uFFFF';
@@ -81,21 +82,32 @@ class ExtractLocalRefactoringImpl extends RefactoringImpl
   CompilationUnit get unit => resolveResult.unit;
 
   String get _declarationKeywordAndType {
-    var useConst =
-        stringLiteralPart == null &&
-        _isPartOfConstantExpression(singleExpression);
-    var useFinal = codeStyleOptions.makeLocalsFinal;
+    bool useConst;
+    bool dotShorthandRequiresType;
+    var expression = singleExpression;
+    if (expression != null) {
+      useConst = stringLiteralPart == null && expression.inConstantContext;
+      // If the expression that we're extracting is a dot shorthand or we have a
+      // dependent dot shorthand, we need to retain the type in the new
+      // declaration.
+      dotShorthandRequiresType =
+          isDotShorthand(expression) || hasDependentDotShorthand(expression);
+    } else {
+      dotShorthandRequiresType = false;
+      useConst = false;
+    }
 
     String? typeString;
-    if (codeStyleOptions.specifyTypes) {
+    if (codeStyleOptions.specifyTypes || dotShorthandRequiresType) {
       typeString =
-          singleExpression != null
-              ? singleExpression?.staticType?.getDisplayString()
+          expression != null
+              ? expression.staticType?.getDisplayString()
               : stringLiteralPart != null
               ? 'String'
               : null;
     }
 
+    var useFinal = codeStyleOptions.makeLocalsFinal;
     if (useConst) {
       return typeString != null ? 'const $typeString' : 'const';
     } else if (useFinal) {
@@ -499,28 +511,6 @@ class ExtractLocalRefactoringImpl extends RefactoringImpl
     return null;
   }
 
-  bool _isPartOfConstantExpression(AstNode? node) {
-    if (node == null) {
-      return false;
-    }
-    if (node is TypedLiteral) {
-      return node.isConst;
-    }
-    if (node is InstanceCreationExpression) {
-      return node.isConst;
-    }
-    if (node is ArgumentList ||
-        node is ConditionalExpression ||
-        node is BinaryExpression ||
-        node is ParenthesizedExpression ||
-        node is PrefixExpression ||
-        node is Literal ||
-        node is MapLiteralEntry) {
-      return _isPartOfConstantExpression(node.parent);
-    }
-    return false;
-  }
-
   void _prepareNames() {
     names.clear();
     var stringLiteralPart = this.stringLiteralPart;

pkg/analysis_server/test/services/refactoring/legacy/extract_local_test.dart

@@ -344,6 +344,24 @@ void f() {
 ''');
   }
 
+  Future<void> test_const_enum() async {
+    await indexTestUnit('''
+enum A { a }
+void f() {
+  const A vvv = A.a;
+}
+''');
+    _createRefactoringForString('A.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+void f() {
+  const res = A.a;
+  const A vvv = res;
+}
+''');
+  }
+
   Future<void> test_const_inList() async {
     await indexTestUnit('''
 void f() {
@@ -608,6 +626,94 @@ int foo({int ppp = 0}) => ppp + 1;
     expect(subExpressions, ['foo(ppp: 42)']);
   }
 
+  Future<void> test_dotShorthand() async {
+    await indexTestUnit('''
+enum A { a }
+void f() {
+  A vvv = .a;
+}
+''');
+    _createRefactoringForString('.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+void f() {
+  A res = .a;
+  A vvv = res;
+}
+''');
+  }
+
+  Future<void> test_dotShorthand_const() async {
+    await indexTestUnit('''
+enum A { a }
+void f() {
+  const A vvv = .a;
+}
+''');
+    _createRefactoringForString('.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+void f() {
+  const A res = .a;
+  const A vvv = res;
+}
+''');
+  }
+
+  Future<void> test_dotShorthand_inferred() async {
+    await indexTestUnit('''
+enum A { a }
+T f<T>(T arg) => arg;
+
+void g() {
+  A a = f(.a);
+}
+''');
+    _createRefactoringForString('.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+T f<T>(T arg) => arg;
+
+void g() {
+  A res = .a;
+  A a = f(res);
+}
+''');
+  }
+
+  Future<void> test_dotShorthand_inferred_chain() async {
+    await indexTestUnit('''
+class A {
+  A.named();
+  A fn() => A.named();
+}
+
+T f<T>(T arg) => arg;
+
+void g() {
+  A a = f(.named().fn());
+}
+''');
+    _createRefactoringForString('.named().fn()');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+class A {
+  A.named();
+  A fn() => A.named();
+}
+
+T f<T>(T arg) => arg;
+
+void g() {
+  A res = .named().fn();
+  A a = f(res);
+}
+''');
+  }
+
   Future<void> test_fragmentExpression() async {
     await indexTestUnit('''
 void f() {
@@ -830,6 +936,32 @@ void f() {
 ''');
   }
 
+  // Enabling the lint should not impact the result -- which is keeping the type
+  // in the extracted local.
+  Future<void> test_lint_alwaysSpecifyTypes_dotShorthand() async {
+    createAnalysisOptionsFile(
+      experiments: experiments,
+      lints: [LintNames.always_specify_types],
+    );
+    await indexTestUnit('''
+enum A { a }
+void fn(A a) => print(a);
+void f() {
+  fn(.a);
+}
+''');
+    _createRefactoringForString('.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+void fn(A a) => print(a);
+void f() {
+  A res = .a;
+  fn(res);
+}
+''');
+  }
+
   Future<void> test_lint_alwaysSpecifyTypes_final() async {
     createAnalysisOptionsFile(
       lints: [LintNames.always_specify_types, LintNames.prefer_final_locals],
@@ -916,6 +1048,74 @@ void f() {
 ''');
   }
 
+  Future<void> test_lint_preferFinalLocals_const() async {
+    createAnalysisOptionsFile(
+      experiments: experiments,
+      lints: [LintNames.prefer_final_locals],
+    );
+    await indexTestUnit('''
+enum A { a }
+void f() {
+  const a = A.a;
+}
+''');
+    _createRefactoringForString('.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+void f() {
+  const res = A.a;
+  const a = res;
+}
+''');
+  }
+
+  Future<void> test_lint_preferFinalLocals_dotShorthand() async {
+    createAnalysisOptionsFile(
+      experiments: experiments,
+      lints: [LintNames.prefer_final_locals],
+    );
+    await indexTestUnit('''
+enum A { a }
+void fn(A a) => print(a);
+void f() {
+  fn(.a);
+}
+''');
+    _createRefactoringForString('.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+void fn(A a) => print(a);
+void f() {
+  final A res = .a;
+  fn(res);
+}
+''');
+  }
+
+  Future<void> test_lint_preferFinalLocals_dotShorthand_const() async {
+    createAnalysisOptionsFile(
+      experiments: experiments,
+      lints: [LintNames.prefer_final_locals],
+    );
+    await indexTestUnit('''
+enum A { a }
+void f() {
+  const A a = .a;
+}
+''');
+    _createRefactoringForString('.a');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+enum A { a }
+void f() {
+  const A res = .a;
+  const A a = res;
+}
+''');
+  }
+
   Future<void> test_occurrences_differentName_samePrefix() async {
     await indexTestUnit('''
 void f(A a) {