Element model support for covariant

pkg/analyzer/test/src/summary/resynthesize_common.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.serialization.elements_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 908 matching lines @@
       if (original.field == null) {
         expect(resynthesized.field, isNull, reason: '$desc field');
       } else {
         expect(resynthesized.field, isNotNull, reason: '$desc field');
         compareFieldElements(
             resynthesized.field, original.field, '$desc field');
       }
     }
     expect(resynthesized.defaultValueCode, original.defaultValueCode,
         reason: desc);
-    expect(resynthesized.isCovariant, original.isCovariant, reason: desc);
+    expect((resynthesized as ParameterElementImpl).isExplicitlyCovariant,
+        (original as ParameterElementImpl).isExplicitlyCovariant,
+        reason: desc);
+    expect(resynthesized.isCovariant, original.isCovariant,
+        reason: '$desc isCovariant');

[scheglov, 2017/01/20 00:30:18]

We already cast to Impl(s) below.

[Brian Wilkerson, 2017/01/20 15:59:07]

Ok. I moved the first test after the casts and removed the redundant cast.

     ParameterElementImpl resynthesizedActual =
         getActualElement(resynthesized, desc);
     ParameterElementImpl originalActual = getActualElement(original, desc);
     compareFunctionElements(
         resynthesizedActual.initializer, originalActual.initializer, desc);
   }
 
   void comparePrefixElements(PrefixElementImpl resynthesized,
       PrefixElementImpl original, String desc) {
     compareElements(resynthesized, original, desc);
@@ skipping 258 matching lines @@
     } else if (modifier == Modifier.ASYNCHRONOUS) {
       if (element is ExecutableElement) {
         return element.isAsynchronous;
       }
       return false;
     } else if (modifier == Modifier.CONST) {
       if (element is VariableElement) {
         return element.isConst;
       }
       return false;
+    } else if (modifier == Modifier.COVARIANT) {
+      if (element is ParameterElementImpl) {
+        return element.isExplicitlyCovariant;
+      }
+      return false;
     } else if (modifier == Modifier.DEFERRED) {
       if (element is ImportElement) {
         return element.isDeferred;
       }
       return false;
     } else if (modifier == Modifier.ENUM) {
       if (element is ClassElement) {
         return element.isEnum;
       }
       return false;
@@ skipping 1597 matching lines @@
   final x;
   C() : x = new D();
 }
 class D {
   final x;
   D() : x = new C();
 }
 ''');
   }
 
-  void test_covariant_parameter() {
-    // Note: due to dartbug.com/27393, the keyword "checked" is identified by
-    // its presence in a library called "meta".  If that bug is fixed, this test
-    // my need to be changed.
-    checkLibrary(r'''
-library meta;
-const checked = null;
-class A<T> {
-  void f(@checked T t) {}
-}
-''');
-  }
-
-  void test_covariant_parameter_inherited() {
-    // Note: due to dartbug.com/27393, the keyword "checked" is identified by
-    // its presence in a library called "meta".  If that bug is fixed, this test
-    // my need to be changed.
-    checkLibrary(r'''
-library meta;
-const checked = null;
-class A<T> {
-  void f(@checked T t) {}
-}
-class B<T> extends A<T> {
-  void f(T t) {}
-}
-''');
-  }
-
   test_defaultValue_refersToGenericClass_constructor() {
     checkLibrary('''
 class B<T> {
   const B();
 }
 class C<T> {
   const C([B<T> b = const B()]);
 }
 ''');
   }
@@ skipping 232 matching lines @@
     var typeA = library.definingCompilationUnit.getType('B').supertype;
     expect(typeA.element.source.shortName, 'foo_io.dart');
   }
 
   test_exports() {
     addLibrarySource('/a.dart', 'library a;');
     addLibrarySource('/b.dart', 'library b;');
     checkLibrary('export "a.dart"; export "b.dart";');
   }
 
+  test_field_covariant() {
+    checkLibrary('''
+class C {
+  covariant int x;
+}''');
+  }
+
   test_field_documented() {
     checkLibrary('''
 class C {
   /**
    * Docs
    */
   var x;
 }''');
   }
 
@@ skipping 1051 matching lines @@
   test_method_inferred_type_nonStatic_implicit_param() {
     checkLibrary('class C extends D { void f(value) {} }'
         ' abstract class D { void f(int value); }');
   }
 
   test_method_inferred_type_nonStatic_implicit_return() {
     checkLibrary(
         'class C extends D { f() => null; } abstract class D { int f(); }');
   }
 
-  test_method_parameter_parameters() {
-    checkLibrary('class C { f(g(x, y)) {} }');
-  }
-
-  test_method_parameter_parameters_in_generic_class() {
-    checkLibrary('class C<A, B> { f(A g(B x)) {} }');
-  }
-
-  test_method_parameter_return_type() {
-    checkLibrary('class C { f(int g()) {} }');
-  }
-
-  test_method_parameter_return_type_void() {
-    checkLibrary('class C { f(void g()) {} }');
-  }
-
   test_method_type_parameter() {
     prepareAnalysisContext(createOptions());
     checkLibrary('class C { T f<T, U>(U u) => null; }');
   }
 
   test_method_type_parameter_in_generic_class() {
     prepareAnalysisContext(createOptions());
     checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
   }
 
@@ skipping 79 matching lines @@
   }
 
   test_operator_index_set() {
     checkLibrary('class C { void operator[]=(int i, bool v) {} }');
   }
 
   test_operator_less_equal() {
     checkLibrary('class C { bool operator<=(C other) => false; }');
   }
 
+  void test_parameter_checked() {
+    // Note: due to dartbug.com/27393, the keyword "checked" is identified by
+    // its presence in a library called "meta".  If that bug is fixed, this test
+    // my need to be changed.
+    checkLibrary(r'''
+library meta;
+const checked = null;
+class A<T> {
+  void f(@checked T t) {}
+}
+''');
+  }
+
+  void test_parameter_checked_inherited() {
+    // Note: due to dartbug.com/27393, the keyword "checked" is identified by
+    // its presence in a library called "meta".  If that bug is fixed, this test
+    // my need to be changed.
+    checkLibrary(r'''
+library meta;
+const checked = null;
+class A<T> {
+  void f(@checked T t) {}
+}
+class B<T> extends A<T> {
+  void f(T t) {}
+}
+''');
+  }
+
+  test_parameter_covariant() {
+    prepareAnalysisContext(createOptions());
+    checkLibrary('class C { void m(covariant C c) {} }');
+  }
+
+  void test_parameter_covariant_inherited() {
+    checkLibrary(r'''
+class A<T> {
+  void f(covariant T t) {}
+}
+class B<T> extends A<T> {
+  void f(T t) {}
+}
+''');
+  }
+
+  test_parameter_parameters() {
+    checkLibrary('class C { f(g(x, y)) {} }');
+  }
+
+  test_parameter_parameters_in_generic_class() {
+    checkLibrary('class C<A, B> { f(A g(B x)) {} }');
+  }
+
+  test_parameter_return_type() {
+    checkLibrary('class C { f(int g()) {} }');
+  }
+
+  test_parameter_return_type_void() {
+    checkLibrary('class C { f(void g()) {} }');
+  }
+
   test_parameterTypeNotInferred_constructor() {
     // Strong mode doesn't do type inference on constructor parameters, so it's
     // ok that we don't store inferred type info for them in summaries.
     checkLibrary('''
 class C {
   C.positional([x = 1]);
   C.named({x: 1});
 }
 ''');
   }
@@ skipping 54 matching lines @@
 
   test_propagated_type_refers_to_closure() {
     checkLibrary('''
 void f() {
   var x = () => 0;
   var y = x;
 }
 ''');
   }
 
+  test_setter_covariant() {
+    checkLibrary('class C { void set x(covariant int value); }');
+  }
+
   test_setter_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 void set x(value) {}''');
   }
 
   test_setter_external() {
@@ skipping 522 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }