Issue 22409. Restore recognizing string concatenation in const expressions.

pkg/analyzer/test/generated/all_the_rest_test.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.all_the_rest_test;
 
 import 'dart:collection';
 
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/html.dart' as ht;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/html_factory.dart';
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:path/src/context.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
 import 'parser_test.dart';
 import 'resolver_test.dart';
 import 'test_support.dart';
-import 'package:analyzer/source/package_map_resolver.dart';
-import 'package:analyzer/file_system/memory_file_system.dart';
-import 'package:analyzer/file_system/file_system.dart';
-import 'package:path/src/context.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ConstantEvaluatorTest);
   runReflectiveTests(ConstantFinderTest);
   runReflectiveTests(ConstantValueComputerTest);
   runReflectiveTests(ConstantVisitorTest);
   runReflectiveTests(ContentCacheTest);
   runReflectiveTests(CustomUriResolverTest);
@@ skipping 446 matching lines @@
     expect(value, null);
   }
 
   void fail_identifier_typeParameter() {
     EvaluationResult result = _getExpressionValue("?");
     expect(result.isValid, isTrue);
     DartObject value = result.value;
     expect(value, null);
   }
 
-  void fail_plus_string_string() {
-    _assertValue4("ab", "'a' + 'b'");
-  }
-
   void fail_prefixedIdentifier_invalid() {
     EvaluationResult result = _getExpressionValue("?");
     expect(result.isValid, isTrue);
     DartObject value = result.value;
     expect(value, null);
   }
 
   void fail_prefixedIdentifier_valid() {
     EvaluationResult result = _getExpressionValue("?");
     expect(result.isValid, isTrue);
@@ skipping 22 matching lines @@
     expect(value, null);
   }
 
   void fail_simpleIdentifier_valid() {
     EvaluationResult result = _getExpressionValue("?");
     expect(result.isValid, isTrue);
     DartObject value = result.value;
     expect(value, null);
   }
 
-  void fail_stringLength_complex() {
-    _assertValue3(6, "('qwe' + 'rty').length");
-  }
-
-  void fail_stringLength_simple() {
-    _assertValue3(6, "'Dvorak'.length");
-  }
-
   void test_bitAnd_int_int() {
     _assertValue3(74 & 42, "74 & 42");
   }
 
   void test_bitNot() {
     _assertValue3(~42, "~42");
   }
 
   void test_bitOr_int_int() {
     _assertValue3(74 | 42, "74 | 42");
   }
 
   void test_bitXor_int_int() {
     _assertValue3(74 ^ 42, "74 ^ 42");
   }
+
   void test_divide_double_double() {
     _assertValue2(3.2 / 2.3, "3.2 / 2.3");
   }
 
   void test_divide_double_double_byZero() {
     EvaluationResult result = _getExpressionValue("3.2 / 0.0");
     expect(result.isValid, isTrue);
     DartObject value = result.value;
     expect(value.type.name, "double");
     expect(value.doubleValue.isInfinite, isTrue);
   }
 
   void test_divide_int_int() {
     _assertValue3(1, "3 / 2");
   }
-
   void test_divide_int_int_byZero() {
     EvaluationResult result = _getExpressionValue("3 / 0");
     expect(result.isValid, isTrue);
   }
 
   void test_equal_boolean_boolean() {
     _assertValue(false, "true == false");
   }
 
   void test_equal_int_int() {
@@ skipping 18 matching lines @@
     _assertValue(false, "2 > 3");
   }
 
   void test_greaterThanOrEqual_int_int() {
     _assertValue(false, "2 >= 3");
   }
 
   void test_leftShift_int_int() {
     _assertValue3(64, "16 << 2");
   }
+
   void test_lessThan_int_int() {
     _assertValue(true, "2 < 3");
   }
 
   void test_lessThanOrEqual_int_int() {
     _assertValue(true, "2 <= 3");
   }
 
   void test_literal_boolean_false() {
     _assertValue(false, "false");
   }
