Add more non-nullability tests

pkg/analyzer/test/src/task/strong/non_null_checker_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.
 
 // These tests are for an experimental feature that treats Dart primitive types
 // (int, bool, double, etc.) as non-nullable. This file is not evidence for an
 // intention to officially support non-nullable primitives in Dart (or general
 // NNBD, for that matter) so don't get too crazy about it.
 
 library analyzer.test.src.task.non_null_primitives.checker_test;
@@ skipping 162 matching lines @@
 
   void test_nonnullable_fields() {
     addFile(defaultNnbdExample);
     // `null` can be passed as an argument to `Point` in default mode.
     addFile(_withError(defaultNnbdExampleMod1, "error:INVALID_ASSIGNMENT"));
     // A nullable expression can be passed as an argument to `Point` in default
     // mode.
     addFile(_withError(defaultNnbdExampleMod2, "error:INVALID_ASSIGNMENT"));
     check(nonnullableTypes: <String>['dart:core,int']);
   }
+
+  void test_method_call() {
+    addFile('''
+int s(int x) {
+  return x + 1;
+}
+
+void main() {
+  s(10);
+  s(/*error:INVALID_ASSIGNMENT*/null);
+}
+''');
+    check(nonnullableTypes: <String>['dart:core,int']);
+  }
+
+  void test_generics() {
+    addFile('''
+class Foo<T> {
+  T x;
+
+  Foo(this.x);
+}
+
+void main() {
+  var f = new Foo<String>("hello");
+  var g = new Foo<int>(10);
+  var h = new Foo<String>(null);
+  var i = new Foo<int>(/*error:INVALID_ASSIGNMENT*/null);
+
+  print(f.x);
+  print(g.x);
+  print(h.x);
+  print(i.x);
+}
+''');
+    addFile('''
+class Foo<T> {
+  T x; // Should be annotated for a runtime check: x = (null as T)
+
+  Foo();
+}
+
+void main() {
+  var f = new Foo<String>();
+  var g = new Foo<int>(); // Should fail at runtime.
+}
+''');
+    check(nonnullableTypes: <String>['dart:core,int']);
+  }
+
+  void test_map() {
+    addFile('''
+class Pair<K, V> {
+  K first;
+  V second;
+
+  Pair(this.first, this.second);
+}
+
+class SlowMap<K, V> {
+  List<Pair<K, V>> array;
+  int arrayLength = 0;
+
+  SlowMap() : array = <Pair<K, V>>[];
+
+  void insert(K key, V value) {
+    array.add(new Pair<K, V>(key, value));
+    ++arrayLength;
+  }
+
+  bool has(K key) {
+    for (int i = 0; i < arrayLength; ++i) {
+      if (array[i].first == key) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  V get(K key) {
+    for (int i = 0; i < arrayLength; ++i) {
+      if (array[i].first == key) {
+        return array[i].second;
+      }
+    }
+    return null;
+    // TODO(stanm): generate explicit cast to V which will produce a runtime
+    // error if V is non-nullable. Optionally, generate a static warning too.
+  }
+}
+
+void main() {
+  var legs = new SlowMap<String, int>();
+  legs.insert("spider", 8);
+  legs.insert("goat", 4);
+  legs.insert("chicken", 2);
+
+  int x = legs.get("goat"); // This should not produce an error.
+  int y = legs.get("sheep"); // TODO(stanm): Runtime error here.
+}
+''');
+    check(nonnullableTypes: <String>['dart:core,int']);
+  }
 }
 
 String _withError(String file, String error) {
   return ("" + file).replaceFirst("boom", error);
 }