infer null from context, this avoids bottom being introduced

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, 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.
 
 library analyzer.test.generated.strong_mode_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 2028 matching lines @@
     verify([source]);
   }
 
   void test_ternaryOperator_null_left() {
     String code = r'''
 main() {
   var foo = (true) ? null : 3;
 }
 ''';
     resolveTestUnit(code);
-    expectInitializerType('foo', 'int', isNull);
+    expectInitializerType('foo', 'dynamic', isNull);

[Jennifer Messerly, 2016/08/04 13:10:16]

This case is really unfortunate and makes me doubtful of the merits of this CL.
To some extent, it may be avoidable with null aware ops, but not always.

I suppose we could add some logic for ternary ops when one of the branches is
null? Or is that just papering over the problem.

[Leaf, 2016/08/04 23:52:55]

Yeah, I think this will cause problems.  I think it will show up in other places
that LUB is used as well.  I think there are ways we could tackle this, but not
sure it's worth it right now.

[Jennifer Messerly, 2016/08/05 13:46:36]

Yeah, definitely doesn't seem right at the moment.

Another thought here is define a type for `null` (maybe Null?), and have it be
subtype of other nullable types. essentially LUB(Null, T) becomes T in our
current system (and could be extended once we have non-nullable types).

But that's getting a little out of the scope of this change, so going to close
this one :)

   }
 
   void test_ternaryOperator_null_right() {
     String code = r'''
 main() {
   var foo = (true) ? 3 : null;
 }
 ''';
     resolveTestUnit(code);
-    expectInitializerType('foo', 'int', isNull);
+    expectInitializerType('foo', 'dynamic', isNull);
   }
 }
 
 @reflectiveTest
 class StrongModeTypePropagationTest extends ResolverTestCase {
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
@@ skipping 238 matching lines @@
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     assertPropagatedAssignedType(code, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }