Issue 22409. Restore recognizing string concatenation in const expressions.

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

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'dart:collection';
 
+import 'package:analyzer/src/generated/utilities_general.dart';
+
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine, RecordingErrorListener;
 import 'error.dart';
 import 'java_core.dart';
 import 'resolver.dart' show TypeProvider;
 import 'scanner.dart' show Token, TokenType;
 import 'source.dart' show Source;
 import 'utilities_collection.dart';
 import 'utilities_dart.dart' show ParameterKind;
-import 'package:analyzer/src/generated/utilities_general.dart';
 
 /**
  * Instances of the class `BoolState` represent the state of an object representing a boolean
  * value.
  */
 class BoolState extends InstanceState {
   /**
    * An instance representing the boolean value 'false'.
    */
   static BoolState FALSE_STATE = new BoolState(false);
@@ skipping 1225 matching lines @@
     return _nullObject;
   }
 
   /**
    * This method is called just before retrieving an evaluation result from an AST node. Unit tests
    * will override it to introduce additional error checking.
    */
   void beforeGetEvaluationResult(AstNode node) {
   }
 
+  /**
+   * Return `true` if the given [element] represents the `length` getter in
+   * class [String].
+   */
+  bool isStringLength(Element element) {
+    if (element is PropertyAccessorElement) {
+      if (element.isGetter && element.name == 'length') {
+        return element.enclosingElement == _typeProvider.stringType.element;
+      }
+    }
+    return false;
+  }
+
   @override
   DartObjectImpl visitAdjacentStrings(AdjacentStrings node) {
     DartObjectImpl result = null;
     for (StringLiteral string in node.strings) {
       if (result == null) {
         result = string.accept(this);
       } else {
         result =
             _dartObjectComputer.concatenate(node, result, string.accept(this));
       }
@@ skipping 262 matching lines @@
 
   @override
   DartObjectImpl visitNullLiteral(NullLiteral node) => null2;
 
   @override
   DartObjectImpl visitParenthesizedExpression(ParenthesizedExpression node) =>
       node.expression.accept(this);
 
   @override
   DartObjectImpl visitPrefixedIdentifier(PrefixedIdentifier node) {
-    // TODO(brianwilkerson) Uncomment the lines below when the new constant
-    // support can be added.
-    //    Element element = node.getStaticElement();
-    //    if (isStringLength(element)) {
-    //      EvaluationResultImpl target = node.getPrefix().accept(this);
-    //      return target.stringLength(typeProvider, node);
-    //    }
+    // String.length
+    {
+      Element element = node.staticElement;
+      if (isStringLength(element)) {
+        DartObjectImpl prefixResult = node.prefix.accept(this);
+        return prefixResult.stringLength(_typeProvider);
+      }
+    }
+    // importPrefix.CONST
     SimpleIdentifier prefixNode = node.prefix;
     Element prefixElement = prefixNode.staticElement;
     if (prefixElement is! PrefixElement) {
       DartObjectImpl prefixResult = prefixNode.accept(this);
       if (prefixResult == null) {
         // The error has already been reported.
         return null;
       }
     }
     // validate prefixed identifier
@@ skipping 19 matching lines @@
         _error(node, null);
         return null;
       }
       break;
     }
   }
 
   @override
   DartObjectImpl visitPropertyAccess(PropertyAccess node) {
     Element element = node.propertyName.staticElement;
-    // TODO(brianwilkerson) Uncomment the lines below when the new constant
-    // support can be added.
-    //    if (isStringLength(element)) {
-    //      EvaluationResultImpl target = node.getRealTarget().accept(this);
-    //      return target.stringLength(typeProvider, node);
-    //    }
+    if (isStringLength(element)) {
+      DartObjectImpl prefixResult = node.realTarget.accept(this);
+      return prefixResult.stringLength(_typeProvider);
+    }
     return _getConstantValue(node, element);
   }
 
   @override
   DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
     if (_lexicalEnvironment != null &&
         _lexicalEnvironment.containsKey(node.name)) {
       return _lexicalEnvironment[node.name];
     }
     return _getConstantValue(node, node.staticElement);
@@ skipping 1978 matching lines @@
     bool first = true;
     for (String fieldName in fieldNames) {
       if (first) {
         first = false;
       } else {
         buffer.write('; ');
       }
       buffer.write(fieldName);
       buffer.write(' = ');
       buffer.write(_fieldMap[fieldName]);
-    };
+    }
     return buffer.toString();
   }
 }
 
 /**
  * The class `InstanceState` defines the behavior of objects representing the state of a Dart
  * object.
  */
 abstract class InstanceState {
   /**
@@ skipping 46 matching lines @@
   Object get value => null;
 
   /**
    * Return the result of invoking the '+' operator on this object with the given argument.
    *
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '+' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   InstanceState add(InstanceState rightOperand) {
-    // TODO(brianwilkerson) Uncomment the code below when the new constant
-    // support can be added.
-//    if (this instanceof StringState || rightOperand instanceof StringState) {
-//      return concatenate(rightOperand);
-//    }
+    if (this is StringState && rightOperand is StringState) {
+      return concatenate(rightOperand);
+    }
     assertNumOrNull(this);
     assertNumOrNull(rightOperand);
     throw new EvaluationException(CompileTimeErrorCode.INVALID_CONSTANT);
   }
 
   /**
    * Throw an exception if the given state does not represent a boolean value.
    *
    * @param state the state being tested
    * @throws EvaluationException if the given state does not represent a boolean value
@@ skipping 1559 matching lines @@
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }