Issue 28491. Add support for UnlinkedExprOperation.pushSuper even though it is not allowed.

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 422 matching lines @@
       } else if (o is PropertyAccess &&
           o.target is PrefixedIdentifier &&
           r is SimpleIdentifier) {
         // We don't resynthesize property access when it takes the form
         // `prefixName.className.staticMember`.  We just resynthesize a
         // SimpleIdentifier correctly resolved to the static member.
         PrefixedIdentifier oTarget = o.target;
         checkElidablePrefix(oTarget.prefix);
         checkElidablePrefix(oTarget.identifier);
         compareConstAsts(r, o.propertyName, desc);
+      } else if (o is SuperExpression && r is SuperExpression) {
+        // Nothing to compare.
       } else if (o is ThisExpression && r is ThisExpression) {
         // Nothing to compare.
       } else if (o is NullLiteral) {
         expect(r, new isInstanceOf<NullLiteral>(), reason: desc);
       } else if (o is BooleanLiteral && r is BooleanLiteral) {
         expect(r.value, o.value, reason: desc);
       } else if (o is IntegerLiteral && r is IntegerLiteral) {
         expect(r.value, o.value, reason: desc);
       } else if (o is DoubleLiteral && r is DoubleLiteral) {
         if (r.value != null &&
@@ skipping 235 matching lines @@
     expect(resynthesized.name, original.name);
     expect(resynthesized.nameOffset, original.nameOffset, reason: desc);
     expect(rImpl.codeOffset, oImpl.codeOffset, reason: desc);
     expect(rImpl.codeLength, oImpl.codeLength, reason: desc);
     expect(resynthesized.documentationComment, original.documentationComment,
         reason: desc);
     compareMetadata(resynthesized.metadata, original.metadata, desc);
 
     // Validate modifiers.
     for (Modifier modifier in Modifier.values) {
+      // There is no way to know this by looking at declarations.
+      if (modifier == Modifier.REFERENCES_SUPER) {

[Paul Berry, 2017/01/29 14:28:02]

We can't safely do this.  The modifier REFERENCES_SUPER *is* used for analysis
(it's used to detect if a class gets used illegaly as a mixin when "supermixin"
support isn't enabled).  So we need to check that it's resynthesized correctly.

In fact, looking through the code, it looks like you've uncovered a preexisting
bug in summaries: support for this modifier was never added to the summary
logic.  This means that if a user has "supermixin" support disabled, and they
try to mix in a class that references super, and that class comes from a
summary, an error won't be properly reported.

I've filed a bug to track this: https://github.com/dart-lang/sdk/issues/28553

Rather than skip the REFERENCES_SUPER check here, would you mind marking the
corresponding resynthesis test as failing, and referencing the bug in a comment?

[scheglov, 2017/01/29 18:05:15]

Done.

+        continue;
+      }
       bool got = _hasModifier(resynthesized, modifier);
       bool want = _hasModifier(original, modifier);
       expect(got, want,
           reason: 'Mismatch in $desc.$modifier: got $got, want $want');
     }
 
     // Validate members.
     if (oImpl is Member) {
       expect(rImpl, new isInstanceOf<Member>(), reason: desc);
     } else {
@@ skipping 1647 matching lines @@
 
   test_const_topLevel_prefix() {
     checkLibrary(r'''
 const vNotEqual = 1 != 2;
 const vNot = !true;
 const vNegate = -1;
 const vComplement = ~1;
 ''');
   }
 
+  test_const_topLevel_super() {
+    checkLibrary(r'''
+const vSuper = super;
+''');
+  }
+
   test_const_topLevel_this() {
     checkLibrary(r'''
 const vThis = this;
 ''');
   }
 
   test_const_topLevel_typedList() {
     checkLibrary(r'''
 const vNull = const <Null>[];
 const vDynamic = const <dynamic>[1, 2, 3];
@@ skipping 2438 matching lines @@
   }
 
   test_typedef_type_parameters_f_bound_simple() {
     checkLibrary('typedef U F<T extends U, U>(T t);');
   }
 
   test_typedefs() {
     checkLibrary('f() {} g() {}');
   }
 
+  test_unresolved_annotation_instanceCreation_argument_super() {
+    checkLibrary(
+        '''
+class A {
+  const A(_);
+}
+
+@A(super)
+class C {}
+''',
+        allowErrors: true);
+  }
+
   test_unresolved_annotation_instanceCreation_argument_this() {
     checkLibrary(
         '''
 class A {
   const A(_);
 }
 
 @A(this)
 class C {}
 ''',
@@ skipping 221 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }