Naive handling of List#[] and List#[]=

tests/compiler/dart2js/cpa_inference_test.dart

 // Copyright (c) 2012, 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:uri";
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/scanner/scannerlib.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/source_file.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/types/types.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart';
@@ skipping 140 matching lines @@
     operator *(x);
     operator -(x);
     operator ==(x);
   }
   abstract class int extends num { }
   abstract class double extends num { }
   class bool {}
   class String {}
   class Object {}
   class Function {}
-  abstract class List {}
+  abstract class List<E> {
+    factory List([int length]);
+    E operator [](int index);
+    void operator []=(int index, E value);
+  }
   abstract class Map {}
   class Closure {}
   class Null {}
   class Type {}
   class Dynamic_ {}
   bool identical(Object a, Object b) {}''';
 
 AnalysisResult analyze(String code, {int maxConcreteTypeSize: 1000}) {
   Uri uri = new Uri.fromComponents(scheme: 'source');
   MockCompiler compiler = new MockCompiler(
@@ skipping 711 matching lines @@
         var bar = new A() != 2;
         var baz = new B() != 2;
         foo; bar; baz;
       }
       """;
   AnalysisResult result = analyze(source);
   result.checkNodeHasType('foo', [result.bool]);
   result.checkNodeHasType('bar', [result.bool]);
   result.checkNodeHasType('baz', []);
   // TODO(polux): the following result should be [:[null, string]:], see
-  // fieldInitialization().
+  // testFieldInitialization().
   result.checkFieldHasType('A', 'witness', [result.string]);
 }
 
 testFieldInitialization() {
   final String source = r"""
     class A {
       var x;
       var y = 1;
     }
     main () {
       new A();
     }
     """;
   AnalysisResult result = analyze(source);
   result.checkFieldHasType('A', 'x', [result.nullType]);
   result.checkFieldHasType('A', 'y', [result.int]);
 }
 
+testLists() {
+  final String source = r"""
+    main() {
+      new List();
+      var l1 = [1.2];
+      var l2 = [];
+      l1['a'] = 42;  // raises an error, so int should not be recorded
+      l1[1] = 'abc';
+      "__dynamic_for_test"[1] = true;
+      var x = l1[1];
+      var y = l2[1];
+      var z = l1['foo'];
+      x; y; z;
+    }""";
+  AnalysisResult result = analyze(source);
+  result.checkNodeHasType('x', [result.double, result.string, result.bool]);
+  result.checkNodeHasType('y', [result.double, result.string, result.bool]);
+  result.checkNodeHasType('z', []);
+}
+
+testListWithCapacity() {
+  final String source = r"""
+    main() {
+      var l = new List(10);
+      var x = l[0];
+      x;
+    }""";
+  AnalysisResult result = analyze(source);
+  result.checkNodeHasType('x', [result.nullType]);
+}
+
+testEmptyList() {
+  final String source = r"""
+    main() {
+      var l = new List();
+      var x = l[0];
+      x;
+    }""";
+  AnalysisResult result = analyze(source);
+  result.checkNodeHasType('x', []);
+}
+
 testSendWithWrongArity() {
   final String source = r"""
     f(x) { }
     class A { g(x) { } }
     main () {
       var x = f();
       var y = f(1, 2);
       var z = new A().g();
       var w = new A().g(1, 2);
       x; y; z; w;
@@ skipping 85 matching lines @@
   testOperators();
   testCompoundOperators1();
   testCompoundOperators2();
   testSetIndexOperator();
   testInequality();
   // testFieldInitialization(); // TODO(polux)
   testSendWithWrongArity();
   testBigTypesWidening1();
   testBigTypesWidening2();
   testDynamicIsAbsorbing();
+  testLists();
+  testListWithCapacity();
+  testEmptyList();
 }