Define "obvious" types to include formal parameters

This CL changes the definition of what it takes for a expression to have
an "obvious" type such that formal parameters are also included. For
example `(int x) { int y = x; }` will be flagged by the lint
`omit_obvious_local_variable_types` because `x` is considered to have an
obvious type, so `y` shouldn't have a type annotation.

I consider this to be a bug fix.

Note that it is assumed that the declaration of the given formal
parameter justifies the assumption that it does in fact have an obvious
type; if this is not true then the recommended remedy will be to change
the declaration of the formal parameter (by adding a type annotation).
This is the same kind of treatment which is given to to local variables
(where we may add a type annotation, or ensure that it has an
initializing expression whose type is obvious).

Change-Id: Id38c4d7660eb478293671e2b9785f4108a3313de
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/434062
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Erik Ernst <[email protected]>

Author: eernstg

pkg/linter/lib/src/util/obvious_types.dart

@@ -164,8 +164,13 @@ extension ExpressionExtensions on Expression {
       case SimpleIdentifier():
         if (self.isQualified) return false;
         var declaration = self.element;
-        if (declaration is! LocalVariableElement) return false;
-        return self.staticType == declaration.type;
+        if (declaration is LocalVariableElement) {
+          return self.staticType == declaration.type;
+        }
+        if (declaration is FormalParameterElement) {
+          return self.staticType == declaration.type;
+        }
+        return false;
       case InstanceCreationExpression():
         var createdType = self.constructorName.type;
         if (createdType.typeArguments != null) {

pkg/linter/test/rules/omit_obvious_local_variable_types_test.dart

@@ -344,6 +344,30 @@ var b = 'b';
 ''');
   }
 
+  test_parameter() async {
+    await assertDiagnostics(
+      r'''
+void f(int parameter) {
+  int i = parameter;
+}
+''',
+      [lint(26, 3)],
+    );
+  }
+
+  test_parameter_of_literal() async {
+    await assertDiagnostics(
+      r'''
+Function f() {
+  return (int parameter) {
+    int i = parameter;
+  };
+}
+''',
+      [lint(46, 3)],
+    );
+  }
+
   /// Types are considered an important part of the pattern so we
   /// intentionally do not lint on declared variable patterns.
   test_pattern_list_destructured() async {