Integrate recent parameter override logic

pkg/analyzer/test/src/task/strong_mode_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 test.src.task.strong_mode_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/strong_mode.dart';
@@ skipping 88 matching lines @@
     PropertyAccessorElement getterC = classC.getGetter(fieldName);
     expect(fieldC.type.isDynamic, isTrue);
     expect(getterC.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(fieldC.type.isDynamic, isTrue);
     expect(getterC.returnType.isDynamic, isTrue);
   }
 
+  void test_inferCompilationUnit_field_multiple_different_generic() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String fieldName = 'f';
+    CompilationUnitElement unit = resolve('''
+class A<E> {
+  E $fieldName;
+}
+class B<E> {
+  E $fieldName;
+}
+class C implements A<int>, B<double> {
+  var $fieldName;
+}
+''');
+    ClassElement classC = unit.getType('C');
+    FieldElement fieldC = classC.getField(fieldName);
+    PropertyAccessorElement getterC = classC.getGetter(fieldName);
+    expect(fieldC.type.isDynamic, isTrue);
+    expect(getterC.returnType.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(fieldC.type.isDynamic, isTrue);
+    expect(getterC.returnType.isDynamic, isTrue);
+  }
+
   void test_inferCompilationUnit_field_multiple_dynamic() {
     InstanceMemberInferrer inferrer = createInferrer;
     String fieldName = 'f';
     CompilationUnitElement unit = resolve('''
 class A {
   int $fieldName;
 }
 class B {
   var $fieldName;
 }
@@ skipping 128 matching lines @@
     PropertyAccessorElement getterB = classB.getGetter(fieldName);
     expect(fieldB.type.isDynamic, isTrue);
     expect(getterB.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(fieldB.type, fieldA.type);
     expect(getterB.returnType, getterA.returnType);
   }
 
+  void test_inferCompilationUnit_field_single_generic() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String fieldName = 'f';
+    CompilationUnitElement unit = resolve('''
+class A<E> {
+  E $fieldName;
+}
+class B<E> extends A<E> {
+  var $fieldName;
+}
+''');
+    ClassElement classB = unit.getType('B');
+    DartType typeBE = classB.typeParameters[0].type;
+    FieldElement fieldB = classB.getField(fieldName);
+    PropertyAccessorElement getterB = classB.getGetter(fieldName);
+    expect(fieldB.type.isDynamic, isTrue);
+    expect(getterB.returnType.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(fieldB.type, typeBE);
+    expect(getterB.returnType, typeBE);
+  }
+
   void test_inferCompilationUnit_field_single_inconsistentAccessors() {
     InstanceMemberInferrer inferrer = createInferrer;
     String fieldName = 'f';
     CompilationUnitElement unit = resolve('''
 class A {
   int get $fieldName => 0;
   set $fieldName(String value) {}
 }
 class B extends A {
   var $fieldName;
@@ skipping 137 matching lines @@
     PropertyAccessorElement getterB = classB.getGetter(getterName);
     expect(fieldB.type.isDynamic, isTrue);
     expect(getterB.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(fieldB.type, fieldA.type);
     expect(getterB.returnType, getterA.returnType);
   }
 
+  void test_inferCompilationUnit_getter_single_generic() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String getterName = 'g';
+    CompilationUnitElement unit = resolve('''
+class A<E> {
+  E get $getterName => 0;
+}
+class B<E> extends A<E> {
+  get $getterName => 0;
+}
+''');
+    ClassElement classB = unit.getType('B');
+    DartType typeBE = classB.typeParameters[0].type;
+    FieldElement fieldB = classB.getField(getterName);
+    PropertyAccessorElement getterB = classB.getGetter(getterName);
+    expect(fieldB.type.isDynamic, isTrue);
+    expect(getterB.returnType.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(fieldB.type, typeBE);
+    expect(getterB.returnType, typeBE);
+  }
+
   void test_inferCompilationUnit_getter_single_inconsistentAccessors() {
     InstanceMemberInferrer inferrer = createInferrer;
     String getterName = 'g';
     CompilationUnitElement unit = resolve('''
 class A {
   int get $getterName => 0;
   set $getterName(String value) {}
 }
 class B extends A {
   var get $getterName => 1;
@@ skipping 14 matching lines @@
   void test_inferCompilationUnit_invalid_inheritanceCycle() {
     InstanceMemberInferrer inferrer = createInferrer;
     CompilationUnitElement unit = resolve('''
 class A extends C {}
 class B extends A {}
 class C extends B {}
 ''');
     inferrer.inferCompilationUnit(unit);
   }
 
-  void test_inferCompilationUnit_method_multiple_different() {
+  void test_inferCompilationUnit_method_parameter_multiple_different() {
     InstanceMemberInferrer inferrer = createInferrer;
     String methodName = 'm';
     CompilationUnitElement unit = resolve('''
+class A {
+  $methodName(int p) => 0;
+}
+class B {
+  $methodName(double p) => 0;
+}
+class C implements A, B {
+  $methodName(p) => 0;
+}
+''');
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    ParameterElement parameterC = methodC.parameters[0];
+    expect(parameterC.type.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(parameterC.type.isDynamic, isTrue);
+  }
+
+  void test_inferCompilationUnit_method_parameter_multiple_named_different() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
+class A {
+  $methodName({int p}) => 0;
+}
+class B {
+  $methodName({int q}) => 0;
+}
+class C implements A, B {
+  $methodName({p}) => 0;
+}
+''');
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    ParameterElement parameterC = methodC.parameters[0];
+    expect(parameterC.type.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(parameterC.type.isDynamic, isTrue);
+  }
+
+  void test_inferCompilationUnit_method_parameter_multiple_named_same() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
+class A {
+  $methodName({int p}) => 0;
+}
+class B {
+  $methodName({int p}) => 0;
+}
+class C implements A, B {
+  $methodName({p}) => 0;
+}
+''');
+    ClassElement classA = unit.getType('A');
+    MethodElement methodA = classA.getMethod(methodName);
+    ParameterElement parameterA = methodA.parameters[0];
+    DartType expectedType = parameterA.type;
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    ParameterElement parameterC = methodC.parameters[0];
+    expect(parameterC.type.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(parameterC.type, expectedType);
+  }
+
+  void test_inferCompilationUnit_method_parameter_multiple_namedAndRequired() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
+class A {
+  $methodName({int p}) => 0;
+}
+class B {
+  $methodName(int p) => 0;
+}
+class C implements A, B {
+  $methodName(p) => 0;
+}
+''');
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    ParameterElement parameterC = methodC.parameters[0];
+    expect(parameterC.type.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(parameterC.type.isDynamic, isTrue);
+  }
+
+  void test_inferCompilationUnit_method_parameter_multiple_optionalAndRequired() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
+class A {
+  $methodName(int p) => 0;
+}
+class B {
+  $methodName([int p]) => 0;
+}
+class C implements A, B {
+  $methodName(p) => 0;
+}
+''');
+    ClassElement classA = unit.getType('A');
+    MethodElement methodA = classA.getMethod(methodName);
+    ParameterElement parameterA = methodA.parameters[0];
+    DartType expectedType = parameterA.type;
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    ParameterElement parameterC = methodC.parameters[0];
+    expect(parameterC.type.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(parameterC.type, expectedType);
+  }
+
+  void test_inferCompilationUnit_method_parameter_single_generic() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
+class A<E> {
+  $methodName(E p) => 0;
+}
+class C<E> implements A<E> {
+  $methodName(p) => 0;
+}
+''');
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    ParameterElement parameterC = methodC.parameters[0];
+    expect(parameterC.type.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(parameterC.type, classC.typeParameters[0].type);
+  }
+
+  void test_inferCompilationUnit_method_return_multiple_different() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
 class A {
   int $methodName() => 0;
 }
 class B {
   double $methodName() => 0.0;
 }
 class C implements A, B {
   $methodName() => 0;
 }
 ''');
     ClassElement classC = unit.getType('C');
     MethodElement methodC = classC.getMethod(methodName);
     expect(methodC.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(methodC.returnType.isDynamic, isTrue);
   }
 
-  void test_inferCompilationUnit_method_multiple_dynamic() {
+  void test_inferCompilationUnit_method_return_multiple_different_generic() {
     InstanceMemberInferrer inferrer = createInferrer;
     String methodName = 'm';
     CompilationUnitElement unit = resolve('''
+class A<E> {
+  E $methodName() => null;
+}
+class B<E> {
+  E $methodName() => null;
+}
+class C implements A<int>, B<double> {
+  $methodName() => null;
+}
+''');
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    expect(methodC.returnType.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(methodC.returnType.isDynamic, isTrue);
+  }
+
+  void test_inferCompilationUnit_method_return_multiple_dynamic() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
 class A {
   int $methodName() => 0;
 }
 class B {
   $methodName() => 0;
 }
 class C implements A, B {
   $methodName() => 0;
 }
 ''');
     ClassElement classC = unit.getType('C');
     MethodElement methodC = classC.getMethod(methodName);
     expect(methodC.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(methodC.returnType.isDynamic, isTrue);
   }
 
-  void test_inferCompilationUnit_method_multiple_same_nonVoid() {
+  void test_inferCompilationUnit_method_return_multiple_same_generic() {
     InstanceMemberInferrer inferrer = createInferrer;
     String methodName = 'm';
     CompilationUnitElement unit = resolve('''
+class A<E> {
+  E $methodName() => 0;
+}
+class B<E> {
+  E $methodName() => 0;
+}
+class C<E> implements A<E>, B<E> {
+  $methodName() => 0;
+}
+''');
+    ClassElement classC = unit.getType('C');
+    MethodElement methodC = classC.getMethod(methodName);
+    expect(methodC.returnType.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(methodC.returnType, classC.typeParameters[0].type);
+  }
+
+  void test_inferCompilationUnit_method_return_multiple_same_nonVoid() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
 class A {
   int $methodName() => 0;
 }
 class B {
-  int $methodName() => 0.0;
+  int $methodName() => 0;
 }
 class C implements A, B {
   $methodName() => 0;
 }
 ''');
     ClassElement classA = unit.getType('A');
     MethodElement methodA = classA.getMethod(methodName);
     DartType expectedType = methodA.returnType;
     ClassElement classC = unit.getType('C');
     MethodElement methodC = classC.getMethod(methodName);
     expect(methodC.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(methodC.returnType, expectedType);
   }
 
-  void test_inferCompilationUnit_method_multiple_same_void() {
+  void test_inferCompilationUnit_method_return_multiple_same_void() {
     InstanceMemberInferrer inferrer = createInferrer;
     String methodName = 'm';
     CompilationUnitElement unit = resolve('''
 class A {
   void $methodName() {};
 }
 class B {
   void $methodName() {};
 }
 class C implements A, B {
   $methodName() {};
 }
 ''');
     ClassElement classA = unit.getType('A');
     MethodElement methodA = classA.getMethod(methodName);
     DartType expectedType = methodA.returnType;
     ClassElement classC = unit.getType('C');
     MethodElement methodC = classC.getMethod(methodName);
     expect(methodC.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(methodC.returnType, expectedType);
   }
 
-  void test_inferCompilationUnit_method_multiple_void() {
+  void test_inferCompilationUnit_method_return_multiple_void() {
     InstanceMemberInferrer inferrer = createInferrer;
     String methodName = 'm';
     CompilationUnitElement unit = resolve('''
 class A {
   int $methodName() => 0;
 }
 class B {
   void $methodName() => 0;
 }
 class C implements A, B {
   $methodName() => 0;
 }
 ''');
     ClassElement classC = unit.getType('C');
     MethodElement methodC = classC.getMethod(methodName);
     expect(methodC.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(methodC.returnType.isDynamic, isTrue);
   }
 
-  void test_inferCompilationUnit_method_single() {
+  void test_inferCompilationUnit_method_return_single() {
     InstanceMemberInferrer inferrer = createInferrer;
     String methodName = 'm';
     CompilationUnitElement unit = resolve('''
 class A {
   int $methodName() => 0;
 }
 class B extends A {
   $methodName() => 0;
 }
 ''');
     ClassElement classA = unit.getType('A');
     MethodElement methodA = classA.getMethod(methodName);
     ClassElement classB = unit.getType('B');
     MethodElement methodB = classB.getMethod(methodName);
     expect(methodB.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(methodB.returnType, methodA.returnType);
   }
+
+  void test_inferCompilationUnit_method_return_single_generic() {
+    InstanceMemberInferrer inferrer = createInferrer;
+    String methodName = 'm';
+    CompilationUnitElement unit = resolve('''
+class A<E> {
+  E $methodName() => 0;
 }
+class B<E> extends A<E> {
+  $methodName() => 0;
+}
+''');
+    ClassElement classB = unit.getType('B');
+    MethodElement methodB = classB.getMethod(methodName);
+    expect(methodB.returnType.isDynamic, isTrue);
+
+    inferrer.inferCompilationUnit(unit);
+
+    expect(methodB.returnType, classB.typeParameters[0].type);
+  }
+}