Migration: add support for variable and field type inference.

stereotype441 · commit-bot@chromium.org · commit a200980da05e · 2019-06-30T16:39:17.000Z
Change-Id: Iae66992d4f9734438776af34b68aabf20f5c15d0 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/107517 Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -849,14 +849,26 @@ $stackTrace''');
   }
 
   @override
-  DecoratedType visitVariableDeclaration(VariableDeclaration node) {
-    var destinationType = getOrComputeElementType(node.declaredElement);
-    var initializer = node.initializer;
-    if (initializer == null) {
-      // TODO(paulberry)
-      _unimplemented(node, 'Variable declaration with no initializer');
-    } else {
-      _handleAssignment(initializer, destinationType);
+  DecoratedType visitVariableDeclarationList(VariableDeclarationList node) {
+    node.metadata.accept(this);
+    var typeAnnotation = node.type;
+    for (var variable in node.variables) {
+      variable.metadata.accept(this);
+      var initializer = variable.initializer;
+      if (initializer != null) {
+        var destinationType = getOrComputeElementType(variable.declaredElement);
+        if (typeAnnotation == null) {
+          var initializerType = initializer.accept(this);
+          if (initializerType == null) {
+            throw StateError('No type computed for ${initializer.runtimeType} '
+                '(${initializer.toSource()}) offset=${initializer.offset}');
+          }
+          _unionDecoratedTypes(initializerType, destinationType,
+              InitializerInferenceOrigin(_source, variable.name.offset));
+        } else {
+          _handleAssignment(initializer, destinationType);
+        }
+      }
     }
     return null;
   }
diff --git a/pkg/nnbd_migration/lib/src/edge_origin.dart b/pkg/nnbd_migration/lib/src/edge_origin.dart
@@ -62,6 +62,11 @@ class InheritanceOrigin extends EdgeOriginWithLocation {
   InheritanceOrigin(Source source, int offset) : super(source, offset);
 }
 
+/// Edge origin resulting from a type that is inferred from its initializer.
+class InitializerInferenceOrigin extends EdgeOriginWithLocation {
+  InitializerInferenceOrigin(Source source, int offset) : super(source, offset);
+}
+
 /// Edge origin resulting from a class that is instantiated to bounds.
 ///
 /// For example, in the following code snippet:
diff --git a/pkg/nnbd_migration/lib/src/node_builder.dart b/pkg/nnbd_migration/lib/src/node_builder.dart
@@ -344,10 +344,13 @@ $stackTrace''');
   @override
   DecoratedType visitVariableDeclarationList(VariableDeclarationList node) {
     node.metadata.accept(this);
-    var type = decorateType(node.type, node);
+    var typeAnnotation = node.type;
+    var type = typeAnnotation?.accept(this);
     for (var variable in node.variables) {
       variable.metadata.accept(this);
-      _variables.recordDecoratedElementType(variable.declaredElement, type);
+      var declaredElement = variable.declaredElement;
+      _variables.recordDecoratedElementType(declaredElement,
+          type ?? DecoratedType.forImplicitType(declaredElement.type, _graph));
       variable.initializer?.accept(this);
     }
     return null;
diff --git a/pkg/nnbd_migration/test/api_test.dart b/pkg/nnbd_migration/test/api_test.dart
@@ -813,6 +813,31 @@ int f(int i) {
     await _checkSingleFileChanges(content, expected);
   }
 
+  test_field_type_inferred() async {
+    var content = '''
+int f() => null;
+class C {
+  var x = 1;
+  void g() {
+    x = f();
+  }
+}
+''';
+    // The type of x is inferred from its initializer, so it is non-nullable,
+    // even though we try to assign a nullable value to it.  So a null check
+    // must be added.
+    var expected = '''
+int? f() => null;
+class C {
+  var x = 1;
+  void g() {
+    x = f()!;
+  }
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   test_genericType_noTypeArguments() async {
     var content = '''
 void f(C c) {}
@@ -1042,6 +1067,27 @@ class C {
     await _checkSingleFileChanges(content, expected);
   }
 
+  test_localVariable_type_inferred() async {
+    var content = '''
+int f() => null;
+void main() {
+  var x = 1;
+  x = f();
+}
+''';
+    // The type of x is inferred from its initializer, so it is non-nullable,
+    // even though we try to assign a nullable value to it.  So a null check
+    // must be added.
+    var expected = '''
+int? f() => null;
+void main() {
+  var x = 1;
+  x = f()!;
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   test_named_parameter_no_default_unused() async {
     var content = '''
 void f({String s}) {}
@@ -1613,6 +1659,27 @@ Object? g() => f();
     await _checkSingleFileChanges(content, expected);
   }
 
+  test_topLevelVariable_type_inferred() async {
+    var content = '''
+int f() => null;
+var x = 1;
+void main() {
+  x = f();
+}
+''';
+    // The type of x is inferred from its initializer, so it is non-nullable,
+    // even though we try to assign a nullable value to it.  So a null check
+    // must be added.
+    var expected = '''
+int? f() => null;
+var x = 1;
+void main() {
+  x = f()!;
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   test_two_files() async {
     var root = '/home/test/lib';
     var path1 = convertPath('$root/file1.dart');
diff --git a/pkg/nnbd_migration/test/edge_builder_test.dart b/pkg/nnbd_migration/test/edge_builder_test.dart
@@ -799,6 +799,18 @@ double f() {
     assertNoUpstreamNullability(decoratedTypeAnnotation('double').node);
   }
 
+  test_field_type_inferred() async {
+    await analyze('''
+int f() => 1;
+class C {
+  var x = f();
+}
+''');
+    var xType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    assertUnion(xType.node, decoratedTypeAnnotation('int').node);
+  }
+
   test_functionDeclaration_expression_body() async {
     await analyze('''
 int/*1*/ f(int/*2*/ i) => i/*3*/;
@@ -1310,6 +1322,18 @@ List<String> f() {
     assertEdge(always, decoratedTypeAnnotation('String>[').node, hard: false);
   }
 
+  test_localVariable_type_inferred() async {
+    await analyze('''
+int f() => 1;
+main() {
+  var x = f();
+}
+''');
+    var xType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    assertUnion(xType.node, decoratedTypeAnnotation('int').node);
+  }
+
   test_method_parameterType_inferred() async {
     await analyze('''
 class B {
@@ -2329,6 +2353,16 @@ double get myPi => pi;
     assertEdge(never, myPiType.node, hard: false);
   }
 
+  test_topLevelVariable_type_inferred() async {
+    await analyze('''
+int f() => 1;
+var x = f();
+''');
+    var xType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    assertUnion(xType.node, decoratedTypeAnnotation('int').node);
+  }
+
   test_type_argument_explicit_bound() async {
     await analyze('''
 class C<T extends Object> {}
diff --git a/pkg/nnbd_migration/test/node_builder_test.dart b/pkg/nnbd_migration/test/node_builder_test.dart
@@ -367,6 +367,40 @@ dynamic f() {}
     assertEdge(always, decoratedType.node, hard: false);
   }
 
+  test_field_type_implicit_dynamic() async {
+    await analyze('''
+class C {
+  var x;
+}
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, same(always));
+  }
+
+  test_field_type_inferred() async {
+    await analyze('''
+class C {
+  var x = 1;
+}
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
+  }
+
+  test_field_type_inferred_dynamic() async {
+    await analyze('''
+dynamic f() {}
+class C {
+  var x = f();
+}
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, same(always));
+  }
+
   test_field_type_simple() async {
     await analyze('''
 class C {
@@ -555,6 +589,40 @@ void f(List<int> x) {}
     expect(decoratedIntType.node, isNot(never));
   }
 
+  test_localVariable_type_implicit_dynamic() async {
+    await analyze('''
+main() {
+  var x;
+}
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, same(always));
+  }
+
+  test_localVariable_type_inferred() async {
+    await analyze('''
+main() {
+  var x = 1;
+}
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
+  }
+
+  test_localVariable_type_inferred_dynamic() async {
+    await analyze('''
+dynamic f() {}
+main() {
+  var x = f();
+}
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, same(always));
+  }
+
   test_method_parameterType_implicit_dynamic() async {
     await analyze('''
 class C {
@@ -754,6 +822,34 @@ int f() => 0;
     expect(decoratedType.node, isNot(never));
   }
 
+  test_topLevelVariable_type_implicit_dynamic() async {
+    await analyze('''
+var x;
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, same(always));
+  }
+
+  test_topLevelVariable_type_inferred() async {
+    await analyze('''
+var x = 1;
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
+  }
+
+  test_topLevelVariable_type_inferred_dynamic() async {
+    await analyze('''
+dynamic f() {}
+var x = f();
+''');
+    var decoratedType =
+        variables.decoratedElementType(findNode.simple('x').staticElement);
+    expect(decoratedType.node, same(always));
+  }
+
   test_type_comment_bang() async {
     await analyze('''
 void f(int/*!*/ i) {}
