Widen big concrete types to dynamic.

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 73 matching lines @@
   }
 
   /**
    * Finds the [Element] corresponding to [: className#fieldName :].
    */
   Element findField(String className, String fieldName) {
     ClassElement element = compiler.mainApp.find(buildSourceString(className));
     return element.lookupLocalMember(buildSourceString(fieldName));
   }
 
-  static ConcreteType concreteFrom(List<BaseType> baseTypes) {
-    ConcreteType result = new ConcreteType.empty();
+  ConcreteType concreteFrom(List<BaseType> baseTypes) {
+    ConcreteType result = inferrer.emptyConcreteType;
     for (final baseType in baseTypes) {
-      result = result.union(new ConcreteType.singleton(baseType));
+      result = result.union(inferrer.singletonConcreteType(baseType));
     }
+    // We make sure the concrete types expected by the tests don't default to
+    // dynamic because of widening.
+    assert(!result.isUnkown());
     return result;
   }
 
   /**
    * Checks that the inferred type of the node corresponding to the last
    * occurence of [: variable; :] in the program is the concrete type
    * made of [baseTypes].
    */
   void checkNodeHasType(String variable, List<BaseType> baseTypes) {
     return Expect.equals(
@@ skipping 46 matching lines @@
   class Object {}
   class Function {}
   abstract class List {}
   abstract class Map {}
   class Closure {}
   class Null {}
   class Type {}
   class Dynamic_ {}
   bool identical(Object a, Object b) {}''';
 
-AnalysisResult analyze(String code) {
+AnalysisResult analyze(String code, {int maxConcreteTypeSize: 1000}) {
   Uri uri = new Uri.fromComponents(scheme: 'source');
-  MockCompiler compiler = new MockCompiler(coreSource: CORELIB,
-                                           enableConcreteTypeInference: true);
+  MockCompiler compiler = new MockCompiler(
+      coreSource: CORELIB,
+      enableConcreteTypeInference: true,
+      maxConcreteTypeSize: maxConcreteTypeSize);
   compiler.sourceFiles[uri.toString()] = new SourceFile(uri.toString(), code);
   compiler.typesTask.concreteTypesInferrer.testMode = true;
   compiler.runCompiler(uri);
   return new AnalysisResult(compiler);
 }
 
 testDynamicBackDoor() {
   final String source = r"""
     main () {
       var x = "__dynamic_for_test";
@@ skipping 600 matching lines @@
       x; y; z; w;
     }
     """;
   AnalysisResult result = analyze(source);
   result.checkNodeHasType('x', []);
   result.checkNodeHasType('y', []);
   result.checkNodeHasType('z', []);
   result.checkNodeHasType('w', []);
 }
 
+testBigTypesWidening1() {
+  final String source = r"""
+    small() => true ? 1 : 'abc';
+    big() => true ? 1 : (true ? 'abc' : false);
+    main () {
+      var x = small();
+      var y = big();
+      x; y;
+    }
+    """;
+  AnalysisResult result = analyze(source, maxConcreteTypeSize: 2);
+  result.checkNodeHasType('x', [result.int, result.string]);
+  result.checkNodeHasUnknownType('y');
+}
+
+testBigTypesWidening2() {
+  final String source = r"""
+    class A {
+      var x, y;
+      A(this.x, this.y);
+    }
+    main () {
+      var a = new A(1, 1);
+      a.x = 'abc';
+      a.y = 'abc';
+      a.y = true;
+    }
+    """;
+  AnalysisResult result = analyze(source, maxConcreteTypeSize: 2);
+  result.checkFieldHasType('A', 'x', [result.int, result.string]);
+  result.checkFieldHasUknownType('A', 'y');
+}
+
 testDynamicIsAbsorbing() {
   final String source = r"""
     main () {
       var x = 1;
       if (true) {
         x = "__dynamic_for_test";
       } else {
         x = 42;
       }
       x;
@@ skipping 29 matching lines @@
   testReturn();
   // testNoReturn(); // right now we infer the empty type instead of null
   testArithmeticOperators();
   testOperators();
   testCompoundOperators1();
   testCompoundOperators2();
   testSetIndexOperator();
   testInequality();
   // testFieldInitialization(); // TODO(polux)
   testSendWithWrongArity();
+  testBigTypesWidening1();
+  testBigTypesWidening2();
   testDynamicIsAbsorbing();
 }