Improve name generation for indexed expressions

pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/analysis/session.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 594 matching lines @@
     if (type is InterfaceType && alreadyAdded.add(type)) {
       builder.addSuggestion(LinkedEditSuggestionKind.TYPE, type.displayName);
       _addSuperTypeProposals(builder, type.superclass, alreadyAdded);
       for (InterfaceType interfaceType in type.interfaces) {
         _addSuperTypeProposals(builder, interfaceType, alreadyAdded);
       }
     }
   }
 
   String _getBaseNameFromExpression(Expression expression) {
+    if (expression is AsExpression) {
+      return _getBaseNameFromExpression(expression.expression);
+    } else if (expression is ParenthesizedExpression) {
+      return _getBaseNameFromExpression(expression.expression);
+    }
+    return _getBaseNameFromUnwrappedExpression(expression);
+  }
+
+  String _getBaseNameFromLocationInParent(Expression expression) {
+    // value in named expression
+    if (expression.parent is NamedExpression) {
+      NamedExpression namedExpression = expression.parent as NamedExpression;
+      if (namedExpression.expression == expression) {
+        return namedExpression.name.label.name;
+      }
+    }
+    // positional argument
+    ParameterElement parameter = expression.propagatedParameterElement;
+    if (parameter == null) {
+      parameter = expression.staticParameterElement;
+    }
+    if (parameter != null) {
+      return parameter.displayName;
+    }
+
+    // unknown
+    return null;
+  }
+
+  String _getBaseNameFromUnwrappedExpression(Expression expression) {
     String name = null;
-    // e as Type
-    if (expression is AsExpression) {
-      AsExpression asExpression = expression as AsExpression;
-      expression = asExpression.expression;
-    }
     // analyze expressions
     if (expression is SimpleIdentifier) {
-      SimpleIdentifier node = expression;
-      return node.name;
+      return expression.name;
     } else if (expression is PrefixedIdentifier) {
-      PrefixedIdentifier node = expression;
-      return node.identifier.name;
+      return expression.identifier.name;
     } else if (expression is PropertyAccess) {
-      PropertyAccess node = expression;
-      return node.propertyName.name;
+      return expression.propertyName.name;
     } else if (expression is MethodInvocation) {
       name = expression.methodName.name;
     } else if (expression is InstanceCreationExpression) {
-      InstanceCreationExpression creation = expression;
-      ConstructorName constructorName = creation.constructorName;
+      ConstructorName constructorName = expression.constructorName;
       TypeName typeName = constructorName.type;
       if (typeName != null) {
         Identifier typeNameIdentifier = typeName.name;
         // new ClassName()
         if (typeNameIdentifier is SimpleIdentifier) {
           return typeNameIdentifier.name;
         }
         // new prefix.name();
         if (typeNameIdentifier is PrefixedIdentifier) {
           PrefixedIdentifier prefixed = typeNameIdentifier;
           // new prefix.ClassName()
           if (prefixed.prefix.staticElement is PrefixElement) {
             return prefixed.identifier.name;
           }
           // new ClassName.constructorName()
           return prefixed.prefix.name;
         }
       }
+    } else if (expression is IndexExpression) {
+      name = _getBaseNameFromExpression(expression.realTarget);
+      if (name.endsWith('es')) {
+        name = name.substring(0, name.length - 2);
+      } else if (name.endsWith('s')) {
+        name = name.substring(0, name.length - 1);
+      }
     }
     // strip known prefixes
     if (name != null) {
       for (int i = 0; i < _KNOWN_METHOD_NAME_PREFIXES.length; i++) {
         String prefix = _KNOWN_METHOD_NAME_PREFIXES[i];
         if (name.startsWith(prefix)) {
           if (name == prefix) {
             return null;
           } else if (isUpperCase(name.codeUnitAt(prefix.length))) {
             return name.substring(prefix.length);
           }
         }
       }
     }
     // done
     return name;
   }
 
-  String _getBaseNameFromLocationInParent(Expression expression) {
-    // value in named expression
-    if (expression.parent is NamedExpression) {
-      NamedExpression namedExpression = expression.parent as NamedExpression;
-      if (namedExpression.expression == expression) {
-        return namedExpression.name.label.name;
-      }
-    }
-    // positional argument
-    ParameterElement parameter = expression.propagatedParameterElement;
-    if (parameter == null) {
-      parameter = expression.staticParameterElement;
-    }
-    if (parameter != null) {
-      return parameter.displayName;
-    }
-
-    // unknown
-    return null;
-  }
-
   /**
    * Returns all variants of names by removing leading words one by one.
    */
   List<String> _getCamelWordCombinations(String name) {
     List<String> result = [];
     List<String> parts = getCamelWords(name);
     for (int i = 0; i < parts.length; i++) {
       String s1 = parts[i].toLowerCase();
       String s2 = parts.skip(i + 1).join();
       String suggestion = '$s1$s2';
@@ skipping 690 matching lines @@
   }
 }
 
 class _InsertionDescription {
   final int offset;
   final bool insertEmptyLineBefore;
   final bool insertEmptyLineAfter;
   _InsertionDescription(
       this.offset, this.insertEmptyLineBefore, this.insertEmptyLineAfter);
 }