Track implicit vs explicit types in summaries.

pkg/analyzer/test/src/summary/summary_test.dart

 // Copyright (c) 2015, 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.src.summary.summary_test;
 
-import 'dart:typed_data';
-
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/builder.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart'
     as summarize_elements;
 import 'package:unittest/unittest.dart';
 
@@ skipping 734 matching lines @@
     UnlinkedClass cls = serializeClassText('class C<T> {}');
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].bound, isNull);
   }
 
   test_constructor() {
     UnlinkedExecutable executable =
         findExecutable('', cls: serializeClassText('class C { C(); }'));
     expect(executable.kind, UnlinkedExecutableKind.constructor);
+    expect(executable.hasImplicitReturnType, isFalse);
   }
 
   test_constructor_anonymous() {
     UnlinkedExecutable executable =
         findExecutable('', cls: serializeClassText('class C { C(); }'));
     expect(executable.name, isEmpty);
   }
 
   test_constructor_const() {
     UnlinkedExecutable executable =
@@ skipping 39 matching lines @@
     UnlinkedExecutable executable = findExecutable('',
         cls: serializeClassText('class C { C(int this.x()); Function x; }'));
     UnlinkedParam parameter = executable.parameters[0];
     checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_constructor_initializing_formal_function_typed_implicit_return_type() {
     UnlinkedExecutable executable = findExecutable('',
         cls: serializeClassText('class C { C(this.x()); Function x; }'));
     UnlinkedParam parameter = executable.parameters[0];
+    // Since the parameter is function-typed it is considered to have an
+    // explicit type, even though that explicit type itself has an implicit
+    // return type.
+    expect(parameter.hasImplicitType, isFalse);
     checkDynamicTypeRef(parameter.type);
   }
 
   test_constructor_initializing_formal_function_typed_no_prameters() {
     UnlinkedExecutable executable = findExecutable('',
         cls: serializeClassText('class C { C(this.x()); final x; }'));
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, isEmpty);
   }
 
@@ skipping 13 matching lines @@
     expect(parameter.parameters[1].name, 'b');
   }
 
   test_constructor_initializing_formal_implicit_type() {
     // Note: the implicit type of an initializing formal is the type of the
     // field.
     UnlinkedExecutable executable = findExecutable('',
         cls: serializeClassText('class C { C(this.x); int x; }'));
     UnlinkedParam parameter = executable.parameters[0];
     checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
+    expect(parameter.hasImplicitType, isTrue);
   }
 
   test_constructor_initializing_formal_name() {
     UnlinkedExecutable executable = findExecutable('',
         cls: serializeClassText('class C { C(this.x); final x; }'));
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.name, 'x');
   }
 
   test_constructor_initializing_formal_named() {
@@ skipping 193 matching lines @@
   test_executable_concrete() {
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f() {} }').executables[0];
     expect(executable.isAbstract, isFalse);
   }
 
   test_executable_function() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.unit, 0);
+    expect(executable.hasImplicitReturnType, isTrue);
+    checkDynamicTypeRef(executable.returnType);
+  }
+
+  test_executable_function_explicit_return() {
+    UnlinkedExecutable executable =
+        serializeExecutableText('dynamic f() => null;');
+    expect(executable.hasImplicitReturnType, isFalse);
+    checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_getter() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
     expect(executable.kind, UnlinkedExecutableKind.getter);
+    expect(executable.hasImplicitReturnType, isFalse);
     expect(findVariable('f'), isNull);
     expect(findExecutable('f='), isNull);
   }
 
   test_executable_getter_type() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_getter_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('get f => 1;');
     checkDynamicTypeRef(executable.returnType);
+    expect(executable.hasImplicitReturnType, isTrue);
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_member_function() {
     UnlinkedExecutable executable =
         findExecutable('f', cls: serializeClassText('class C { f() {} }'));
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
+    expect(executable.hasImplicitReturnType, isTrue);
+  }
+
+  test_executable_member_function_explicit_return() {
+    UnlinkedExecutable executable = findExecutable('f',
+        cls: serializeClassText('class C { dynamic f() => null; }'));
+    expect(executable.hasImplicitReturnType, isFalse);
   }
 
   test_executable_member_getter() {
     UnlinkedClass cls = serializeClassText('class C { int get f => 1; }');
     UnlinkedExecutable executable =
         findExecutable('f', cls: cls, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.getter);
+    expect(executable.hasImplicitReturnType, isFalse);
     expect(findVariable('f', cls: cls), isNull);
     expect(findExecutable('f=', cls: cls), isNull);
   }
 
   test_executable_member_setter() {
     UnlinkedClass cls = serializeClassText('class C { void set f(value) {} }');
     UnlinkedExecutable executable =
         findExecutable('f=', cls: cls, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.setter);
+    // For setters, hasImplicitReturnType is always false.
+    expect(executable.hasImplicitReturnType, isFalse);
     expect(findVariable('f', cls: cls), isNull);
     expect(findExecutable('f', cls: cls), isNull);
   }
 
