Fix summarization of unresolved annotations.

pkg/analyzer/test/src/summary/summary_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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 7788 matching lines @@
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'A',
                     absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'foo')
               ])
     ]);
   }
 
+  test_metadata_constructor_call_named_prefixed_unresolved_class() {
+    addNamedSource('/foo.dart', '');
+    UnlinkedClass cls = serializeClassText(
+        'import "foo.dart" as foo; @foo.A.named() class C {}',
+        allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.invokeConstructor,
+    ], ints: [
+      0,
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+          expectedKind: ReferenceKind.unresolved,
+          prefixExpectations: [
+            new _PrefixExpectation(ReferenceKind.unresolved, 'A'),
+            new _PrefixExpectation(ReferenceKind.prefix, 'foo')
+          ],
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
+  test_metadata_constructor_call_named_prefixed_unresolved_constructor() {
+    addNamedSource('/foo.dart', 'class A {}');
+    UnlinkedClass cls = serializeClassText(
+        'import "foo.dart" as foo; @foo.A.named() class C {}',
+        allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.invokeConstructor,
+    ], ints: [
+      0,
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+          expectedKind: ReferenceKind.unresolved,
+          prefixExpectations: [
+            new _PrefixExpectation(ReferenceKind.classOrEnum, 'A',
+                absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart'),
+            new _PrefixExpectation(ReferenceKind.prefix, 'foo')
+          ],
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
+  test_metadata_constructor_call_named_unresolved_class() {
+    UnlinkedClass cls =
+        serializeClassText('@A.named() class C {}', allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.invokeConstructor,
+    ], ints: [
+      0,
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+          expectedKind: ReferenceKind.unresolved,
+          prefixExpectations: [
+            new _PrefixExpectation(ReferenceKind.unresolved, 'A')
+          ],
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
+  test_metadata_constructor_call_named_unresolved_constructor() {
+    UnlinkedClass cls = serializeClassText('class A {} @A.named() class C {}',
+        allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.invokeConstructor,
+    ], ints: [
+      0,
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+          expectedKind: ReferenceKind.unresolved,
+          prefixExpectations: [
+            new _PrefixExpectation(ReferenceKind.classOrEnum, 'A')
+          ],
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
   test_metadata_constructor_call_unnamed() {
     UnlinkedClass cls =
         serializeClassText('class A { const A(); } @A() class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
@@ skipping 11 matching lines @@
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/foo.dart'), 'foo.dart', 'A',
           expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'foo')
     ]);
   }
 
+  test_metadata_constructor_call_unnamed_prefixed_unresolved() {
+    addNamedSource('/foo.dart', '');
+    UnlinkedClass cls = serializeClassText(
+        'import "foo.dart" as foo; @foo.A() class C {}',
+        allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.invokeConstructor,
+    ], ints: [
+      0,
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'A',
+          expectedKind: ReferenceKind.unresolved,
+          expectedPrefix: 'foo',
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
+  test_metadata_constructor_call_unnamed_unresolved() {
+    UnlinkedClass cls =
+        serializeClassText('@A() class C {}', allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.invokeConstructor,
+    ], ints: [
+      0,
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'A',
+          expectedKind: ReferenceKind.unresolved,
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
   test_metadata_constructor_call_with_args() {
     UnlinkedClass cls =
         serializeClassText('class A { const A(x); } @A(null) class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedConstOperation.pushNull,
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       1
@@ skipping 148 matching lines @@
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'b',
           expectedKind: ReferenceKind.topLevelPropertyAccessor,
           expectedPrefix: 'a')
     ]);
   }
 
+  test_metadata_prefixed_variable_unresolved() {
+    addNamedSource('/a.dart', '');
+    UnlinkedClass cls = serializeClassText(
+        'import "a.dart" as a; @a.b class C {}',
+        allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.pushReference
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'b',
+          expectedKind: ReferenceKind.unresolved,
+          expectedPrefix: 'a',
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
   test_metadata_simpleFormalParameter() {
     checkAnnotationA(serializeExecutableText('const a = null; f(@a x) {}')
         .parameters[0]
         .annotations);
   }
 
   test_metadata_simpleFormalParameter_withDefault() {
     checkAnnotationA(
         serializeExecutableText('const a = null; f([@a x = null]) {}')
             .parameters[0]
@@ skipping 24 matching lines @@
         .typeParameters[0]
         .annotations);
   }
 
   test_metadata_typeParameter_ofTypedef() {
     checkAnnotationA(serializeTypedefText('const a = null; typedef F<@a T>();')
         .typeParameters[0]
         .annotations);
   }
 
+  test_metadata_variable_unresolved() {
+    UnlinkedClass cls = serializeClassText('@a class C {}', allowErrors: true);
+    expect(cls.annotations, hasLength(1));
+    _assertUnlinkedConst(cls.annotations[0], operators: [
+      UnlinkedConstOperation.pushReference
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'a',
+          expectedKind: ReferenceKind.unresolved,
+          checkAstDerivedDataOverride: true)
+    ]);
+  }
+
   test_method_documented() {
     String text = '''
 class C {
   /**
    * Docs
    */
   f() {}
 }''';
     UnlinkedExecutable executable = serializeClassText(text).executables[0];
     expect(executable.documentationComment, isNotNull);
@@ skipping 1316 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }