Enforce LinkedReference.dependency == 0 for contained entities.

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/generated/engine.dart';
@@ skipping 1580 matching lines @@
 import 'a.dart';
 const v = const C<int, String>.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'named',
+        checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                  absoluteUri: absUri('/a.dart'),
+                  relativeUri: 'a.dart',
                   numTypeParameters: 2)
             ],
             allowTypeParameters: true);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_named_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'named',
+        checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                  absoluteUri: absUri('/a.dart'),
+                  relativeUri: 'a.dart',
                   numTypeParameters: 2),
               new _PrefixExpectation(ReferenceKind.prefix, 'p',
                   inLibraryDefiningUnit: true)
             ],
             allowTypeParameters: true);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
@@ skipping 116 matching lines @@
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'named',
+      (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
+                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'named',
+      (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C'),
+                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p',
                     inLibraryDefiningUnit: true)
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   const C(a, b, c, d, {e, f, g});
@@ skipping 110 matching lines @@
   static const int length = 0;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const int v = p.C.length;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'length',
+      (EntityRef r) => checkTypeRef(r, null, null, 'length',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p',
                     inLibraryDefiningUnit: true)
               ])
     ]);
   }
 
@@ skipping 409 matching lines @@
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.F;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'F',
+      (EntityRef r) => checkTypeRef(r, null, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
+                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.F;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'F',
+      (EntityRef r) => checkTypeRef(r, null, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C'),
+                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p',
                     inLibraryDefiningUnit: true),
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static m() {}
@@ skipping 19 matching lines @@
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.m;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'm',
+      (EntityRef r) => checkTypeRef(r, null, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
+                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.m;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'm',
+      (EntityRef r) => checkTypeRef(r, null, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C'),
+                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
+                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p',
                     inLibraryDefiningUnit: true)
               ])
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction() {
     UnlinkedVariable variable = serializeVariableText('''
 f() {}
 const v = f;
@@ skipping 1893 matching lines @@
         getTypeRefForSlot(cls.executables[0].parameters[1].inferredTypeSlot);
     // Check that parameter g's inferred type is the type implied by D.f's 1st
     // (zero-based) parameter.
     expect(type.implicitFunctionTypeIndices, [1]);
     expect(type.paramReference, 0);
     expect(type.typeArguments, isEmpty);
     expect(type.reference,
         greaterThanOrEqualTo(unlinkedUnits[0].references.length));
     LinkedReference linkedReference =
         linked.units[0].references[type.reference];
-    int expectedDep =
-        checkHasDependency(absUri('/b.dart'), 'b.dart', fullyLinked: true);
-    expect(linkedReference.dependency, expectedDep);
+    expect(linkedReference.dependency, 0);
     expect(linkedReference.kind, ReferenceKind.method);
     expect(linkedReference.name, 'f');
     expect(linkedReference.numTypeParameters, 0);
     expect(linkedReference.unit, 0);
     expect(linkedReference.containingReference, isNot(0));
     expect(linkedReference.containingReference, lessThan(type.reference));
     checkReferenceIndex(
         linkedReference.containingReference, absUri('/b.dart'), 'b.dart', 'E');
   }
 
@@ skipping 987 matching lines @@
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
+  /**
+   * Verify invariants of the given [linkedLibrary].
+   */
+  void validateLinkedLibrary(LinkedLibrary linkedLibrary) {
+    for (LinkedUnit unit in linkedLibrary.units) {
+      for (LinkedReference reference in unit.references) {
+        switch (reference.kind) {
+          case ReferenceKind.classOrEnum:
+          case ReferenceKind.typedef:

[scheglov, 2016/02/05 21:15:13]

The list of case(s) is almost sorted.
Maybe worth to move "typedef" after "topLevelFunction".

[Paul Berry, 2016/02/05 21:19:16]

Done.

+          case ReferenceKind.topLevelPropertyAccessor:
+          case ReferenceKind.topLevelFunction:
+            // This reference can have either a zero or a nonzero dependency,
+            // since it refers to top level element which might or might not be
+            // imported from another library.
+            break;
+          case ReferenceKind.prefix:
+            // Prefixes should have a dependency of 0, since they come from the
+            // current library.
+            expect(reference.dependency, 0,
+                reason: 'Nonzero dependency for prefix');
+            break;
+          case ReferenceKind.unresolved:
+            // Unresolved references always have a dependency of 0.
+            expect(reference.dependency, 0,
+                reason: 'Nonzero dependency for undefined');
+            break;
+          default:
+            // This reference should have a dependency of 0, since it refers to
+            // an element that is contained within some other element.
+            expect(reference.dependency, 0,
+                reason: 'Nonzero dependency for ${reference.kind}');
+        }
+      }
+    }
+  }
+
   void _assertUnlinkedConst(UnlinkedConst constExpr,
       {List<UnlinkedConstOperation> operators,
       List<int> ints: const <int>[],
       List<double> doubles: const <double>[],
       List<String> strings: const <String>[],
       List<_EntityRefValidator> referenceValidators:
           const <_EntityRefValidator>[]}) {
     expect(constExpr, isNotNull);
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
@@ skipping 16 matching lines @@
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.inLibraryDefiningUnit: false,
       this.absoluteUri,
       this.relativeUri,
       this.numTypeParameters: 0});
 }