-
   void test_literal_boolean_true() {
     _assertValue(true, "true");
   }
 
   void test_literal_list() {
     EvaluationResult result = _getExpressionValue("const ['a', 'b', 'c']");
     expect(result.isValid, isTrue);
   }
 
   void test_literal_map() {
@@ skipping 94 matching lines @@
   }
 
   void test_plus_double_double() {
     _assertValue2(2.3 + 3.2, "2.3 + 3.2");
   }
 
   void test_plus_int_int() {
     _assertValue3(5, "2 + 3");
   }
 
+  void test_plus_string_string() {
+    _assertValue4("ab", "'a' + 'b'");
+  }
+
   void test_remainder_double_double() {
     _assertValue2(3.2 % 2.3, "3.2 % 2.3");
   }
 
   void test_remainder_int_int() {
     _assertValue3(2, "8 % 3");
   }
 
   void test_rightShift() {
     _assertValue3(16, "64 >> 2");
   }
 
+  void test_stringLength_complex() {
+    _assertValue3(6, "('qwe' + 'rty').length");
+  }
+
+  void test_stringLength_simple() {
+    _assertValue3(6, "'Dvorak'.length");
+  }
+
   void test_times_double_double() {
     _assertValue2(2.3 * 3.2, "2.3 * 3.2");
   }
 
   void test_times_int_int() {
     _assertValue3(6, "2 * 3");
   }
 
   void test_truncatingDivide_double_double() {
     _assertValue3(1, "3.2 ~/ 2.3");
@@ skipping 1625 matching lines @@
 @reflectiveTest
 class CustomUriResolverTest {
   void test_creation() {
     expect(new CustomUriResolver({}), isNotNull);
   }
 
   void test_resolve_unknown_uri() {
     UriResolver resolver = new CustomUriResolver({
       'custom:library': '/path/to/library.dart',
     });
-    Source result = resolver.resolveAbsolute(
-        parseUriWithException("custom:non_library"));
+    Source result =
+        resolver.resolveAbsolute(parseUriWithException("custom:non_library"));
     expect(result, isNull);
   }
 
   void test_resolve_uri() {
     String path =
         FileUtilities2.createFile("/path/to/library.dart").getAbsolutePath();
     UriResolver resolver = new CustomUriResolver({
       'custom:library': path,
     });
-    Source result = resolver.resolveAbsolute(
-        parseUriWithException("custom:library"));
+    Source result =
+        resolver.resolveAbsolute(parseUriWithException("custom:library"));
     expect(result, isNotNull);
     expect(result.fullName, path);
   }
 }
 
 
 @reflectiveTest
 class DartObjectImplTest extends EngineTestCase {
   TypeProvider _typeProvider = new TestTypeProvider();
 
-  void fail_add_knownString_knownString() {
-    fail("New constant semantics are not yet enabled");
-    _assertAdd(_stringValue("ab"), _stringValue("a"), _stringValue("b"));
-  }
-
-  void fail_add_knownString_unknownString() {
-    fail("New constant semantics are not yet enabled");
-    _assertAdd(_stringValue(null), _stringValue("a"), _stringValue(null));
-  }
-
-  void fail_add_unknownString_knownString() {
-    fail("New constant semantics are not yet enabled");
-    _assertAdd(_stringValue(null), _stringValue(null), _stringValue("b"));
-  }
-  void fail_add_unknownString_unknownString() {
-    fail("New constant semantics are not yet enabled");
-    _assertAdd(_stringValue(null), _stringValue(null), _stringValue(null));
-  }
-
   void test_add_knownDouble_knownDouble() {
     _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _doubleValue(2.0));
   }
 
   void test_add_knownDouble_knownInt() {
     _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _intValue(2));
   }
 
   void test_add_knownDouble_unknownDouble() {
     _assertAdd(_doubleValue(null), _doubleValue(1.0), _doubleValue(null));
@@ skipping 16 matching lines @@
   }
 
   void test_add_knownInt_unknownInt() {
     _assertAdd(_intValue(null), _intValue(1), _intValue(null));
   }
 
   void test_add_knownString_knownInt() {
     _assertAdd(null, _stringValue("1"), _intValue(2));
   }
 
