Index defined top-level and class member names.

pkg/analyzer/test/src/summary/index_unit_test.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
@@ skipping 32 matching lines @@
 
   _ElementIndexAssert assertThat(Element element) {
     return new _ElementIndexAssert(this, element);
   }
 
   CompilationUnitElement importedUnit({int index: 0}) {
     List<ImportElement> imports = testLibraryElement.imports;
     return imports[index].importedLibrary.definingCompilationUnit;
   }
 
+  void test_definedName_classMember_field() {
+    _indexTestUnit('''
+class A {
+  int f;
+}''');
+    _assertDefinedName('f', IndexNameKind.classMember, 'f;');
+  }
+
+  void test_definedName_classMember_getter() {
+    _indexTestUnit('''
+class A {
+  int get g => 0;
+}''');
+    _assertDefinedName('g', IndexNameKind.classMember, 'g => 0;');
+  }
+
+  void test_definedName_classMember_method() {
+    _indexTestUnit('''
+class A {
+  m() {}
+}''');
+    _assertDefinedName('m', IndexNameKind.classMember, 'm() {}');
+  }
+
+  void test_definedName_classMember_operator() {
+    _indexTestUnit('''
+class A {
+  operator +(o) {}
+}''');
+    _assertDefinedName('+', IndexNameKind.classMember, '+(o) {}');
+  }
+
+  void test_definedName_classMember_setter() {
+    _indexTestUnit('''
+class A {
+  int set s (_) {}
+}''');
+    _assertDefinedName('s', IndexNameKind.classMember, 's (_) {}');
+  }
+
+  void test_definedName_topLevel_class() {
+    _indexTestUnit('class A {}');
+    _assertDefinedName('A', IndexNameKind.topLevel, 'A {}');
+  }
+
+  void test_definedName_topLevel_classAlias() {
+    _indexTestUnit('''
+class M {}
+class C = Object with M;''');
+    _assertDefinedName('C', IndexNameKind.topLevel, 'C =');
+  }
+
+  void test_definedName_topLevel_enum() {
+    _indexTestUnit('enum E {a, b, c}');
+    _assertDefinedName('E', IndexNameKind.topLevel, 'E {');
+  }
+
+  void test_definedName_topLevel_function() {
+    _indexTestUnit('foo() {}');
+    _assertDefinedName('foo', IndexNameKind.topLevel, 'foo() {}');
+  }
+
+  void test_definedName_topLevel_functionTypeAlias() {
+    _indexTestUnit('typedef F(int p);');
+    _assertDefinedName('F', IndexNameKind.topLevel, 'F(int p);');
+  }
+
+  void test_definedName_topLevel_getter() {
+    _indexTestUnit('''
+int get g => 0;
+''');
+    _assertDefinedName('g', IndexNameKind.topLevel, 'g => 0;');
+  }
+
+  void test_definedName_topLevel_setter() {
+    _indexTestUnit('''
+int set s (_) {}
+''');
+    _assertDefinedName('s', IndexNameKind.topLevel, 's (_) {}');
+  }
+
+  void test_definedName_topLevel_topLevelVariable() {
+    _indexTestUnit('var V = 42;');
+    _assertDefinedName('V', IndexNameKind.topLevel, 'V = 42;');
+  }
+
   void test_isExtendedBy_ClassDeclaration() {
     _indexTestUnit('''
 class A {} // 1
 class B extends A {} // 2
 ''');
     ClassElement elementA = findElement('A');
     assertThat(elementA).isExtendedAt('A {} // 2');
   }
 
   void test_isExtendedBy_ClassDeclaration_Object() {
@@ skipping 447 matching lines @@
 
   void test_isReferencedBy_typeInVariableList() {
     _indexTestUnit('''
 class A {}
 A myVariable = null;
 ''');
     Element element = findElement('A');
     assertThat(element).isReferencedAt('A myVariable');
   }
 
+  void _assertDefinedName(String name, IndexNameKind kind, String search) {
+    int offset = findOffset(search);
+    int nameId = _getStringId(name);
+    for (int i = 0; i < unitIndex.definedNames.length; i++) {
+      if (unitIndex.definedNames[i] == nameId &&
+          unitIndex.definedNameKinds[i] == kind &&
+          unitIndex.definedNameOffsets[i] == offset) {
+        return;
+      }
+    }
+    _failWithIndexDump('Not found $name $kind at $offset');
+  }
+
   /**
    * Asserts that [unitIndex] has an item with the expected properties.
    */
   void _assertHasRelation(
       Element element,
       IndexRelationKind expectedRelationKind,
       ExpectedLocation expectedLocation) {
     int elementId = _findElementId(element);
     int matchIndex;
     for (int i = 0; i < unitIndex.locationOffsets.length; i++) {
@@ skipping 64 matching lines @@
     for (int i = 0; i < packageIndex.elementLibraryUris.length; i++) {
       if (packageIndex.elementLibraryUris[i] == libraryUriId &&
           packageIndex.elementUnitUris[i] == unitUriId) {
         return i;
       }
     }
     _failWithIndexDump('Unit $unitElement of $element is not referenced');
     return -1;
   }
 
+  int _getStringId(String str) {
+    int id = packageIndex.strings.indexOf(str);
+    expect(id, isNonNegative);
+    return id;
+  }
+
   int _getUriId(Uri uri) {
     String str = uri.toString();
-    int id = packageIndex.uris.indexOf(str);
-    expect(id, isNonNegative);
-    return id;
+    return _getStringId(str);
   }
 
   void _indexTestUnit(String code) {
     resolveTestUnit(code);
     PackageIndexAssembler assembler = new PackageIndexAssembler();
     assembler.index(testUnit);
     // assemble, write and read
     PackageIndexBuilder indexBuilder = assembler.assemble();
     List<int> indexBytes = indexBuilder.toBuffer();
     packageIndex = new PackageIndex.fromBuffer(indexBytes);
@@ skipping 39 matching lines @@
         test._expectedLocation(search, length: length));
   }
 
   void isReferencedQualifiedAt(String search, {int length}) {
     test._assertHasRelation(
         element,
         IndexRelationKind.IS_REFERENCED_QUALIFIED_BY,
         test._expectedLocation(search, length: length));
   }
 }