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 30 matching lines @@
 class AnalysisResult {
   MockCompiler compiler;
   ConcreteTypesInferrer inferrer;
   Node ast;
 
   BaseType int;
   BaseType double;
   BaseType num;
   BaseType bool;
   BaseType string;
-  BaseType list;
+  BaseType jsArray;
   BaseType map;
   BaseType nullType;
 
   AnalysisResult(MockCompiler compiler) : this.compiler = compiler {
     inferrer = compiler.typesTask.concreteTypesInferrer;
     int = inferrer.baseTypes.intBaseType;
     double = inferrer.baseTypes.doubleBaseType;
     num = inferrer.baseTypes.numBaseType;
     bool = inferrer.baseTypes.boolBaseType;
     string = inferrer.baseTypes.stringBaseType;
-    list = inferrer.baseTypes.listBaseType;
+    jsArray = inferrer.baseTypes.jsArrayBaseType;
     map = inferrer.baseTypes.mapBaseType;
     nullType = new NullBaseType();
     Element mainElement = compiler.mainApp.find(buildSourceString('main'));
     ast = mainElement.parseNode(compiler);
   }
 
   BaseType base(String className) {
     final source = buildSourceString(className);
     return new ClassBaseType(compiler.mainApp.find(source));
   }
@@ skipping 78 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 499 matching lines @@
         var x;
         A(this.x);
       }
       main() {
         var x = [];
         var y = [1, "a", null, new A(42)];
         x; y;
       }
       """;
   AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.list]);
-  result.checkNodeHasType('y', [result.list]);
+  result.checkNodeHasType('x', [result.jsArray]);
+  result.checkNodeHasType('y', [result.jsArray]);
   result.checkFieldHasType('A', 'x', [result.int]);
 }
 
 testMapLiterals() {
   final String source = r"""
       class A {
         var x;
         A(this.x);
       }
       main() {
@@ skipping 190 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() {

[karlklose, 2013/01/23 13:16:55]

Can you add a test with elements like in testLists AND capacity?

+  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();
 }