+  test_executable_member_setter_implicit_return() {
+    UnlinkedClass cls = serializeClassText('class C { set f(value) {} }');
+    UnlinkedExecutable executable =
+        findExecutable('f=', cls: cls, failIfAbsent: true);
+    expect(executable.hasImplicitReturnType, isFalse);
+    checkDynamicTypeRef(executable.returnType);
+  }
+
   test_executable_name() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.name, 'f');
   }
 
   test_executable_no_flags() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.isAbstract, isFalse);
     expect(executable.isConst, isFalse);
     expect(executable.isFactory, isFalse);
     expect(executable.isStatic, isFalse);
   }
 
   test_executable_non_static() {
     UnlinkedExecutable executable =
         serializeClassText('class C { f() {} }').executables[0];
     expect(executable.isStatic, isFalse);
   }
 
   test_executable_non_static_top_level() {
     // Top level executables are considered non-static.
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.isStatic, isFalse);
   }
 
   test_executable_param_function_typed() {
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     expect(executable.parameters[0].isFunctionTyped, isTrue);
+    // Since the parameter is function-typed it is considered to have an
+    // explicit type, even though that explicit type itself has an implicit
+    // return type.
+    expect(executable.parameters[0].hasImplicitType, isFalse);
+  }
+
+  test_executable_param_function_typed_explicit_return_type() {
+    UnlinkedExecutable executable =
+        serializeExecutableText('f(dynamic g()) {}');
+    expect(executable.parameters[0].hasImplicitType, isFalse);
   }
 
   test_executable_param_function_typed_param() {
     UnlinkedExecutable executable = serializeExecutableText('f(g(x)) {}');
     expect(executable.parameters[0].parameters, hasLength(1));
   }
 
   test_executable_param_function_typed_param_none() {
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     expect(executable.parameters[0].parameters, isEmpty);
@@ skipping 59 matching lines @@
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_param_order() {
     UnlinkedExecutable executable = serializeExecutableText('f(x, y) {}');
     expect(executable.parameters, hasLength(2));
     expect(executable.parameters[0].name, 'x');
     expect(executable.parameters[1].name, 'y');
   }
 
+  test_executable_param_type_explicit() {
+    UnlinkedExecutable executable = serializeExecutableText('f(dynamic x) {}');
+    checkDynamicTypeRef(executable.parameters[0].type);
+    expect(executable.parameters[0].hasImplicitType, isFalse);
+  }
+
   test_executable_param_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
     checkDynamicTypeRef(executable.parameters[0].type);
+    expect(executable.parameters[0].hasImplicitType, isTrue);
   }
 
   test_executable_return_type() {
     UnlinkedExecutable executable = serializeExecutableText('int f() => 1;');
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
+    expect(executable.hasImplicitReturnType, isFalse);
   }
 
   test_executable_return_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     checkDynamicTypeRef(executable.returnType);
+    expect(executable.hasImplicitReturnType, isTrue);
   }
 
   test_executable_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('void f() {}');
     expect(executable.returnType, isNull);
   }
 
   test_executable_setter() {
     UnlinkedExecutable executable =
         serializeExecutableText('void set f(value) {}', 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
+    expect(executable.hasImplicitReturnType, isFalse);
     expect(findVariable('f'), isNull);
     expect(findExecutable('f'), isNull);
   }
 
+  test_executable_setter_implicit_return() {
+    UnlinkedExecutable executable =
+        serializeExecutableText('set f(value) {}', 'f=');
+    // For setters, hasImplicitReturnType is always false.
+    expect(executable.hasImplicitReturnType, isFalse);
+    checkDynamicTypeRef(executable.returnType);
+  }
+
   test_executable_setter_type() {
     UnlinkedExecutable executable =
         serializeExecutableText('void set f(int value) {}', 'f=');
     expect(executable.returnType, isNull);
     expect(executable.parameters, hasLength(1));
     expect(executable.parameters[0].name, 'value');
     checkTypeRef(
         executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
   }
 
@@ skipping 528 matching lines @@
     expect(findExecutable('i'), isNull);
     expect(findExecutable('i='), isNull);
   }
 
   test_variable_const() {
     UnlinkedVariable variable =
         serializeVariableText('const int i = 0;', variableName: 'i');
     expect(variable.isConst, isTrue);
   }
 
+  test_variable_explicit_dynamic() {
+    UnlinkedVariable variable = serializeVariableText('dynamic v;');
+    checkDynamicTypeRef(variable.type);
+    expect(variable.hasImplicitType, isFalse);
+  }
+
   test_variable_final_top_level() {
     UnlinkedVariable variable =
         serializeVariableText('final int i = 0;', variableName: 'i');
     expect(variable.isFinal, isTrue);
   }
 
   test_variable_implicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('var v;');
     checkDynamicTypeRef(variable.type);
+    expect(variable.hasImplicitType, isTrue);
   }
 
   test_variable_name() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     expect(variable.name, 'i');
     expect(variable.unit, 0);
   }
 
   test_variable_no_flags() {
@@ skipping 34 matching lines @@
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 }