+  void test_add_knownString_knownString() {
+    _assertAdd(_stringValue("ab"), _stringValue("a"), _stringValue("b"));
+  }
+
+  void test_add_knownString_unknownString() {
+    _assertAdd(_stringValue(null), _stringValue("a"), _stringValue(null));
+  }
+
   void test_add_unknownDouble_knownDouble() {
     _assertAdd(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));
   }
 
   void test_add_unknownDouble_knownInt() {
     _assertAdd(_doubleValue(null), _doubleValue(null), _intValue(2));
   }
 
   void test_add_unknownInt_knownDouble() {
     _assertAdd(_doubleValue(null), _intValue(null), _doubleValue(2.0));
   }
 
   void test_add_unknownInt_knownInt() {
     _assertAdd(_intValue(null), _intValue(null), _intValue(2));
   }
+
+  void test_add_unknownString_knownString() {
+    _assertAdd(_stringValue(null), _stringValue(null), _stringValue("b"));
+  }
+
+  void test_add_unknownString_unknownString() {
+    _assertAdd(_stringValue(null), _stringValue(null), _stringValue(null));
+  }
   void test_bitAnd_knownInt_knownInt() {
     _assertBitAnd(_intValue(2), _intValue(6), _intValue(3));
   }
 
   void test_bitAnd_knownInt_knownString() {
     _assertBitAnd(null, _intValue(6), _stringValue("3"));
   }
 
   void test_bitAnd_knownInt_unknownInt() {
     _assertBitAnd(_intValue(null), _intValue(6), _intValue(null));
@@ skipping 6027 matching lines @@
         new FileBasedSource.con1(FileUtilities2.createFile("/does/not/have.dart"));
     Source result = factory.resolveUri(containingSource, "exist.dart");
     expect(
         result.fullName,
         FileUtilities2.createFile("/does/not/exist.dart").getAbsolutePath());
   }
 
   void test_resolveUri_nonAbsolute_relative_package() {
     MemoryResourceProvider provider = new MemoryResourceProvider();
     Context context = provider.pathContext;
-    String packagePath = context.joinAll([context.separator, 'path', 'to', 'package']);
+    String packagePath =
+        context.joinAll([context.separator, 'path', 'to', 'package']);
     String libPath = context.joinAll([packagePath, 'lib']);
     String dirPath = context.joinAll([libPath, 'dir']);
     String firstPath = context.joinAll([dirPath, 'first.dart']);
     String secondPath = context.joinAll([dirPath, 'second.dart']);
 
     provider.newFolder(packagePath);
-    Folder libFolder =  provider.newFolder(libPath);
+    Folder libFolder = provider.newFolder(libPath);
     provider.newFolder(dirPath);
     File firstFile = provider.newFile(firstPath, '');
     provider.newFile(secondPath, '');
 
-    PackageMapUriResolver resolver = new PackageMapUriResolver(provider, {'package' : [libFolder]});
+    PackageMapUriResolver resolver = new PackageMapUriResolver(provider, {
+      'package': [libFolder]
+    });
     SourceFactory factory = new SourceFactory([resolver]);
-    Source librarySource = firstFile.createSource(Uri.parse('package:package/dir/first.dart'));
+    Source librarySource =
+        firstFile.createSource(Uri.parse('package:package/dir/first.dart'));
 
     Source result = factory.resolveUri(librarySource, 'second.dart');
     expect(result, isNotNull);
     expect(result.fullName, secondPath);
     expect(result.uri.toString(), 'package:package/dir/second.dart');
   }
 
   void test_restoreUri() {
     JavaFile file1 = FileUtilities2.createFile("/some/file1.dart");
     JavaFile file2 = FileUtilities2.createFile("/some/file2.dart");
@@ skipping 493 matching lines @@
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(
           actualExternalScriptName,
           _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }